Enhance the accuracy of the GA (#14)

* Enhance the accuracy of the GA

* Tests, doc

* Tests errors

* Compat and tag new version v0.0.3

* Coverage

Author: Azzaare

Manifest.toml

@@ -86,6 +86,12 @@ uuid = "ade2ca70-3891-5945-98fb-dc099432e06a"
 deps = ["Mmap"]
 uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
 
+[[Dictionaries]]
+deps = ["Indexing", "Random"]
+git-tree-sha1 = "73ddbf30bc6488a72c4a7a05b54f21b59c6c74fb"
+uuid = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
+version = "0.3.6"
+
 [[DiffResults]]
 deps = ["StaticArrays"]
 git-tree-sha1 = "c18e98cba888c6c25d1c3b048e4b3380ca956805"
@@ -130,6 +136,12 @@ version = "0.10.14"
 deps = ["Random"]
 uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820"
 
+[[Indexing]]
+deps = ["Test"]
+git-tree-sha1 = "0cf3ac621cd74b1d03af0cc4275f680b2070a5cc"
+uuid = "313cdc1a-70c2-5d6a-ae34-0150d3930a38"
+version = "1.1.0"
+
 [[InteractiveUtils]]
 deps = ["Markdown"]
 uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240"

Project.toml

@@ -1,18 +1,20 @@
 name = "CompositionalNetworks"
 uuid = "4b67e4b5-442d-4ef5-b760-3f5df3a57537"
 authors = ["Jean-François Baffier"]
-version = "0.0.2"
+version = "0.0.3"
 
 [deps]
 CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+Dictionaries = "85a47980-9c8c-11e8-2b9f-f7ca1fa99fb4"
 Evolutionary = "86b6b26d-c046-49b6-aa0b-5f0f74682bd6"
 OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [compat]
 CSV = "0.8"
 DataFrames = "0.22"
+Dictionaries = "0.3"
 Evolutionary = "0.7"
 OrderedCollections = "1.3"
 julia = "1.5"

src/CompositionalNetworks.jl

@@ -1,11 +1,12 @@
 module CompositionalNetworks
 
 # Imports
-import Evolutionary: GA, tournament, singlepoint, flip, optimize, minimizer, rouletteinv, minimizer
+import Evolutionary: GA, tournament, singlepoint, flip, optimize, minimizer, Options, summary, trace, rouletteinv
 import Random: bitrand, falses
 import OrderedCollections: LittleDict
 import DataFrames: DataFrame, Not
 import CSV: CSV
+import Dictionaries: Dictionary, set!
 
 # Exports utilities
 export lazy, lazy_param, csv2space

src/genetic.jl

@@ -4,7 +4,7 @@ Generate a pôpulation of weigths (individuals) for the genetic algorithm weigth
 """
 function _generate_population(icn, pop_size)
     population = Vector{BitVector}()
-    foreach(_ -> push!(population, _generate_weights(icn)), 1:pop_size)
+    foreach(_ -> push!(population, falses(_nbits(icn))), 1:pop_size)
     return population
 end
 
@@ -18,44 +18,42 @@ function _loss(X, X_sols, icn, weigths, metric)
 end
 
 """
-    _single_point(v1::T, v2::T, icn) where {T <: AbstractVector}
-    _flip(recombinant::T, icn) where {T <: BitVector}
-Meta functions that add individuals a viability check in `Evolutionary.singlepoint` and `Evolutionary.flip`.
-"""
-function _single_point(v1::T, v2::T, icn) where {T <: AbstractVector}
-    while true
-        c1, c2 = singlepoint(v1, v2)
-        _is_viable(icn, c1) && _is_viable(icn, c2) && (return c1, c2)
-    end
-end
-function _flip(recombinant::T, icn) where {T <: BitVector}
-    c = deepcopy(recombinant)
-    while true
-        flip(c)
-        _is_viable(icn, c) && (recombinant = c: break)
-    end
-end
-
-"""
-    _optimize!(icn, X, X_sols; ga = GA(), metric = hamming, pop_size = 200)
+    _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`.
 """
-function _optimize!(icn, X, X_sols; ga = GA(), metric = hamming, pop_size = 200)
+function _optimize!(icn, X, X_sols; metric=hamming, pop_size=200, iter=100)
     fitness = weigths -> _loss(X, X_sols, icn, weigths, metric)
 
-    _viable_single_point = (v1, v2) -> _single_point(v1, v2, icn)
-    _viable_flip = v -> _flip(v, icn)
     _icn_ga = GA(
-        populationSize = pop_size,
-        crossoverRate = 0.4,
-        epsilon = 0.03,
-        selection = rouletteinv,
-        crossover = _viable_single_point,
-        mutation = _viable_flip,
-        mutationRate = 0.8
+        populationSize=pop_size,
+        crossoverRate=0.8,
+        epsilon=0.05,
+        selection=tournament(2),
+        crossover=singlepoint,
+        mutation=flip,
+        mutationRate=1.0
     )
 
     pop = _generate_population(icn, pop_size)
-    res = optimize(fitness, pop, _icn_ga)
+    res = optimize(fitness, pop, _icn_ga, Options(iterations=iter))
     _weigths!(icn, minimizer(res))
 end
+
+"""
+    optimize!(icn, X, X_sols, global_iter, local_iter; metric=hamming, popSize=100)
+Optimize and set the weigths of an ICN with a given set of configuration `X` and solutions `X_sols`. The best weigths among `global_iter` will be set. 
+"""
+
+function optimize!(icn, X, X_sols, global_iter, local_iter; metric=hamming, popSize=100)
+    results = Dictionary{BitVector,Int}()
+    @info "Starting optimization of weights"
+    for i in 1:global_iter
+        @info "Iteration $i"
+        _optimize!(icn, X, X_sols; iter = local_iter, metric = metric, pop_size = popSize)
+        _incsert!(results, _weigths(icn))
+    end
+    best = rand(findall(x -> x == maximum(results), results))
+    _weigths!(icn, best)
+    @info show_composition(icn) best results
+    return best, results
+end

src/icn.jl

@@ -154,14 +154,18 @@ end
 Return the regularization value of an ICN weights, which is proportional to the normalized number of operations selected in the icn layers.
 """
 function regularization(icn)
+    Σmax = 0 
     Σop = 0
     _start = 0
     _end = 0
     for layer in _layers(icn)
         l = _length(layer)
         _start = _end + 1
         _end += _exclu(layer) ? _nbits_exclu(layer) : l
-        Σop += _selected_size(layer, @view _weigths(icn)[_start:_end])
+        if !_exclu(layer)
+            Σop += _selected_size(layer, @view _weigths(icn)[_start:_end])
+            Σmax += _length(layer)
+        end
     end
-    return Σop / (_length(icn) + 1)
+    return Σop / (Σmax + 1)
 end

src/layer.jl

@@ -66,6 +66,15 @@ function _generate_inclusive_operations(predicate, bits)
     end
     return ind
 end
+# function _generate_inclusive_operations(predicate, bits)
+#     ind = falses(bits)
+#     s = Set(1:bits)
+#     r = rand(1:bits)
+#     for i in 1:r
+#         ind[pop!(s,rand(s))] = true
+#     end
+#     return ind
+# end
 function _generate_exclusive_operation(max_op_number)
     op = rand(1:max_op_number)
     return _as_bitvector(op, max_op_number)

src/utils.jl

@@ -68,3 +68,7 @@ function _reduce_symbols(symbols, sep, parenthesis = true)
     str = reduce((x,y) -> "$y$sep$x", symbols)
     return parenthesis ? "[$str]" : str
 end
+
+function _incsert!(d::Dictionary, ind)
+    set!(d, ind, isassigned(d, ind) ? d[ind] + 1 : 1)
+end

test/icn.jl

@@ -1,6 +1,6 @@
 # # Test with manually weighted ICN
 
-icn = ICN(nvars = 4, dom_size = 4, param = 2)
+icn = ICN(nvars=4, dom_size=4, param=2)
 show_layers(icn)
 icn.weigths = vcat(trues(18), falses(6))
 
@@ -14,13 +14,16 @@ v = [1,2,4,3]
 
 ## Test GA
 
-X_sol = csv2space("../data/csv/complete_ad-4-4.csv"; filter = :solutions)
+X_sol = csv2space("../data/csv/complete_ad-4-4.csv"; filter=:solutions)
 @test hamming([1,2,3,3], X_sol) == 1
 
 X = csv2space("../data/csv/complete_ad-4-4.csv")
-icn = ICN(nvars = 4, dom_size = 4, param = 0)
+icn = ICN(nvars=4, dom_size=4)
 
 CN._optimize!(icn, X, X_sol)
 @test CN._is_viable(icn)
 err = compose(icn)
 @test err([1,2,3,3]) > 0.0
+@info show_composition(icn)
+
+CN.optimize!(icn, X, X_sol, 10, 100)

test/layers.jl

@@ -56,10 +56,12 @@ funcs = Dict(
     ],
 )
 
-for (f, results) in funcs, (key, vals) in enumerate(data)
-    @test f(vals.first) == results[key]
-    foreach(i -> f(i, vals.first), vals.first)
+for (f, results) in funcs
     @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first) == results[key]
+        foreach(i -> f(i, vals.first), vals.first)
+    end
 end
 
 # Test transformations with parameter
@@ -90,20 +92,26 @@ funcs_param = Dict(
     ],
 )
 
-for (f, results) in funcs_param, (key, vals) in enumerate(data)
-    @test f(vals.first, vals.second) == results[key]
-    foreach(i -> f(i, vals.first, vals.second), vals.first)
+for (f, results) in funcs_param    
     @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first, vals.second) == results[key]
+        foreach(i -> f(i, vals.first, vals.second), vals.first)
+    end
 end
 
 # arithmetic layer
+@info CN._ar_sum
 @test CN._ar_sum(map(p -> p.first, data)) == [2, 7, 5, 6, 4]
+@info CN._ar_prod
 @test CN._ar_prod(map(p -> p.first, data)) == [1, 10, 6, 8, 3]
 
 # aggregation layer
+@info CN._ag_sum
 @test CN._ag_sum(data[1].first) == 15
 @test CN._ag_sum(data[2].first) == 9
 
+@info CN._ag_count_positive
 @test CN._ag_count_positive(data[1].first) == 5
 @test CN._ag_count_positive(data[2].first) == 5
 @test CN._ag_count_positive([1, 0, 1, 0, 1]) == 3
@@ -116,8 +124,11 @@ funcs = [
 ]
 
 # test no param/vars
-for (f, results) in funcs, (key, vals) in enumerate(data)
-    @test f(vals.first) == results[key]
+for (f, results) in funcs
+    @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first) == results[key]
+    end
 end
 
 funcs_param = [
@@ -126,8 +137,11 @@ funcs_param = [
     CN._co_param_minus_val => [0, 5],
 ]
 
-for (f, results) in funcs_param, (key, vals) in enumerate(data)
-    @test f(vals.first, vals.second[1]) == results[key]
+for (f, results) in funcs_param
+    @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first, vals.second[1]) == results[key]
+    end
 end
 
 funcs_vars = [
@@ -136,23 +150,31 @@ funcs_vars = [
     CN._co_vars_minus_val => [2, 0],
 ]
 
-for (f, results) in funcs_vars, (key, vals) in enumerate(data)
-    @test f(vals.first, vals.second[2]) == results[key]
+for (f, results) in funcs_vars
+    @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first, vals.second[2]) == results[key]
+    end
 end
 
-
 funcs_param_dom = [
     CN._co_euclidian_param => [3.5, 2.0],
 ]
 
-for (f, results) in funcs_param_dom, (key, vals) in enumerate(data)
-    @test f(vals.first, vals.second[1], vals.second[2]) ≈ results[key]
+for (f, results) in funcs_param_dom
+    @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first, vals.second[1], vals.second[2]) ≈ results[key]
+    end
 end
 
 funcs_dom = [
-    CN._co_euclidian => [8/3, 2.0],
+    CN._co_euclidian => [8 / 3, 2.0],
 ]
 
-for (f, results) in funcs_dom, (key, vals) in enumerate(data)
-    @test f(vals.first, vals.second[2]) ≈ results[key]
+for (f, results) in funcs_dom
+    @info f
+    for (key, vals) in enumerate(data)
+        @test f(vals.first, vals.second[2]) ≈ results[key]
+    end
 end