Re: Error in `optimize!`

[mdhe1248]

Hi,
I wanted to update deformation. I ran the script below in flash.wustl.edu:/mnt/donghoon_030/20170412

using JLD
using Images, Unitful, FixedSizeArrays, JLD, AxisArrays
using BlockRegistration

fnmm = "/mnt/donghoon_030/20170412/exp2_20170412" #mm `base` name without "_i"`

#### Load data
Es, cs, Qs, knots, mmis = jldopen(string(fnmm, "_", 1, ".mm"), mmaparrays=true) do file
    read(file, "Es"), read(file, "cs"), read(file, "Qs"), read(file, "knots"), read(file, "mmis")
end

#### Calculate deformation (It may take several hours)
λ_old = 1e-6
λt_old = 1e-5
ap = AffinePenalty(knots, λ)
ϕs_old, penalty = fixed_λ(cs, Qs, knots, ap, λt, mmis; show_trace=true, iterations=5)

λ = 1e-7
λt = 1e-3
ϕs, penalty = fixed_λ(cs, Qs, knots, ap, λt, mmis; show_trace=true, iterations=5)

#### Optimization
ϕ_1, fval_1, fval0_1 = optimize!(ϕs, ϕs_old, ap, mmis);
ϕ_2, fval_2, fval0_2 = optimize!(ϕs, ϕs_old, ap, λt,  mmis);

Is this correct implementation? Should it update ϕs based on ϕs_old, ap, mmis?

I obtained this error:

