Rename params (#253)

* first sweep of renaming

* fix destroyed types

* parameter table column renamed to label

* param and param_labels, params!, seem to work

* allow partial execution of unit tests

* remove non existing tests

* fix model unittests

* remove unnessary test layer

* finish replacing

* all unit tests passed

* rename param_values -> params

* add StatsAPI as dep

* add coef and coefnames

* rename df => dof (#254)

* rename df => dof

* import dof from StatsAPI

* rename dof file

* rename sem_fit => fit

* typo

* add nobs and fix testsw

* add coeftable

* fix proximal tests

* fix exports and StatsAPI docstrings

* fix tests

* fix tests

* thx evie for the typo :)

* fix coeftable

---------

Co-authored-by: Maximilian Ernst <[email protected]>

Author: aaronpeikert

Project.toml

@@ -18,6 +18,7 @@ PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StatsAPI = "82ae8749-77ed-4fe6-ae5f-f523153014b0"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
 StenoGraphs = "78862bba-adae-4a83-bb4d-33c106177f81"
 Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7"

README.md

@@ -15,7 +15,7 @@ Models you can fit include
 - Multigroup SEM
 - Sums of arbitrary loss functions (everything the optimizer can handle).
 
-# What are the merrits?
+# What are the merits?
 
 We provide fast objective functions, gradients, and for some cases hessians as well as approximations thereof.
 As a user, you can easily define custom loss functions.

docs/src/developer/loss.md

@@ -79,7 +79,7 @@ model = SemFiniteDiff(
     loss = (SemML, myridge)
 )
 
-model_fit = sem_fit(model)
+model_fit = fit(model)
 ```
 
 This is one way of specifying the model - we now have **one model** with **multiple loss functions**. Because we did not provide a gradient for `Ridge`, we have to specify a `SemFiniteDiff` model that computes numerical gradients with finite difference approximation.
@@ -117,17 +117,17 @@ model_new = Sem(
     loss = (SemML, myridge)
 )
 
-model_fit = sem_fit(model_new)
+model_fit = fit(model_new)
 ```
 
 The results are the same, but we can verify that the computational costs are way lower (for this, the julia package `BenchmarkTools` has to be installed):
 
 ```julia
 using BenchmarkTools
 
-@benchmark sem_fit(model)
+@benchmark fit(model)
 
-@benchmark sem_fit(model_new)
+@benchmark fit(model_new)
 ```
 
 The exact results of those benchmarks are of course highly depended an your system (processor, RAM, etc.), but you should see that the median computation time with analytical gradients drops to about 5% of the computation without analytical gradients.
@@ -241,7 +241,7 @@ model_ml = SemFiniteDiff(
     loss = MaximumLikelihood()
 )
 
-model_fit = sem_fit(model_ml)
+model_fit = fit(model_ml)
 ```
 
 If you want to differentiate your own loss functions via automatic differentiation, check out the [AutoDiffSEM](https://github.com/StructuralEquationModels/AutoDiffSEM) package.

docs/src/developer/optimizer.md

@@ -34,7 +34,7 @@ algorithm(optimizer::SemOptimizerName) = optimizer.algorithm
 options(optimizer::SemOptimizerName) = optimizer.options
 ```
 
-Note that your optimizer is a subtype of `SemOptimizer{:Name}`, where you can choose a `:Name` that can later be used as a keyword argument to `sem_fit(engine = :Name)`.
+Note that your optimizer is a subtype of `SemOptimizer{:Name}`, where you can choose a `:Name` that can later be used as a keyword argument to `fit(engine = :Name)`.
 Similarly, `SemOptimizer{:Name}(args...; kwargs...) = SemOptimizerName(args...; kwargs...)` should be defined as well as a constructor that uses only keyword arguments:
 
 ´´´julia
@@ -46,10 +46,10 @@ SemOptimizerName(;
 ´´´
 A method for `update_observed` and additional methods might be usefull, but are not necessary.
 
-Now comes the substantive part: We need to provide a method for `sem_fit`:
+Now comes the substantive part: We need to provide a method for `fit`:
 
 ```julia
-function sem_fit(
+function fit(
     optim::SemOptimizerName,
     model::AbstractSem,
     start_params::AbstractVector;

docs/src/internals/files.md

@@ -11,7 +11,7 @@ Source code is in the `"src"` folder:
 - `"types.jl"` defines all abstract types and the basic type hierarchy
 - `"objective_gradient_hessian.jl"` contains methods for computing objective, gradient and hessian values for different model types as well as generic fallback methods
 - The four folders `"observed"`, `"implied"`, `"loss"` and `"diff"` contain implementations of specific subtypes (for example, the `"loss"` folder contains a file `"ML.jl"` that implements the `SemML` loss function).
-- `"optimizer"` contains connections to different optimization backends (aka methods for `sem_fit`)
+- `"optimizer"` contains connections to different optimization backends (aka methods for `fit`)
     - `"optim.jl"`: connection to the `Optim.jl` package
 - `"frontend"` contains user-facing functions
     - `"specification"` contains functionality for model specification

docs/src/performance/mixed_differentiation.md

@@ -19,15 +19,15 @@ model_ridge = SemFiniteDiff(
 
 model_ml_ridge = SemEnsemble(model_ml, model_ridge)
 
-model_ml_ridge_fit = sem_fit(model_ml_ridge)
+model_ml_ridge_fit = fit(model_ml_ridge)
 ```
 
 The results of both methods will be the same, but we can verify that the computation costs differ (the package `BenchmarkTools` has to be installed for this):
 
 ```julia
 using BenchmarkTools
 
-@benchmark sem_fit(model)
+@benchmark fit(model)
 
-@benchmark sem_fit(model_ml_ridge)
+@benchmark fit(model_ml_ridge)
 ```

docs/src/performance/mkl.md

@@ -27,9 +27,9 @@ To check the performance implications for fitting a SEM, you can use the [`Bench
 ```julia
 using BenchmarkTools
 
-@benchmark sem_fit($your_model)
+@benchmark fit($your_model)
 
 using MKL
 
-@benchmark sem_fit($your_model)
+@benchmark fit($your_model)
 ```

docs/src/performance/simulation.md

@@ -100,7 +100,7 @@ models = [model1, model2]
 fits = Vector{SemFit}(undef, 2)
 
 Threads.@threads for i in 1:2
-    fits[i] = sem_fit(models[i])
+    fits[i] = fit(models[i])
 end
 ```
 

docs/src/performance/starting_values.md

@@ -1,9 +1,9 @@
 # Starting values
 
-The `sem_fit` function has a keyword argument that takes either a vector of starting values or a function that takes a model as input to compute starting values. Current options are `start_fabin3` for fabin 3 starting values [^Hägglund82] or `start_simple` for simple starting values. Additional keyword arguments to `sem_fit` are passed to the starting value function. For example,
+The `fit` function has a keyword argument that takes either a vector of starting values or a function that takes a model as input to compute starting values. Current options are `start_fabin3` for fabin 3 starting values [^Hägglund82] or `start_simple` for simple starting values. Additional keyword arguments to `fit` are passed to the starting value function. For example,
 
 ```julia
-    sem_fit(
+    fit(
         model; 
         start_val = start_simple,
         start_covariances_latent = 0.5

docs/src/tutorials/collection/multigroup.md

@@ -81,7 +81,7 @@ model_ml_multigroup = SemEnsemble(
 We now fit the model and inspect the parameter estimates:
 
 ```@example mg; ansicolor = true
-fit = sem_fit(model_ml_multigroup)
+fit = fit(model_ml_multigroup)
 update_estimate!(partable, fit)
 details(partable)
 ```