Problem in ResNet50 backbone of "Image segmentation" example

[cdsousa]

I suspect that the following code line from the Image segmentation example

backbone = Metalhead.ResNet50(pretrain=true).layers[1:end-3]

is not doing what is intended since ResNet50 from Metalhead (https://github.com/darsnack/Metalhead.jl/tree/darsnack/vision-refactor) returns a 2 item Chain (backbone and head), and the 1:end-3 indexing returns an empty Chain.

Funny enough, with the model return by methodmodel (basically a Conv((1,1), 3=>32)) the example still works and is able to produce some image segmentation (does it works like just a pixel color indexer?).

I'd say the expected code should be something Metalhead.ResNet50(pretrain=true).layers[1].layers and I would open a PR, but I'm not sure since, with that, the example fails later in the training loop.

[darsnack]

Yeah there were some last minute changes to that PR to create this "backbone/head" structure. Those changes will need to be reflected in FastAI.jl. Thanks for catching this!

[cdsousa]

Doing backbone = Metalhead.ResNet50(pretrain=true).layers[1], which I thing is the correct way, gives an error in the methodmodel(method, backbone) part, something like

layer SkipConnection(Chain(.........), index 6 in Chain, gave an error with input of size (16, 16, 1024, 1)

Do you think this has some easy fix or will it take a big effort to fix?
I'd like to help but I have no knowledge about this stuff.

[darsnack]

It seems like it could be an easy fix, but the complete stack trace will tell us the actual error. Do you mind posting that?

[cdsousa]

Sure thing. Here it is:

┌ Error: layer SkipConnection(Chain(Parallel(+, Chain(Conv((1, 1), 1024 => 512, stride=2, bias=false), BatchNorm(512, relu), Conv((3, 3), 512 => 512, pad=1, bias=false), BatchNorm(512, relu), Conv((1, 1), 512 => 2048, bias=false), BatchNorm(2048, relu)), Chain(Conv((1, 1), 1024 => 2048, stride=2, bias=false), BatchNorm(2048, relu))), Chain(Parallel(+, Chain(Conv((1, 
1), 2048 => 512, bias=false), BatchNorm(512, relu), Conv((3, 3), 512 => 512, pad=1, bias=false), BatchNorm(512, relu), Conv((1, 1), 512 => 2048, bias=false), BatchNorm(2048, relu)), identity), Parallel(+, Chain(Conv((1, 1), 2048 => 512, bias=false), BatchNorm(512, relu), Conv((3, 3), 512 => 512, pad=1, bias=false), BatchNorm(512, relu), Conv((1, 1), 512 => 2048, bias=false), BatchNorm(2048, relu)), identity), AdaptiveMeanPool((1, 1))), Chain(PixelShuffle(2), Chain(Conv((3, 3), 512 => 1024, pad=1), BatchNorm(1024, relu)))), #32), index 6 in Chain, gave an error with input of size (16, 16, 1024, 1)
└ @ Flux C:\Users\xxxxxxxxxxx\.julia\packages\Flux\Zz9RI\src\outputsize.jl:107
ERROR: LoadError: DimensionMismatch("mismatch in dimension 1 (expected 2 got 16)")
Stacktrace:
  [1] _cs
    @ .\abstractarray.jl:1626 [inlined]
  [2] _cshp
    @ .\abstractarray.jl:1622 [inlined]
  [3] _cat_size_shape
    @ .\abstractarray.jl:1602 [inlined]
  [4] cat_size_shape(dims::Tuple{Bool, Bool, Bool}, X::Array{Flux.NilNumber.Nil, 4}, tail::Array{Flux.NilNumber.Nil, 4})   
    @ Base .\abstractarray.jl:1600
  [5] _cat_t(::Int64, ::Type{Flux.NilNumber.Nil}, ::Array{Flux.NilNumber.Nil, 4}, ::Vararg{Array{Flux.NilNumber.Nil, 4}, N} where N)
    @ Base .\abstractarray.jl:1646
  [6] cat_t(::Type{Flux.NilNumber.Nil}, ::Array{Flux.NilNumber.Nil, 4}, ::Vararg{Array{Flux.NilNumber.Nil, 4}, N} where N; 
dims::Int64)
    @ Base .\abstractarray.jl:1643
  [7] _cat
    @ .\abstractarray.jl:1782 [inlined]
  [8] #cat#129
    @ .\abstractarray.jl:1781 [inlined]
  [9] (::FastAI.Models.var"#32#34"{NTuple{4, Int64}})(mx::Array{Flux.NilNumber.Nil, 4}, x::Array{Flux.NilNumber.Nil, 4})
    @ FastAI.Models C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:54
 [10] (::SkipConnection{Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}}, Chain{Tuple{PixelShuffle, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}}}, FastAI.Models.var"#32#34"{NTuple{4, Int64}}})(input::Array{Flux.NilNumber.Nil, 4})
    @ Flux C:\Users\xxxxxxxxxxx\.julia\packages\Flux\Zz9RI\src\layers\basic.jl:279
 [11] outputsize(m::Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 
4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, 
typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, SkipConnection{Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}}, Chain{Tuple{PixelShuffle, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}}}, FastAI.Models.var"#32#34"{NTuple{4, Int64}}}}}, inputsizes::NTuple{4, Int64}; padbatch::Bool)
    @ Flux C:\Users\xxxxxxxxxxx\.julia\packages\Flux\Zz9RI\src\outputsize.jl:104
 [12] outputsize(m::Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 
4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, 
typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, SkipConnection{Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Chain{Tuple{Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}}, Chain{Tuple{PixelShuffle, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}}}, FastAI.Models.var"#32#34"{NTuple{4, Int64}}}}}, inputsizes::NTuple{4, Int64})      
    @ Flux C:\Users\xxxxxxxxxxx\.julia\packages\Flux\Zz9RI\src\outputsize.jl:101
 [13] unet_from_layers(backbonelayers::Vector{Any}, insz::NTuple{4, Int64}; fdownscale::Int64, upsample::typeof(FastAI.Models.upsample_block_small), agg::Function, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}) 
    @ FastAI.Models C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:70
 [14] unet_from_layers(backbonelayers::Vector{Any}, insz::NTuple{4, Int64}; fdownscale::Int64, upsample::typeof(FastAI.Models.upsample_block_small), agg::Function, kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}) 
