remove direct calls of SemOptimizerOptim and add optimizer to SemFit

Author: Maximilian-Stefan-Ernst

docs/src/performance/simulation.md

@@ -67,7 +67,7 @@ For example,
 
 new_observed = SemObservedData(;data = data_2, specification = partable)
 
-my_optimizer = SemOptimizerOptim()
+my_optimizer = SemOptimizer()
 
 new_optimizer = update_observed(my_optimizer, new_observed)
 ```

docs/src/tutorials/construction/build_by_parts.md

@@ -59,7 +59,7 @@ ml = SemML(observed = observed)
 loss_ml = SemLoss(ml)
 
 # optimizer ----------------------------------------------------------------------------
-optimizer = SemOptimizerOptim()
+optimizer = SemOptimizer()
 
 # model --------------------------------------------------------------------------------
 

docs/src/tutorials/construction/outer_constructor.md

@@ -41,7 +41,7 @@ model = Sem(
     data = data,
     implied = RAMSymbolic,
     loss = SemWLS,
-    optimizer = SemOptimizerOptim
+    optimizer = SemOptimizer
 )
 ```
 

docs/src/tutorials/fitting/fitting.md

@@ -17,7 +17,6 @@ Structural Equation Model
 - Fields
    observed:  SemObservedData
    implied:   RAM
-   optimizer: SemOptimizerOptim
 
 ------------- Optimization result -------------
 
@@ -60,7 +59,7 @@ The available keyword arguments are listed in the sections [Using Optim.jl](@ref
 Alternative, you can also explicitely define a `SemOptimizer` and pass it as the first argument to `fit`:
 
 ```julia
-my_optimizer = SemOptimizerOptim(algorithm = BFGS())
+my_optimizer = SemOptimizer(algorithm = BFGS())
 
 fit(my_optimizer, model)
 ```

ext/SEMNLOptExt/NLopt.jl

@@ -19,7 +19,8 @@ end
 
 """
 Uses *NLopt.jl* as the optimization engine. For more information on the available algorithms 
-and options, see the [*NLopt.jl*](https://github.com/JuliaOpt/NLopt.jl)  package and the [NLopt docs](https://nlopt.readthedocs.io/en/latest/).
+and options, see the [*NLopt.jl*](https://github.com/JuliaOpt/NLopt.jl)  package and the 
+[NLopt docs](https://nlopt.readthedocs.io/en/latest/).
 
 # Constructor
 
@@ -138,12 +139,13 @@ SEM.n_iterations(res::NLoptResult) = res.problem.numevals
 SEM.convergence(res::NLoptResult) = res.result[3]
 
 # construct SemFit from fitted NLopt object
-function SemFit_NLopt(optimization_result, model::AbstractSem, start_val, opt)
+function SemFit_NLopt(optimization_result, model::AbstractSem, start_val, optim, opt)
     return SemFit(
         optimization_result[1],
         optimization_result[2],
         start_val,
         model,
+        optim,
         NLoptResult(optimization_result, opt),
     )
 end
@@ -180,7 +182,7 @@ function SEM.fit(
     # fit
     result = NLopt.optimize(opt, start_params)
 
-    return SemFit_NLopt(result, model, start_params, opt)
+    return SemFit_NLopt(result, model, start_params, optim, opt)
 end
 
 ############################################################################################

ext/SEMProximalOptExt/ProximalAlgorithms.jl

@@ -104,6 +104,7 @@ function SEM.fit(
         solution,
         start_params,
         model,
+        optim,
         ProximalResult(optimization_result),
     )
 end

src/frontend/fit/SemFit.jl

@@ -17,11 +17,12 @@ Fitted structural equation model.
 - `n_iterations(::SemFit)` -> number of iterations
 - `convergence(::SemFit)` -> convergence properties
 """
-mutable struct SemFit{Mi, So, St, Mo, O}
+mutable struct SemFit{Mi, So, St, Mo, Op, O}
     minimum::Mi
     solution::So
     start_val::St
     model::Mo
+    optimizer::Op
     optimization_result::O
 end
 
@@ -39,6 +40,10 @@ function Base.show(io::IO, semfit::SemFit)
     #print(io, "Objective value: $(round(semfit.minimum, digits = 4)) \n")
     print(io, "------------- Optimization result ------------- \n")
     print(io, "\n")
+    print(io, "engine: ")
+    print(io, engine(semfit))
+    print(io, "\n")
+    print(io, "\n")
     print(io, semfit.optimization_result)
 end
 
@@ -58,6 +63,7 @@ model(sem_fit::SemFit) = sem_fit.model
 optimization_result(sem_fit::SemFit) = sem_fit.optimization_result
 
 # optimizer properties
+engine(sem_fit::SemFit) = engine(sem_fit.optimizer)
 optimizer(sem_fit::SemFit) = optimizer(optimization_result(sem_fit))
 n_iterations(sem_fit::SemFit) = n_iterations(optimization_result(sem_fit))
 convergence(sem_fit::SemFit) = convergence(optimization_result(sem_fit))

src/optimizer/abstract.jl

@@ -1,5 +1,5 @@
 engine(::Type{<:SemOptimizer{E}}) where {E} = E
-engine(optimizer::SemOptimizer) = engine(typeof(optimizer))
+engine(::SemOptimizer{E}) where {E} = E
 
 """
     SemOptimizer(args...; engine::Symbol = :Optim, kwargs...)

src/optimizer/optim.jl

@@ -76,20 +76,6 @@ update_observed(optimizer::SemOptimizerOptim, observed::SemObserved; kwargs...)
 algorithm(optimizer::SemOptimizerOptim) = optimizer.algorithm
 options(optimizer::SemOptimizerOptim) = optimizer.options
 
-function SemFit(
-    optimization_result::Optim.MultivariateOptimizationResults,
-    model::AbstractSem,
-    start_val,
-)
-    return SemFit(
-        optimization_result.minimum,
-        optimization_result.minimizer,
-        start_val,
-        model,
-        optimization_result,
-    )
-end
-
 optimizer(res::Optim.MultivariateOptimizationResults) = Optim.summary(res)
 n_iterations(res::Optim.MultivariateOptimizationResults) = Optim.iterations(res)
 convergence(res::Optim.MultivariateOptimizationResults) = Optim.converged(res)
@@ -139,5 +125,11 @@ function fit(
             optim.options,
         )
     end
-    return SemFit(result, model, start_params)
+    return SemFit(
+        result.minimum,
+        result.minimizer,
+        start_params,
+        model,
+        optim,
+        result)
 end

test/examples/multigroup/multigroup.jl

@@ -86,7 +86,7 @@ start_test = [
     fill(0.05, 3)
     fill(0.01, 3)
 ]
-semoptimizer = SemOptimizerOptim()
+semoptimizer = SemOptimizer()
 
 @testset "RAMMatrices | constructor | Optim" begin
     include("build_models.jl")