Fixed GeometricBase version to 0.11, GeometricSolutions to 0.5 and GeometricEquations to 0.19. I also replaced tstep with timestep.

Got rid of GeometricIntegrators again.

Author: benedict-96

Project.toml

@@ -1,7 +1,7 @@
 name = "GeometricMachineLearning"
 uuid = "194d25b2-d3f5-49f0-af24-c124f4aa80cc"
-authors = ["Michael Kraus <[email protected]>"]
 version = "0.4.4"
+authors = ["Michael Kraus <[email protected]>"]
 
 [deps]
 AbstractNeuralNetworks = "60874f82-5ada-4c70-bd1c-fa6be7711c8a"
@@ -13,6 +13,7 @@ Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
 ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 GeometricBase = "9a0b12b7-583b-4f04-aa1f-d8551b6addc9"
 GeometricEquations = "c85262ba-a08a-430a-b926-d29770767bf2"
+GeometricIntegrators = "dcce2d33-59f6-5b8d-9047-0defad88ae06"
 GeometricSolutions = "7843afe4-64f4-4df4-9231-049495c56661"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
@@ -41,10 +42,9 @@ ChainRulesCore = "1"
 ChainRulesTestUtils = "1"
 Distances = "0.10"
 ForwardDiff = "0.10, 1"
-GeometricBase = "0.10"
-GeometricEquations = "0.18, 0.19"
-GeometricIntegrators = "0.14.2"
-GeometricSolutions = "0.3.24, 0.4"
+GeometricBase = "0.11"
+GeometricEquations = "0.19"
+GeometricSolutions = "0.5"
 HDF5 = "0.16, 0.17"
 KernelAbstractions = "0.9"
 LazyArrays = "=2.3.2"

docs/src/optimizers/manifold_related/parallel_transport.md

@@ -134,10 +134,10 @@ Y_increments = []
 Δ₂_transported = []
 
 const n_steps = 6
-const tstep = 2
+const timestep = 2
 
 for _ in 1:n_steps
-    update_section!(λY, tstep * B, geodesic)
+    update_section!(λY, timestep * B, geodesic)
     push!(Y_increments, copy(λY.Y))
     push!(Δ_transported, Matrix(λY) * B * E)
     push!(Δ₂_transported, Matrix(λY) * B₂ * E)

docs/src/tutorials/linear_symplectic_transformer.md

@@ -31,11 +31,11 @@ CairoMakie.activate!() # hide
 import Random # hide
 Random.seed!(123) # hide
 
-const tstep = .3
+const timestep = .3
 const n_init_con = 5
 
 # ensemble problem
-ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; tstep = tstep)
+ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; timestep = timestep)
 dl = DataLoader(integrate(ep, ImplicitMidpoint()); suppress_info = true)
 # dl = DataLoader(vcat(dl_nt.input.q, dl_nt.input.p))  # hide
 

docs/src/tutorials/matrix_softmax.md

@@ -47,11 +47,11 @@ mpurple = RGBf(148 / 256, 103 / 256, 189 / 256) # hide
 mblue = RGBf(31 / 256, 119 / 256, 180 / 256) # hide
 mgreen = RGBf(44 / 256, 160 / 256, 44 / 256) # hide
 
-const tstep = .3
+const timestep = .3
 const n_init_con = 5
 
 # ensemble problem
-ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; tstep = tstep)
+ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; timestep = timestep)
 dl = DataLoader(integrate(ep, ImplicitMidpoint()); suppress_info = true)
 # dl = DataLoader(vcat(dl_nt.input.q, dl_nt.input.p))  # hide
 

docs/src/tutorials/softmax_comparison.md

@@ -40,11 +40,11 @@ CairoMakie.activate!() # hide
 import Random # hide
 Random.seed!(123) # hide
 
-const tstep = .3
+const timestep = .3
 const n_init_con = 5
 
 # ensemble problem
-ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; tstep = tstep)
+ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; timestep = timestep)
 dl = DataLoader(integrate(ep, ImplicitMidpoint()); suppress_info = true)
 
 nothing # hide

docs/src/tutorials/symplectic_transformer.md

@@ -31,11 +31,11 @@ CairoMakie.activate!() # hide
 import Random # hide
 Random.seed!(123) # hide
 
-const tstep = .3
+const timestep = .3
 const n_init_con = 5
 
 # ensemble problem
-ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; tstep = tstep)
+ep = hodeensemble([rand(2) for _ in 1:n_init_con], [rand(2) for _ in 1:n_init_con]; timestep = timestep)
 dl = DataLoader(integrate(ep, ImplicitMidpoint()); suppress_info = true)
 # dl = DataLoader(vcat(dl_nt.input.q, dl_nt.input.p))  # hide
 

docs/src/tutorials/volume_preserving_transformer_rigid_body.md

@@ -26,7 +26,7 @@ nothing # hide
 We now generate the data by integrating with:
 
 ```@example rigid_body
-const tstep = .2
+const timestep = .2
 const tspan = (0., 20.)
 nothing # hide
 ```