(repeats 3 times)
    @ FastAI.Models C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:64
 [15] unet_from_layers(backbonelayers::Vector{Any}, insz::NTuple{4, Int64})
    @ FastAI.Models C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:56
 [16] UNetDynamic(backbone::Chain{Tuple{Conv{2, 2, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, MaxPool{2, 2}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), 
Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, 
Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, 
BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}}, inputsize::NTuple{4, Int64}, final::FastAI.Models.var"#29#30"{Int64}; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ FastAI.Models C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:38
 [17] UNetDynamic
    @ C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:37 [inlined]
 [18] #UNetDynamic#28
    @ C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:45 [inlined]
 [19] UNetDynamic
    @ C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\models\unet.jl:44 [inlined]
 [20] blockmodel(inblock::FastAI.ImageTensor{2}, outblock::FastAI.OneHotTensor{2, String}, backbone::Chain{Tuple{Conv{2, 2, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, MaxPool{2, 2}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 
4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, 
typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, 
Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, 
Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, 
Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}}; kwargs::Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ FastAI C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\datablock\models.jl:41
 [21] blockmodel
    @ C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\datablock\models.jl:41 [inlined]
 [22] methodmodel(method::BlockMethod{Tuple{Image{2}, Mask{2, String}}, Tuple{ProjectiveTransforms{2}, ImagePreprocessing{FixedPointNumbers.N0f8, 3, ColorTypes.RGB{FixedPointNumbers.N0f8}, Float32}, OneHot{DataType}}, FastAI.OneHotTensor{2, String}}, backbone::Chain{Tuple{Conv{2, 2, typeof(identity), Array{Float32, 4}, Vector{Float32}}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, MaxPool{2, 2}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, 
Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), 
Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), 
Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, 
typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), 
Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, Parallel{typeof(+), Tuple{Chain{Tuple{Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}, Conv{2, 4, typeof(identity), Array{Float32, 4}, Flux.Zeros}, BatchNorm{typeof(relu), Vector{Float32}, Float32, Vector{Float32}}}}, typeof(identity)}}, AdaptiveMeanPool{4, 2}}})
    @ FastAI C:\Users\xxxxxxxxxxx\.julia\packages\FastAI\4mXj2\src\datablock\method.jl:50
 [23] top-level scope
    @ c:\Users\xxxxxxxxxxx\yyyyyyyyyyy\imgsegm.jl:47
in expression starting at c:\Users\xxxxxxxxxxx\yyyyyyyyyyy\imgsegm.jl:47     

I can also post the display of the ResNet50.

[DhairyaLGandhi]

We can definitely improve the error by not showing the layer in there, and just reference to it

[darsnack]

I agree, we should use a compact representation of the layer instead of the full thing. Probably some \n characters in there too cause there are three separate pieces of info being delivered in a single line.

@cdsousa The quick fix for user code should be

backbone = Metalhead.ResNet50(pretrain=true).layers[1][1:(end - 1)]

The real issue is that the AdaptiveMeanPool should not be part of the backbone. The actual fix will be to Metalhead.jl to change these lines to be

  return Chain(Chain(layers...),
               Chain(AdaptiveMeanPool((1, 1)), flatten, Dense(inplanes, nclasses)))

If you would like to make a PR, then we'd appreciate the help!

[cdsousa]

Thanks @lorenzoh for doing the fix. I didn't proceed doing the PR because I was not able to check if everything fully worked as my laptop has only 4GB of VRAM which was not enough to run the training.