ReservoirComputing.jl/test/test_inits.jl at ff3bf9562ecf94e9d7b713d4e1900c54571f99bf · am-1118/ReservoirComputing.jl · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
using ReservoirComputing, LinearAlgebra, Random, SparseArrays

const res_size = 16
const in_size = 4
const radius = 1.0
const rng = Random.default_rng()

function check_radius(matrix, target_radius; tolerance = 1.0e-5)
    if matrix isa SparseArrays.SparseMatrixCSC
        matrix = Matrix(matrix)
    end
    eigenvalues = eigvals(matrix)
    spectral_radius = maximum(abs.(eigenvalues))
    return isapprox(spectral_radius, target_radius; atol = tolerance)
end

ft = [Float16, Float32, Float64]
reservoir_inits = [
    block_diagonal,
    chaotic_init,
    cycle_jumps,
    delay_line,
    delayline_backward,
    double_cycle,
    forward_connection,
    low_connectivity,
    pseudo_svd,
    rand_sparse,
    selfloop_cycle,
    selfloop_delayline_backward,
    selfloop_backward_cycle,
    selfloop_forwardconnection,
    simple_cycle,
    true_doublecycle,
    permutation_init,
    diagonal_init,
]
input_inits = [
    chebyshev_mapping,
    logistic_mapping,
    minimal_init,
    minimal_init(; sampling_type = :irrational_sample!),
    modified_lm(; factor = 4),
    scaled_rand,
    weighted_init,
    weighted_minimal,
]

@testset "Reservoir Initializers" begin
    @testset "Sizes and types: $init $T" for init in reservoir_inits, T in ft
        #sizes
        @test size(init(res_size, res_size)) == (res_size, res_size)
        @test size(init(rng, res_size, res_size)) == (res_size, res_size)
        #types
        @test eltype(init(T, res_size, res_size)) == T
        @test eltype(init(rng, T, res_size, res_size)) == T
        #closure
        cl = init(rng)
        @test eltype(cl(T, res_size, res_size)) == T
    end

    @testset "Check spectral radius" begin
        sp = rand_sparse(res_size, res_size)
        @test check_radius(sp, radius)
    end

    @testset "Minimum complexity: $init" for init in [
            delay_line,
            delayline_backward,
            cycle_jumps,
            simple_cycle,
            true_doublecycle,
            double_cycle,
            selfloop_cycle,
            selfloop_delayline_backward,
            selfloop_backward_cycle,
            selfloop_forwardconnection,
            forward_connection,
            permutation_init,
        ]
        dl = init(res_size, res_size)
        @test sort(unique(dl)) == Float32.([0.0, 0.1])
    end
end

# TODO: @MartinuzziFrancesco Missing tests for informed_init
@testset "Input Initializers" begin
    @testset "Sizes and types: $init $T" for init in input_inits, T in ft
        #sizes
        @test size(init(res_size, in_size)) == (res_size, in_size)
        @test size(init(rng, res_size, in_size)) == (res_size, in_size)
        #types
        @test eltype(init(T, res_size, in_size)) == T
        @test eltype(init(rng, T, res_size, in_size)) == T
        #closure
        cl = init(rng)
        @test eltype(cl(T, res_size, in_size)) == T
    end

    @testset "Minimum complexity: $init" for init in [
            minimal_init,
            minimal_init(; sampling_type = :irrational_sample!),
        ]
        dl = init(res_size, in_size)
        @test sort(unique(dl)) == Float32.([-0.1, 0.1])
    end
end

@testset "Wigner_matrix_init.jl" begin
    #rng = Random.default_rng()
    #res_size = 10


    W = wigner_init(rng, Float32, res_size; radius = 0.9, std = 0.5)

    @test size(W) == (res_size, res_size)

    @test eltype(W) == Float32

    @test issymmetric(W)
end