Use the functions directly instead of Symbols in resnet

Also fix `tuplify`

Author: theabhirath

src/convnets/resnets/core.jl

@@ -292,7 +292,7 @@ function resnet(img_dims, stem, get_layers, block_repeats::AbstractVector{<:Inte
     return Chain(backbone, classifier_fn(nfeaturemaps))
 end
 
-function resnet(block_type::Symbol, block_repeats::AbstractVector{<:Integer},
+function resnet(block_type, block_repeats::AbstractVector{<:Integer},
                 downsample_opt::NTuple{2, Any} = (downsample_conv, downsample_identity);
                 cardinality::Integer = 1, base_width::Integer = 64, inplanes::Integer = 64,
                 reduction_factor::Integer = 1, imsize::Dims{2} = (256, 256),
@@ -304,7 +304,7 @@ function resnet(block_type::Symbol, block_repeats::AbstractVector{<:Integer},
     # Build stem
     stem = stem_fn(; inchannels)
     # Block builder
-    if block_type === :basicblock
+    if block_type == basicblock
         @assert cardinality==1 "Cardinality must be 1 for `basicblock`"
         @assert base_width==64 "Base width must be 64 for `basicblock`"
         get_layers = basicblock_builder(block_repeats; inplanes, reduction_factor,
@@ -314,15 +314,15 @@ function resnet(block_type::Symbol, block_repeats::AbstractVector{<:Integer},
                                         planes_fn = resnet_planes,
                                         downsample_tuple = downsample_opt,
                                         kwargs...)
-    elseif block_type === :bottleneck
+    elseif block_type == bottleneck
         get_layers = bottleneck_builder(block_repeats; inplanes, cardinality, base_width,
                                         reduction_factor, activation, norm_layer, revnorm,
                                         attn_fn, drop_block_rate, drop_path_rate,
                                         stride_fn = resnet_stride,
                                         planes_fn = resnet_planes,
                                         downsample_tuple = downsample_opt,
                                         kwargs...)
-    elseif block_type === :bottle2neck
+    elseif block_type == bottle2neck
         @assert drop_block_rate==0.0 "DropBlock not supported for `bottle2neck`"
         @assert drop_path_rate==0.0 "DropPath not supported for `bottle2neck`"
         @assert reduction_factor==1 "Reduction factor not supported for `bottle2neck`"
@@ -346,12 +346,12 @@ function resnet(block_fn, block_repeats, downsample_opt::Symbol = :B; kwargs...)
 end
 
 # block-layer configurations for ResNet-like models
-const RESNET_CONFIGS = Dict(18 => (:basicblock, [2, 2, 2, 2]),
-                            34 => (:basicblock, [3, 4, 6, 3]),
-                            50 => (:bottleneck, [3, 4, 6, 3]),
-                            101 => (:bottleneck, [3, 4, 23, 3]),
-                            152 => (:bottleneck, [3, 8, 36, 3]))
+const RESNET_CONFIGS = Dict(18 => (basicblock, [2, 2, 2, 2]),
+                            34 => (basicblock, [3, 4, 6, 3]),
+                            50 => (bottleneck, [3, 4, 6, 3]),
+                            101 => (bottleneck, [3, 4, 23, 3]),
+                            152 => (bottleneck, [3, 8, 36, 3]))
 
-const LRESNET_CONFIGS = Dict(50 => (:bottleneck, [3, 4, 6, 3]),
-                             101 => (:bottleneck, [3, 4, 23, 3]),
-                             152 => (:bottleneck, [3, 8, 36, 3]))
+const LRESNET_CONFIGS = Dict(50 => (bottleneck, [3, 4, 6, 3]),
+                             101 => (bottleneck, [3, 4, 23, 3]),
+                             152 => (bottleneck, [3, 8, 36, 3]))

src/convnets/resnets/res2net.jl

@@ -33,10 +33,10 @@ function bottle2neck(inplanes::Integer, planes::Integer; stride::Integer = 1,
                 for _ in 1:max(1, scale - 1)]
     reslayer = is_first ? Parallel(cat_channels, pool, conv_bns...) :
                Parallel(cat_channels, identity, Chain(PairwiseFusion(+, conv_bns...)))
-    if is_first
-        tuplify(x) = tuple(x...)
+    tuplify = if is_first
+        x -> tuple(x...)
     else
-        tuplify(x) = tuple(x[1], tuple(x[2:end]...))
+        x -> tuple(x[1], tuple(x[2:end]...))
     end
     layers = [conv_norm((1, 1), inplanes => width * scale, activation;
                         norm_layer, revnorm, bias = false)...,
@@ -102,8 +102,8 @@ end
 function Res2Net(depth::Integer; pretrain::Bool = false, scale::Integer = 4,
                  base_width::Integer = 26, inchannels::Integer = 3,
                  nclasses::Integer = 1000)
-    _checkconfig(depth, sort(collect(keys(RESNET_CONFIGS)))[3:end])
-    layers = resnet(:bottle2neck, RESNET_CONFIGS[depth][2]; base_width, scale,
+    _checkconfig(depth, keys(LRESNET_CONFIGS))
+    layers = resnet(bottle2neck, LRESNET_CONFIGS[depth][2]; base_width, scale,
                     inchannels, nclasses)
     if pretrain
         loadpretrain!(layers, string("Res2Net", depth, "_", base_width, "x", scale))
@@ -143,7 +143,7 @@ function Res2NeXt(depth::Integer; pretrain::Bool = false, scale::Integer = 4,
                   base_width::Integer = 4, cardinality::Integer = 8,
                   inchannels::Integer = 3, nclasses::Integer = 1000)
     _checkconfig(depth, keys(LRESNET_CONFIGS))
-    layers = resnet(:bottle2neck, LRESNET_CONFIGS[depth][2]; base_width, scale,
+    layers = resnet(bottle2neck, LRESNET_CONFIGS[depth][2]; base_width, scale,
                     cardinality, inchannels, nclasses)
     if pretrain
         loadpretrain!(layers,

test/convnets.jl

@@ -33,7 +33,7 @@ end
     end
 
     @testset "resnet" begin
-        @testset for block_fn in [:basicblock, :bottleneck]
+        @testset for block_fn in [Metalhead.basicblock, Metalhead.bottleneck]
             layer_list = [
                 [2, 2, 2, 2],
                 [3, 4, 6, 3],