@@ -38,7 +38,7 @@ using GeometricMachineLearning # hide
 using GeometricIntegrators: integrate, ImplicitMidpoint
 using GeometricProblems.RigidBody: odeproblem, odeensemble, default_parameters
 
-ensemble_problem = odeensemble(ics; tspan = tspan, tstep = tstep, parameters = default_parameters)
+ensemble_problem = odeensemble(ics; tspan = tspan, timestep = timestep, parameters = default_parameters)
 ensemble_solution = integrate(ensemble_problem, ImplicitMidpoint())
 
 dl_cpu = DataLoader(ensemble_solution; suppress_info = true)
@@ -229,16 +229,16 @@ const t_validation = 120
 
 function produce_trajectory(ics_val)
     problem = odeproblem(ics_val;   tspan = (0, t_validation), 
-                                    tstep = tstep, 
+                                    timestep = timestep, 
                                     parameters = default_parameters)
     solution = integrate(problem, ImplicitMidpoint())
     trajectory = Float32.(DataLoader(solution; suppress_info = true).input)
     nn_vpff_solution = iterate(nn_vpff, trajectory[:, 1]; 
-                                            n_points = Int(floor(t_validation / tstep)) + 1)
+                                            n_points = Int(floor(t_validation / timestep)) + 1)
     nn_vpt_solution = iterate(nn_vpt, trajectory[:, 1:seq_length];
-                                            n_points = Int(floor(t_validation / tstep)) + 1)
+                                            n_points = Int(floor(t_validation / timestep)) + 1)
     nn_st_solution = iterate(nn_st, trajectory[:, 1:seq_length];
-                                            n_points = Int(floor(t_validation / tstep)) + 1)
+                                            n_points = Int(floor(t_validation / timestep)) + 1)
     trajectory, nn_vpff_solution, nn_vpt_solution, nn_st_solution
 end
 
