remove name from at-compact

Author: mcabbott

src/compact.jl

@@ -68,20 +68,6 @@ for epoch in 1:1000
   Flux.train!((m,x,y) -> (m(x) - y)^2, model, data, optim)
 end
 ```
-
-You may also specify a `name` for the model, which will
-be used instead of the default printout, which gives a verbatim
-representation of the code used to construct the model:
-
-```
-model = @compact(w=rand(3), name="Linear(3 => 1)") do x
-  sum(w .* x)
-end
-println(model)  # "Linear(3 => 1)"
-```
-
-This can be useful when using `@compact` to hierarchically construct
-complex models to be used inside a `Chain`.
 """
 macro compact(_exs...)
   # check inputs, extracting function expression fex and unprocessed keyword arguments _kwexs
@@ -108,16 +94,6 @@ macro compact(_exs...)
   kwexs2 = map(ex -> Expr(:kw, ex.args...), _kwexs) # handle keyword arguments provided before semicolon
   kwexs = (kwexs1..., kwexs2...)
 
-  # check if user has named layer:
-  name = findfirst(ex -> ex.args[1] == :name, kwexs)
-  if name !== nothing && kwexs[name].args[2] !== nothing
-    length(kwexs) == 1 && error("expects keyword arguments")
-    name_str = kwexs[name].args[2]
-    # remove name from kwexs (a tuple)
-    kwexs = (kwexs[1:name-1]..., kwexs[name+1:end]...)
-    name = name_str
-  end
-
   # make strings
   layer = "@compact"
   setup = NamedTuple(map(ex -> Symbol(string(ex.args[1])) => string(ex.args[2]), kwexs))
@@ -136,7 +112,7 @@ macro compact(_exs...)
   fex = supportself(fex, vars)
 
   # assemble
-  return esc(:($CompactLayer($fex, $name, ($layer, $input, $block), $setup; $(kwexs...))))
+  return esc(:($CompactLayer($fex, ($layer, $input, $block), $setup; $(kwexs...))))
 end
 
 function supportself(fex::Expr, vars)
@@ -155,12 +131,11 @@ end
 
 struct CompactLayer{F,NT1<:NamedTuple,NT2<:NamedTuple}
   fun::F
-  name::Union{String,Nothing}
   strings::NTuple{3,String}
   setup_strings::NT1
   variables::NT2
 end
-CompactLayer(f::Function, name::Union{String,Nothing}, str::Tuple, setup_str::NamedTuple; kw...) = CompactLayer(f, name, str, setup_str, NamedTuple(kw))
+CompactLayer(f::Function, str::Tuple, setup_str::NamedTuple; kw...) = CompactLayer(f, str, setup_str, NamedTuple(kw))
 (m::CompactLayer)(x...) = m.fun(m.variables, x...)
 CompactLayer(args...) = error("CompactLayer is meant to be constructed by the macro")
 Flux.@functor CompactLayer
@@ -179,19 +154,9 @@ end
 
 function Flux._big_show(io::IO, obj::CompactLayer, indent::Int=0, name=nothing)
   setup_strings = obj.setup_strings
-  local_name = obj.name
-  has_explicit_name = local_name !== nothing
-  if has_explicit_name
-    if indent != 0 || length(Flux.params(obj)) <= 2
-      _just_show_params(io, local_name, obj, indent)
-    else  # indent == 0
-      print(io, local_name)
-      Flux._big_finale(io, obj)
-    end
-  else  # no name, so print normally
     layer, input, block = obj.strings
     pre, post = ("(", ")")
-    println(io, " "^indent, isnothing(name) ? "" : "$name = ", layer, pre)
+    println(io, " "^indent, "@compact", pre)
     for k in keys(obj.variables)
       v = obj.variables[k]
       if Flux._show_leaflike(v)
@@ -220,7 +185,6 @@ function Flux._big_show(io::IO, obj::CompactLayer, indent::Int=0, name=nothing)
     else
       println(io, ",")
     end
-  end
 end
 
 # Modified from src/layers/show.jl

test/compact.jl

@@ -118,15 +118,6 @@ end
     @test similar_strings(get_model_string(model), expected_string)
   end
 
-  @testset "Custom naming" begin
-    model = @compact(w=Dense(32, 32), name="Linear(...)") do x, y
-      tmp = sum(w(x))
-      return tmp + y
-    end
-    expected_string = "Linear(...)         # 1_056 parameters"
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
   @testset "Hierarchical models" begin
     model1 = @compact(w1=Dense(32=>32, relu), w2=Dense(32=>32, relu)) do x
       w2(w1(x))
@@ -148,6 +139,28 @@ end
     @test similar_strings(get_model_string(model2), expected_string)
   end
 
+#=  # This test is broken:
+
+julia> model1 = @compact(w1=Dense(32=>32, relu), w2=Dense(32=>32, relu)) do x
+             w2(w1(x));
+
+julia> model2 = @compact(w1=model1, w2=Dense(32=>32, relu)) do x
+             w2(w1(x))
+           end
+@compact(
+  @compact(
+    w1 = Dense(32 => 32, relu),         # 1_056 parameters
+    w2 = Dense(32 => 32, relu),         # 1_056 parameters
+  ) do x 
+      w2(w1(x))
+  end,
+  w2 = Dense(32 => 32, relu),           # 1_056 parameters
+) do x 
+    w2(w1(x))
+end                  # Total: 6 arrays, 3_168 parameters, 13.239 KiB.
+
+=#
+
   @testset "Array parameters" begin
     model = @compact(x=randn(32), w=Dense(32=>32)) do s
       w(x .* s)
@@ -161,41 +174,6 @@ end
     @test similar_strings(get_model_string(model), expected_string)
   end
 
-  @testset "Hierarchy with inner model named" begin
-    model = @compact(
-      w1=@compact(w1=randn(32, 32), name="Model(32)") do x
-        w1 * x
-      end,
-      w2=randn(32, 32),
-      w3=randn(32),
-    ) do x
-      w2 * w1(x)
-    end
-    expected_string = """@compact(
-      Model(32),                            # 1_024 parameters
-      w2 = randn(32, 32),                   # 1_024 parameters
-      w3 = randn(32),                       # 32 parameters
-    ) do x 
-        w2 * w1(x)
-    end                  # Total: 3 arrays, 2_080 parameters, 17.089 KiB."""
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
-  @testset "Hierarchy with outer model named" begin
-    model = @compact(
-      w1=@compact(w1=randn(32, 32)) do x
-        w1 * x
-      end,
-      w2=randn(32, 32),
-      w3=randn(32),
-      name="Model(32)"
-    ) do x
-      w2 * w1(x)
-    end
-    expected_string = """Model(32)                  # Total: 3 arrays, 2_080 parameters, 17.057KiB."""
-    @test similar_strings(get_model_string(model), expected_string)
-  end
-
   @testset "Dependent initializations" begin
     # Test that initialization lines cannot depend on each other
     @test_throws UndefVarError @compact(y = 3, z = y^2) do x