Optional inplace, perf gain, no accuracy loss 3/3

Author: Azzaare

src/genetic.jl

@@ -8,22 +8,6 @@ function generate_population(icn, pop_size)
     return population
 end
 
-"""
-    loss(X, X_sols, icn, weigths, metric)
-Compute the loss of `icn`.
-"""
-function loss(solutions, non_sltns, icn, weigths, metric, dom_size, param; samples=nothing)
-    compo = compose(icn, weigths)
-    f = composition(compo)
-    X = if isnothing(samples)
-        Iterators.flatten((solutions, non_sltns))
-    else
-        Iterators.flatten((solutions, rand(non_sltns, samples)))
-    end
-    σ = sum(x -> abs(f(x; param, dom_size) - metric(x, solutions)), X) + regularization(icn)
-    return σ
-end
-
 """
     _optimize!(icn, X, X_sols; metric = hamming, pop_size = 200)
 Optimize and set the weigths of an ICN with a given set of configuration `X` and solutions `X_sols`.
@@ -40,11 +24,18 @@ function _optimize!(
     samples=nothing,
     memoize=false,
 )
-    _metric = memoize ? (@memoize Dict memoize_metric(x, X) = metric(x, X)) : metric
-    _bias = memoize ? (@memoize Dict memoize_bias(x) = weigths_bias(x)) : weigths_bias
-    fitness =
-        w ->
-            loss(solutions, non_sltns, icn, w, _metric, dom_size, param; samples) + _bias(w)
+    inplace = zeros(dom_size, max_icn_length())
+    _non_sltns = isnothing(samples) ? non_sltns : rand(non_sltns, samples)
+
+    function fitness(w)
+        compo = compose(icn, w)
+        f = composition(compo)
+        S = Iterators.flatten((solutions, _non_sltns))
+        return sum(x -> abs(f(x; X=inplace, param, dom_size) - metric(x, solutions)), S) +
+               regularization(icn) +
+               weigths_bias(w)
+    end
+    _fitness = memoize ? (@memoize Dict memoize_fitness(w) = fitness(w)) : fitness
 
     _icn_ga = GA(;
         populationSize=pop_size,
@@ -57,7 +48,7 @@ function _optimize!(
     )
 
     pop = generate_population(icn, pop_size)
-    r = Evolutionary.optimize(fitness, pop, _icn_ga, Evolutionary.Options(; iterations))
+    r = Evolutionary.optimize(_fitness, pop, _icn_ga, Evolutionary.Options(; iterations))
     return weights!(icn, Evolutionary.minimizer(r))
 end
 

src/icn.jl

@@ -24,7 +24,7 @@ mutable struct ICN
         co_layer=comparison_layer(param),
     )
         w = generate_weights([tr_layer, ar_layer, ag_layer, co_layer])
-        new(tr_layer, ar_layer, ag_layer, co_layer, w)
+        return new(tr_layer, ar_layer, ag_layer, co_layer, w)
     end
 end
 
@@ -75,7 +75,7 @@ Set the weights of an ICN with a `BitVector`.
 function weights!(icn, weigths)
     length(weigths) == nbits(icn) || @warn icn weigths
     @assert length(weigths) == nbits(icn)
-    icn.weigths = weigths
+    return icn.weigths = weigths
 end
 
 """
@@ -107,14 +107,20 @@ function regularization(icn)
     return Σop / (Σmax + 1)
 end
 
-max_icn_length(icn = ICN(param = true)) = length(icn.transformation)
+max_icn_length(icn=ICN(; param=true)) = length(icn.transformation)
 
 """
     _compose(icn)
 Internal function called by `compose` and `show_composition`.
 """
 function _compose(icn::ICN)
-    !is_viable(icn) && (return ((x; param=nothing, dom_size=0) -> typemax(Float64)), [])
+    !is_viable(icn) && (
+        return (
+            (x; X=zeros(length(x), max_icn_length()), param=nothing, dom_size=0) ->
+                typemax(Float64)
+        ),
+        []
+    )
 
     funcs = Vector{Vector{Function}}()
     symbols = Vector{Vector{Symbol}}()
@@ -148,11 +154,10 @@ function _compose(icn::ICN)
 
     function composition(x; X=zeros(length(x), length(funcs[1])), param=nothing, dom_size)
         tr_in(Tuple(funcs[1]), X, x, param)
-        for i in 1:length(x)
-            X[i,1] = funcs[2][1](@view X[i,:])
-        end
-        funcs[3][1](@view X[:, 1]) |>
-        (y -> funcs[4][1](y; param, dom_size, nvars=length(x)))
+        X[:, 1] .= 1:length(x) .|> (i -> funcs[2][1](@view X[i, 1:length(funcs[1])]))
+        return (y -> funcs[4][1](y; param, dom_size, nvars=length(x)))(
+            funcs[3][1](@view X[:, 1])
+        )
     end
 
     return composition, symbols

src/learn.jl

@@ -72,7 +72,7 @@ function explore_learn_compose(
     ),
     memoize=false,
 )
-    dom_size = maximum(domain_size, domains)
+    dom_size = maximum(length, domains)
     solutions, non_sltns = configurations
     return learn_compose(
         solutions,