modified: CHANGELOG.md

modified: Project.toml modified: src/main/main_systems.jl
AutomationLabs-sh · Mar 17, 2023 · ccce5e8 · ccce5e8
1 parent 0cdb0be
commit ccce5e8
Show file tree

Hide file tree

Showing 3 changed files with 37 additions and 115 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 # AutomationLabsSystems Changelog
 
+## v0.1.6
+
+* Modification of proceed_system_model_evaluation with the name of neural networks sub-layers.
+
 ## v0.1.5
 
 * Remove neuralode_type1 and keep only neuralode_type2 as neuralODE from AutomationLabsIdentification.jl.

diff --git a/Project.toml b/Project.toml
@@ -1,7 +1,7 @@
 name = "AutomationLabsSystems"
 uuid = "6d3dfdf0-e107-48c6-a6ff-eced1a5a9334"
 authors = ["Pierre BLAUD <pierre.blaud@ikmail.com> and contributors"]
-version = "0.1.5"
+version = "0.1.6"
 
 [deps]
 AutomationLabsIdentification = "48ff5a6f-d08b-4053-9585-6a9e3e078386"

diff --git a/src/main/main_systems.jl b/src/main/main_systems.jl
@@ -195,129 +195,47 @@ function proceed_system_model_evaluation(
     system::MathematicalSystems.ConstrainedBlackBoxControlDiscreteSystem,
 )
 
-    if typeof(system.f) == Flux.Chain{
-        Tuple{
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-            Flux.Chain{
-                NTuple{4,Flux.Dense{typeof(NNlib.relu),Matrix{Float32},Vector{Float32}}},
-            },
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-        },
-    }
+    # Get keys from the neural networks
+    sublayers_name = collect(keys(system.f))
+
+    if sublayers_name[1] == :fnn_input
         model_type = AutomationLabsIdentification.Fnn()
 
-    elseif typeof(system.f) == Flux.Chain{
-        Tuple{
-            AutomationLabsIdentification.DenseIcnn{typeof(identity),Matrix{Float32},Bool},
-            Flux.Chain{
-                Tuple{
-                    AutomationLabsIdentification.DenseIcnn{
-                        typeof(NNlib.relu),
-                        Matrix{Float32},
-                        Vector{Float32},
-                    },
-                    AutomationLabsIdentification.DenseIcnn{
-                        typeof(NNlib.relu),
-                        Matrix{Float32},
-                        Vector{Float32},
-                    },
-                },
-            },
-            AutomationLabsIdentification.DenseIcnn{typeof(identity),Matrix{Float32},Bool},
-        },
-    }
+    elseif sublayers_name[1] == :icnn_input
         model_type = AutomationLabsIdentification.Icnn()
 
-    elseif typeof(system.f) == Flux.Chain{
-        Tuple{
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-            Flux.Chain{
-                Tuple{
-                    Flux.SkipConnection{
-                        Flux.Chain{
-                            Tuple{
-                                Flux.Dense{
-                                    typeof(NNlib.relu),
-                                    Matrix{Float32},
-                                    Vector{Float32},
-                                },
-                            },
-                        },
-                        typeof(+),
-                    },
-                },
-            },
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-        },
-    }
+    elseif sublayers_name[1] == :resnet_input
         model_type = AutomationLabsIdentification.ResNet()
 
-    elseif typeof(system.f) == Flux.Chain{
-        Tuple{
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-            Flux.Chain{
-                Tuple{
-                    Flux.SkipConnection{
-                        Flux.Chain{
-                            Tuple{
-                                Flux.Dense{
-                                    typeof(NNlib.relu),
-                                    Matrix{Float32},
-                                    Vector{Float32},
-                                },
-                            },
-                        },
-                        typeof(vcat),
-                    },
-                },
-            },
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-        },
-    }
+    elseif sublayers_name[1] == :polynet_input
+        model_type = AutomationLabsIdentification.PolyNet()
+
+    elseif sublayers_name[1] == :densenet_input
         model_type = AutomationLabsIdentification.DenseNet()
 
-    elseif typeof(system.f) == Flux.Chain{
-        Tuple{
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-            Flux.Chain{
-                NTuple{
-                    4,
-                    Flux.SkipConnection{
-                        Flux.Parallel{
-                            typeof(+),
-                            Tuple{
-                                Flux.Dense{
-                                    typeof(NNlib.relu),
-                                    Matrix{Float32},
-                                    Vector{Float32},
-                                },
-                                Flux.Chain{
-                                    Tuple{
-                                        Flux.Dense{
-                                            typeof(NNlib.relu),
-                                            Matrix{Float32},
-                                            Vector{Float32},
-                                        },
-                                        Flux.Dense{
-                                            typeof(NNlib.relu),
-                                            Matrix{Float32},
-                                            Vector{Float32},
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        typeof(+),
-                    },
-                },
-            },
-            Flux.Dense{typeof(identity),Matrix{Float32},Bool},
-        },
-    }
-        model_type = AutomationLabsIdentification.PolyNet()
+    elseif sublayers_name[1] == :rbf_input
+        model_type = AutomationLabsIdentification.Rbf()
+
+    elseif sublayers_name[1] == :neuralode_inner
+        model_type = AutomationLabsIdentification.NeuralODE()
+
+    elseif sublayers_name[1] == :rknn1_identity
+        model_type = AutomationLabsIdentification.Rknn1() 
+
+    elseif sublayers_name[1] == :rknn2_identity
+        model_type = AutomationLabsIdentification.Rknn2() 
+
+    elseif sublayers_name[1] == :rknn4_identity
+        model_type = AutomationLabsIdentification.Rknn4() 
+
+    elseif sublayers_name[1] == :rnn_input
+        model_type = AutomationLabsIdentification.Rnn() 
+
+    elseif sublayers_name[1] == :lstm_input
+        model_type = AutomationLabsIdentification.Lstm() 
 
-    elseif typeof(system.f) == Function
-        model_type = typeof(system.f)
+    elseif sublayers_name[1] == :gru_input
+        model_type = AutomationLabsIdentification.Gru() 
 
     end