@@ -314,14 +314,14 @@ We can see that the volume-preserving transformer performs much better than the
 We also compare the times it takes to integrate the system with (i) implicit midpoint, (ii) the volume-preserving transformer and (iii) the standard transformer:
 ```@example rigid_body
 function timing() # hide
-problem = odeproblem(ics_val₁; tspan = (0, t_validation), tstep = tstep, parameters = default_parameters) # hide
+problem = odeproblem(ics_val₁; tspan = (0, t_validation), timestep = timestep, parameters = default_parameters) # hide
 solution = integrate(problem, ImplicitMidpoint()) # hide
 @time "Implicit Midpoint" solution = integrate(problem, ImplicitMidpoint())
 trajectory = Float32.(DataLoader(solution; suppress_info = true).input)
-iterate(nn_vpt, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / tstep)) + 1) # hide
-@time "VPT" iterate(nn_vpt, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / tstep)) + 1)
-iterate(nn_st, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / tstep)) + 1) # hide
-@time "ST" iterate(nn_st, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / tstep)) + 1)
+iterate(nn_vpt, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / timestep)) + 1) # hide
+@time "VPT" iterate(nn_vpt, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / timestep)) + 1)
+iterate(nn_st, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / timestep)) + 1) # hide
+@time "ST" iterate(nn_st, trajectory[:, 1:seq_length]; n_points = Int(floor(t_validation / timestep)) + 1)
 nothing # hide
 end # hide
 timing() # hide

scripts/Script_using_fully_GML/data_problem.jl

@@ -85,32 +85,32 @@ end
 ########################################################################################
 # get data of a problem for Sypmnet (results is (data = target =(q,p))) from Hamiltonian
 
-function get_phase_space_data(nameproblem, q₀, p₀, tspan = (0., 100.), tstep = 0.1)
+function get_phase_space_data(nameproblem, q₀, p₀, tspan = (0., 100.), timestep = 0.1)
 
     # get the Hamiltonien corresponding to name_problem   
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
-    q,p = compute_phase_space(H_problem, q₀, p₀, tspan, tstep)
+    q,p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
 
     return (q, p)
 end
 
 
-function get_phase_space_multiple_trajectoy(nameproblem; singlematrix = true, n_trajectory = 1, n_points = 10, tstep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
+function get_phase_space_multiple_trajectoy(nameproblem; singlematrix = true, n_trajectory = 1, n_points = 10, timestep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
 
     # get the Hamiltonien corresponding to name_problem   
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*tstep)
+    tspan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     trajectory_q = [zeros(n_points+1,n_dim) for _ in 1:n_trajectory]
     trajectory_p = [zeros(n_points+1,n_dim) for _ in 1:n_trajectory]
     for i in 1:n_trajectory
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        trajectory_q[i],trajectory_p[i] = compute_phase_space(H_problem, q₀, p₀, tspan, tstep)
+        trajectory_q[i],trajectory_p[i] = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
     end
 
     if singlematrix
@@ -125,7 +125,7 @@ end
 ###############################################################################
 # compute phase space from the Hamiltonian
 
-function compute_phase_space(H_problem, q₀, p₀, tspan = (0., 100.), tstep = 0.1)
+function compute_phase_space(H_problem, q₀, p₀, tspan = (0., 100.), timestep = 0.1)
 
     n_dim = length(q₀)
 
@@ -144,7 +144,7 @@ function compute_phase_space(H_problem, q₀, p₀, tspan = (0., 100.), tstep =
     h(t, q, p, params) = H2(q,p)
 
     # simulate data with geometric Integrators
-    ode = HODEProblem(v, f, h, tspan, tstep, q₀, p₀)
+    ode = HODEProblem(v, f, h, tspan, timestep, q₀, p₀)
 
     #return sol = integrate(ode, SymplecticEulerA())
     return sol = integrate(ode, SymplecticTableau(TableauExplicitEuler()))
@@ -168,14 +168,14 @@ struct storing_data{T}
 end
 
 
-function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_points = 10, tstep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
+function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_points = 10, timestep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
 
 
     # get the Hamiltonien corresponding to name_problem   
     H_problem, n_dim = dict_problem_H[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*tstep)
+    tspan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = NamedTuple()
@@ -184,7 +184,7 @@ function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_poin
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, tstep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
 
         Data = [(q[n], p[n]) for n in 1:size(q,1)]
 
@@ -194,14 +194,14 @@ function get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_poin
         pre_data = merge(pre_data,nt)
     end
 
-    data = storing_data(tstep, n_trajectory, pre_data)
+    data = storing_data(timestep, n_trajectory, pre_data)
 
 
 
     return data #data_trajectory(data, Get_nb_trajectory, Get_length_trajectory, Get_q, Get_p, Get_Δt)
 end
 
-function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory = 1, n_points = 10, tstep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
+function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory = 1, n_points = 10, timestep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
 
 
     # get the Hamiltonien corresponding to name_problem   
@@ -217,7 +217,7 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
     dH(x) = symplectic_matrix * ∇H(x)
 
     #define timespan
-    tspan=(0.,n_points*tstep)
+    tspan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = NamedTuple()
@@ -227,7 +227,7 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, tstep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
 
         Data = [(q[n], p[n]) for n in 1:size(q,1)]
         data_calc = [[q[n]..., p[n]...] for n in 1:size(q,1)]
@@ -243,7 +243,7 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
 
     end
 
-    data = storing_data(tstep, n_trajectory, pre_data)
+    data = storing_data(timestep, n_trajectory, pre_data)
 
     Get_Δt(Data) = Data.Δt
     Get_nb_trajectory(Data) = Data.nb_trajectory
@@ -258,18 +258,18 @@ function get_multiple_trajectory_structure_with_target(nameproblem; n_trajectory
 end
 
 
-function get_multiple_trajectory_structure_Lagrangian(nameproblem; n_trajectory = 1, n_points = 10, tstep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
+function get_multiple_trajectory_structure_Lagrangian(nameproblem; n_trajectory = 1, n_points = 10, timestep = 0.1, qmin = -0.2, pmin = -0.2, qmax = 0.2, pmax = 0.2)
 
 
     # get the Hamiltonien corresponding to name_problem   
     H_problem, n_dim = dict_problem_L[nameproblem] 
 
     #define timespan
-    tspan=(0.,n_points*tstep)
+    tspan=(0.,n_points*timestep)
 
     #compute phase space for each trajectory staring from a random point
     pre_data = []
-    push!(pre_data,[tstep])
+    push!(pre_data,[timestep])
     push!(pre_data,[n_trajectory])
     push!(pre_data, [n_points+1])
 
@@ -278,7 +278,7 @@ function get_multiple_trajectory_structure_Lagrangian(nameproblem; n_trajectory
 
         q₀ = [rand()*(qmax-qmin)+qmin for _ in 1:n_dim]
         p₀ = [rand()*(pmax-pmin)+pmin for _ in 1:n_dim]
-        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, tstep)
+        q, p = compute_phase_space(H_problem, q₀, p₀, tspan, timestep)
 
         Data = [q[n] for n in 1:size(q,1)]
 

scripts/Script_using_fully_GML/lnn_script.jl

@@ -35,7 +35,7 @@ end
 
 
 #=
-Data = get_multiple_trajectory_structure(:pendulum; n_trajectory = 20, n_points = 1000, tstep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
+Data = get_multiple_trajectory_structure(:pendulum; n_trajectory = 20, n_points = 1000, timestep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
 
 Get_Data = Dict(
     :Δt => Data -> Data.Δt,

scripts/Script_using_fully_GML/sympnet_script.jl

@@ -8,7 +8,7 @@ nameproblem = :pendulum
 
 H , n_dim = dict_problem_H[nameproblem]
 
-Data = get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_points = 1000, tstep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
+Data = get_multiple_trajectory_structure(nameproblem; n_trajectory = 1, n_points = 1000, timestep = 0.1, qmin = -1.2, pmin = -1.2, qmax = 1.2, pmax = 1.2)
 
 get_Data = Dict(
     :Δt => Data -> Data.Δt,