julia> ϕ, fval, fval0 = optimize!(ϕ, ϕs_old, ap, mmis);
ERROR: MethodError: no method matching maxshift(::Float32)
Closest candidates are:
  maxshift(::CenterIndexedArrays.CenterIndexedArray{ND<:RegisterCore.NumDenom,N,A}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterCore.jl:226
  maxshift{T,N}(::CachedInterpolations.CachedInterpolation{T,N,M,O}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:1044
 in #_optimize!#5(::Array{Any,1}, ::Function, ::RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{Float32,8}}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float32,8}, ::Float64, ::Int64) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:432
 in #optimize!#4(::Float64, ::Int64, ::Array{Any,1}, ::Function, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float32,8}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:426
 in optimize!(::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float32,8}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:425

[timholy]

The only reason to update the deformation is if you warp the moving image and recalculate all of the mismatch-related parameters for the warped image (Es, cs, Qs, and mmis).

[timholy]

And if you're doing whole-experiment registration, that would basically require that you write out a disk file with the intermediate warped image.

[mdhe1248]

Ah, I just wanted to briefly test it if optimize! works.
I will try from the beginning with small data set.
The procedure would be then (I only listed some key parameters),

1. Calculate mm using the original image: obtain mmis_old and other parameters.
2. Obtain ϕs_old using fixed_λ. And warp the original image.
3. Calculate mm using warped image: obtain mmis, and other parameters.
4. Get ap. Get ϕs using fixed_λ.
5. Run optimized_ϕs, fval, fval0 = optimize!(ϕs, ϕs_old, ap, mmis)
6. Warp the original image using an optimized_ϕs.

[timholy]

Yes, that's right. No guarantees that it will be any better than ϕs_old (one can always hope...)

[timholy]

I should also say that this isn't heavily tested so you're likely to get the same issue. Is mmis an array of CenterIndexedArrays (or something similar)? If it's an array of real values, check out the various versions of fixed_lambda (in RegisterOptimize) that convert from an Array{Tf} to the mmisc version.

[mdhe1248]

That was my concern.

julia> typeof(mmis)  
Array{Float32,8} 

I think this is it:
The 3rd and 4th lines from the bottom convert mmis -> mmisr -> mmisc.

function fixed_λ{Tf<:Number,T,N}(cs::Array{Tf}, Qs::Array{Tf}, knots::NTuple{N}, ap::AffinePenalty{T,N}, λt, mmis::Array{Tf}; kwargs...)
    csr = reinterpret(Vec{N,Tf}, cs, tail(size(cs)))
    Qsr = reinterpret(Mat{N,N,Tf}, Qs, tail(tail(size(Qs))))
    if length(mmis) > 10^7
        L = length(mmis)*sizeof(Tf)/1024^3
        @printf "The mismatch data are %0.2f GB in size.\n  During optimization, the initial function evaluations may be limited by I/O and\n  could be very slow. Later evaluations should be faster.\n" L
    end
    ND = NumDenom{Tf}
    mmisr = reinterpret(ND, mmis, tail(size(mmis)))
    mmisc = cachedinterpolators(mmisr, N, ntuple(d->(size(mmisr,d)+1)>>1, N))
    fixed_λ(csr, Qsr, knots, ap, λt, mmisc; kwargs...)
end

and maxshift function is being used here line 4.

function _optimize!(objective, ϕ, dp, mmis, tol, print_level; kwargs...)
    uvec = u_as_vec(ϕ)
    T = eltype(uvec)
    mxs = maxshift(first(mmis))

    solver = IpoptSolver(;hessian_approximation="limited-memory",
                         print_level=print_level,
                         sb="yes",
                         tol=tol, kwargs...)
    m = MathProgBase.NonlinearModel(solver)
    ub1 = T[mxs...] - T(RegisterFit.register_half)
    ub = repeat(ub1, outer=[div(length(uvec), length(ub1))])
    MathProgBase.loadproblem!(m, length(uvec), 0, -ub, ub, T[], T[], :Min, objective)
    MathProgBase.setwarmstart!(m, uvec)
    fval0 = MathProgBase.eval_f(objective, uvec)
    isfinite(fval0) || error("Initial value must be finite")
    MathProgBase.optimize!(m)

    stat = MathProgBase.status(m)
    stat == :Optimal || warn("Solution was not optimal")
    uopt = MathProgBase.getsolution(m)
    fval = MathProgBase.getobjval(m)
    _copy!(ϕ, uopt)
    ϕ, fval, fval0
end

[mdhe1248]

mmisc seems to be passed into this function:

"""
`ϕs, penalty = fixed_λ(cs, Qs, knots, affinepenalty, λt, mmis)`
computes an optimal vector-of-deformations `ϕs` for an image sequence,
using an temporal penalty coefficient `λt`.
"""
function fixed_λ{T,N,_}(cs::AbstractArray{Vec{N,T}}, Qs::AbstractArray{Mat{N,N,T}}, knots::NTuple{N}, ap::AffinePenalty{_,N}, λt, mmis; mu_init=0.1, kwargs...)
    λtT = T(λt)
    apT = convert(AffinePenalty{T,N}, ap)
    maxshift = map(x->(x-1)>>1, size(first(mmis)))
    print("Calculating initial guess (this may take a while)...")
    u0, isconverged = initial_deformation(apT, λtT, cs, Qs)
    println("done")
    if !isconverged
        Base.warn_once("initial_deformation failed to converge with λ = ", ap.λ, ", λt = ", λt)
    end
    uclamp!(u0, maxshift)
    colons = ntuple(ColonFun, Val{N})
    ϕs = [GridDeformation(u0[colons..., i], knots) for i = 1:size(u0)[end]]
    local mismatch
    println("Starting optimization.") 
    optimize!(ϕs, identity, apT, λtT, mmis; kwargs...)
end

[timholy]

Yes, what I'm basically saying is that you might have to imitate the creation of mmisc and pass that. The issue is that saving it to disk destroys some of the "julia" structure and that's why, when you load it, it comes back as a plain array.

[mdhe1248]

Okay,
I changed added one more optimize! function.

function optimize!{Tf<:Number, T, N}(ϕ, ϕ_old, dp::AffinePenalty{T,N}, mmis::Array{Tf})
    ND = NumDenom{Tf}
    mmisr = reinterpret(ND, mmis, tail(size(mmis)));
    mmisc = cachedinterpolators(mmisr, N, ntuple(d->(size(mmisr,d)+1)>>1, N))
    optimize!(ϕ, ϕ_old, dp::DeformationPenalty, mmisc) 
end

Would it be a suitable solution? hm. Is dp::DeformationPenalty the same as dp::AffinePenalty? I may delete ::DeformationPenalty.

After I run this modification, I got another error. I haven't looked at it carefully yet.

ERROR: MethodError: no method matching createProblem(::Int64, ::Array{Float32,1}, ::Array{Float32,1}, ::Int64, ::Array{Float32,1}, ::Array{Float32,1}, ::Int64, ::Int64, ::Ipopt.#eval_f_cb#4{RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Arr
ay{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}}, ::Ipopt.#eval_g_cb#6{RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDefor
mation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}}, :
:Ipopt.#eval_grad_f_cb#5{RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}}, ::Ipopt.#eval_jac_g_cb#7{RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Fl
oat32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}}, ::Void)
Closest candidates are:
  createProblem(::Int64, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Int64, ::Any, ::Any, ::Any, ::Any, ::Any) 
at /home/donghoon/.julia/v0.5/Ipopt/src/Ipopt.jl:171
  createProblem(::Int64, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Array{Float64,1}, ::Array{Float64,1}, ::Int64, ::Int64, ::Any, ::Any, ::Any, ::Any) at /hom
e/donghoon/.julia/v0.5/Ipopt/src/Ipopt.jl:171
 in loadproblem!(::Ipopt.IpoptMathProgModel, ::Int64, ::Int64, ::Array{Float32,1}, ::Array{Float32,1}, ::Array{Float32,1}, ::Array{Float32,1}, ::Symbol, ::RegisterOpti
mize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformat
ion{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{Reg
isterCore.NumDenom{Float32},3,7,(21,21,4)},4}}) at /home/donghoon/.julia/v0.5/Ipopt/src/IpoptSolverInterface.jl:92
 in #_optimize!#5(::Array{Any,1}, ::Function, ::RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},
LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{F
loat64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array
{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.Num
Denom{Float32},3,7,(21,21,4)},4}, ::Float64, ::Int64) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:441
 in #optimize!#4(::Float64, ::Int64, ::Array{Any,1}, ::Function, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace
{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Flo
at64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/Registe
rOptimize.jl:426
 in #__optimize!#20(::Float64, ::Int64, ::Array{Any,1}, ::Function, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSp
ace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{
Float64,3}, ::Array{Float32,8}) at ./REPL[91]:6
 in __optimize!(::Array{RegisterDeformation.GridDeformation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDe
formation{Float32,3,Array{FixedSizeArrays.Vec{3,Float32},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float32,8}) at ./REPL[91]:2

[timholy]

Would it be a suitable solution?

Yes!

Is dp::DeformationPenalty the same as dp::AffinePenalty? I may delete ::DeformationPenalty

You don't need the ::DeformationPenalty annotation on the last of your function (it doesn't do anything). DeformationPenalty is the abstract type:

julia> supertype(AffinePenalty)
RegisterPenalty.DeformationPenalty{T,N}

We used to use a different penalty but switched to the affine penalty. (See https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3745275/ for a sense of just how many choices there are...)

After I run this modification, I got another error.

Looks like Ipopt (which is a C++ optimizer called by Julia) only supports Float64.

[mdhe1248]

Converting Es, cs, Qs, mmis into Float64 resolved the error above.
for example, I ran the below:

cs = convert(Array{Float64, length(size(cs))}, cs)

Now I get another error:

julia> optimize!(ϕs, ϕs_old, ap, mmis)
ERROR: MethodError: no method matching zero(::Type{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}}})
Closest candidates are:
  zero(::Type{Base.LibGit2.Oid}) at libgit2/oid.jl:88
  zero(::Type{Base.Pkg.Resolve.VersionWeights.VWPreBuildItem}) at pkg/resolve/versionweight.jl:80
  zero(::Type{Base.Pkg.Resolve.VersionWeights.VWPreBuild}) at pkg/resolve/versionweight.jl:120
  ...
 in penalty!(::Void, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.Gr
idDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedIn
terpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}, ::BitArray{4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterPenalty.jl:80
 in penalty!(::Void, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.Gr
idDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedIn
terpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterPenalty.jl:79
 in #_optimize!#7(::Array{Any,1}, ::Function, ::RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},L
inSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Flo
at64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{Fi
xedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDeno
m{Float32},3,7,(21,21,4)},4}, ::Float64, ::Int64) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:451
 in #optimize!#4(::Float64, ::Int64, ::Array{Any,1}, ::Function, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{
Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float
64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOp
timize.jl:426
 in optimize!(::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDefor
mation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpola
tion{RegisterCore.NumDenom{Float32},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:425
 in optimize!(::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDefor
mation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float32,8}) at /home/donghoon/.julia
/v0.5/BlockRegistration/src/RegisterOptimize.jl:434

It seems zero(eltype(ϕs)) gives the error message.

[timholy]

Maybe replace that line with local val.

[timholy]

Oh, wait, you'll hit an error on the last line. Perhaps you need something like this:

numbertype{G<:GridDeformation}(ϕs::AbstractVector{G}) = numbertype(first(ϕs))
numbertype(ϕ) = eltype(ϕ)

and use T = numbertype(ϕ) instead of T = eltype(ϕ) on line 79.

[mdhe1248]

I got another error in compose.
This seems like a type error like the one above.

julia> ϕ_1, fval_1, fval0_1 = optimize!(ϕs, ϕs_old, ap, mmis);
ERROR: MethodError: no method matching compose(::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1})
 in penalty!(::Void, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}, ::BitArray{4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterPenalty.jl:86
 in penalty!(::Void, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterPenalty.jl:79
 in #_optimize!#7(::Array{Any,1}, ::Function, ::RegisterOptimize.DeformOpt{Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1},Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1},RegisterPenalty.AffinePenalty{Float64,3},Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}, ::Float64, ::Int64) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:451
 in #optimize!#4(::Float64, ::Int64, ::Array{Any,1}, ::Function, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:426
 in optimize!(::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{CachedInterpolations.CachedInterpolation{RegisterCore.NumDenom{Float64},3,7,(21,21,4)},4}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:425
 in optimize!(::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::Array{RegisterDeformation.GridDeformation{Float64,3,Array{FixedSizeArrays.Vec{3,Float64},3},LinSpace{Float64}},1}, ::RegisterPenalty.AffinePenalty{Float64,3}, ::Array{Float64,8}) at /home/donghoon/.julia/v0.5/BlockRegistration/src/RegisterOptimize.jl:434

[timholy]

It's basically the same thing: compose has been defined for a single deformation but not an array of deformations. You could add a compose method (to GridDeformations) like this:

compose{G1<:GridDeformation, G2<:GridDeformation}(ϕs_old::AbstractVector{G1}, ϕs_new::AbstractVector{G2}) = map(compose, ϕs_old, ϕs_new)