Implement keyword selector

README.md

@@ -47,7 +47,7 @@ chi = 20
 ctm_alg = SimultaneousCTMRG(; tol=1e-10, trscheme=truncdim(chi))
 opt_alg = PEPSOptimize(;
     boundary_alg=ctm_alg,
-    optimizer=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
+    optimizer_alg=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
     gradient_alg=LinSolver(),
     reuse_env=true,
 )

docs/src/index.md

@@ -29,7 +29,7 @@ chi = 20
 ctm_alg = SimultaneousCTMRG(; tol=1e-10, trscheme=truncdim(chi))
 opt_alg = PEPSOptimize(;
     boundary_alg=ctm_alg,
-    optimizer=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
+    optimizer_alg=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
     gradient_alg=LinSolver(),
     reuse_env=true,
 )

examples/heisenberg.jl

@@ -14,8 +14,8 @@ H = heisenberg_XYZ(InfiniteSquare(); Jx=-1, Jy=1, Jz=-1)
 ctm_alg = SimultaneousCTMRG(; tol=1e-10, verbosity=2)
 opt_alg = PEPSOptimize(;
     boundary_alg=ctm_alg,
-    optimizer=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
-    gradient_alg=LinSolver(; solver=GMRES(; tol=1e-6, maxiter=100)),
+    optimizer_alg=LBFGS(4; maxiter=100, gradtol=1e-4, verbosity=3),
+    gradient_alg=LinSolver(; solver_alg=GMRES(; tol=1e-6, maxiter=100)),
     reuse_env=true,
 )
 

src/Defaults.jl

@@ -0,0 +1,139 @@
+"""
+    module Defaults
+
+Module containing default algorithm parameter values and arguments.
+
+## CTMRG
+
+- `ctmrg_tol=$(Defaults.ctmrg_tol)` : Tolerance checking singular value and norm convergence.
+- `ctmrg_maxiter=$(Defaults.ctmrg_maxiter)` : Maximal number of CTMRG iterations per run.
+- `ctmrg_miniter=$(Defaults.ctmrg_miniter)` : Minimal number of CTMRG carried out.
+- `ctmrg_alg=:$(Defaults.ctmrg_alg)` : Default CTMRG algorithm variant.
+- `ctmrg_verbosity=$(Defaults.ctmrg_verbosity)` : CTMRG output information verbosity
+
+## SVD forward & reverse
+
+- `trscheme=:$(Defaults.trscheme)` : Truncation scheme for SVDs and other decompositions.
+- `svd_fwd_alg=:$(Defaults.svd_fwd_alg)` : SVD algorithm that is used in the forward pass.
+- `svd_rrule_tol=$(Defaults.svd_rrule_tol)` : Accuracy of SVD reverse-rule.
+- `svd_rrule_min_krylovdim=$(Defaults.svd_rrule_min_krylovdim)` : Minimal Krylov dimension of the reverse-rule algorithm (if it is a Krylov algorithm).
+- `svd_rrule_verbosity=$(Defaults.svd_rrule_verbosity)` : SVD gradient output verbosity.
+- `svd_rrule_alg=:$(Defaults.svd_rrule_alg)` : Reverse-rule algorithm for the SVD gradient.
+
+## Projectors
+
+- `projector_alg=:$(Defaults.projector_alg)` : Default variant of the CTMRG projector algorithm.
+- `projector_verbosity=$(Defaults.projector_verbosity)` : Projector output information verbosity.
+
+## Fixed-point gradient
+
+- `gradient_tol=$(Defaults.gradient_tol)` : Convergence tolerance for the fixed-point gradient iteration.
+- `gradient_maxiter=$(Defaults.gradient_maxiter)` : Maximal number of iterations for computing the CTMRG fixed-point gradient.
+- `gradient_verbosity=$(Defaults.gradient_verbosity)` : Gradient output information verbosity.
+- `gradient_linsolver=:$(Defaults.gradient_linsolver)` : Default linear solver for the `LinSolver` gradient algorithm.
+- `gradient_eigsolver=:$(Defaults.gradient_eigsolver)` : Default eigensolver for the `EigSolver` gradient algorithm.
+- `gradient_eigsolver_eager=$(Defaults.gradient_eigsolver_eager)` : Enables `EigSolver` algorithm to finish before the full Krylov dimension is reached.
+- `gradient_iterscheme=:$(Defaults.gradient_iterscheme)` : Scheme for differentiating one CTMRG iteration.
+- `gradient_alg=:$(Defaults.gradient_alg)` : Algorithm variant for computing the gradient fixed-point.
+
+## Optimization
+
+- `reuse_env=$(Defaults.reuse_env)` : If `true`, the current optimization step is initialized on the previous environment, otherwise a random environment is used.
+- `optimizer_tol=$(Defaults.optimizer_tol)` : Gradient norm tolerance of the optimizer.
+- `optimizer_maxiter=$(Defaults.optimizer_maxiter)` : Maximal number of optimization steps.
+- `optimizer_verbosity=$(Defaults.optimizer_verbosity)` : Optimizer output information verbosity.
+- `optimizer_alg=:$(Defaults.optimizer_alg)` : Default `OptimKit.OptimizerAlgorithm` for PEPS optimization.
+- `lbfgs_memory=$(Defaults.lbfgs_memory)` : Size of limited memory representation of BFGS Hessian matrix.
+
+## OhMyThreads scheduler
+
+- `scheduler=Ref{Scheduler}(...)` : Multi-threading scheduler which can be accessed via `set_scheduler!`.
+"""
+module Defaults
+
+export set_scheduler!
+
+using OhMyThreads
+
+# CTMRG
+const ctmrg_tol = 1e-8
+const ctmrg_maxiter = 100
+const ctmrg_miniter = 4
+const ctmrg_alg = :simultaneous # ∈ {:simultaneous, :sequential}
+const ctmrg_verbosity = 2
+const sparse = false # TODO: implement sparse CTMRG
+
+# SVD forward & reverse
+const trscheme = :fixedspace # ∈ {:fixedspace, :notrunc, :truncerr, :truncspace, :truncbelow}
+const svd_fwd_alg = :sdd # ∈ {:sdd, :svd, :iterative}
+const svd_rrule_tol = ctmrg_tol
+const svd_rrule_min_krylovdim = 48
+const svd_rrule_verbosity = -1
+const svd_rrule_alg = :arnoldi # ∈ {:gmres, :bicgstab, :arnoldi}
+const krylovdim_factor = 1.4
+
+# Projectors
+const projector_alg = :halfinfinite # ∈ {:halfinfinite, :fullinfinite}
+const projector_verbosity = 0
+
+# Fixed-point gradient
+const gradient_tol = 1e-6
+const gradient_maxiter = 30
+const gradient_verbosity = -1
+const gradient_linsolver = :bicgstab # ∈ {:gmres, :bicgstab}
+const gradient_eigsolver = :arnoldi
+const gradient_eigsolver_eager = true
+const gradient_iterscheme = :fixed # ∈ {:fixed, :diffgauge}
+const gradient_alg = :linsolver # ∈ {:geomsum, :manualiter, :linsolver, :eigsolver}
+
+# Optimization
+const reuse_env = true
+const optimizer_tol = 1e-4
+const optimizer_maxiter = 100
+const optimizer_verbosity = 3
+const optimizer_alg = :lbfgs
+const lbfgs_memory = 20
+
+# OhMyThreads scheduler defaults
+const scheduler = Ref{Scheduler}()
+
+"""
+    set_scheduler!([scheduler]; kwargs...)
+
+Set `OhMyThreads` multi-threading scheduler parameters.
+
+The function either accepts a `scheduler` as an `OhMyThreads.Scheduler` or
+as a symbol where the corresponding parameters are specificed as keyword arguments.
+For instance, a static scheduler that uses four tasks with chunking enabled
+can be set via
+```
+set_scheduler!(StaticScheduler(; ntasks=4, chunking=true))
+```
+or equivalently with 
+```
+set_scheduler!(:static; ntasks=4, chunking=true)
+```
+For a detailed description of all schedulers and their keyword arguments consult the
+[`OhMyThreads` documentation](https://juliafolds2.github.io/OhMyThreads.jl/stable/refs/api/#Schedulers).
+
+If no `scheduler` is passed and only kwargs are provided, the `DynamicScheduler`
+constructor is used with the provided kwargs.
+
+To reset the scheduler to its default value, one calls `set_scheduler!` without passing
+arguments which then uses the default `DynamicScheduler()`. If the number of used threads is
+just one it falls back to `SerialScheduler()`.
+"""
+function set_scheduler!(sc=OhMyThreads.Implementation.NotGiven(); kwargs...)
+    if isempty(kwargs) && sc isa OhMyThreads.Implementation.NotGiven
+        scheduler[] = Threads.nthreads() == 1 ? SerialScheduler() : DynamicScheduler()
+    else
+        scheduler[] = OhMyThreads.Implementation._scheduler_from_userinput(sc; kwargs...)
+    end
+    return nothing
+end
+
+function __init__()
+    return set_scheduler!()
+end
+
+end

src/PEPSKit.jl

@@ -1,18 +1,19 @@
 module PEPSKit
 
 using LinearAlgebra, Statistics, Base.Threads, Base.Iterators, Printf
-using Base: @kwdef
 using Compat
 using Accessors: @set, @reset
 using VectorInterface
 using TensorKit, KrylovKit, MPSKit, OptimKit, TensorOperations
 using ChainRulesCore, Zygote
 using LoggingExtras
-using MPSKit: loginit!, logiter!, logfinish!, logcancel!
+import MPSKit: leading_boundary, loginit!, logiter!, logfinish!, logcancel!
 using MPSKitModels
 using FiniteDifferences
 using OhMyThreads: tmap
 
+include("Defaults.jl")  # Include first to allow for docstring interpolation with Defaults values
+
 include("utility/util.jl")
 include("utility/diffable_threads.jl")
 include("utility/svd.jl")
@@ -65,147 +66,7 @@ include("utility/symmetrization.jl")
 include("algorithms/optimization/fixed_point_differentiation.jl")
 include("algorithms/optimization/peps_optimization.jl")
 
-"""
-    module Defaults
-
-Module containing default algorithm parameter values and arguments.
-
-# CTMRG
-- `ctmrg_tol=1e-8`: Tolerance checking singular value and norm convergence
-- `ctmrg_maxiter=100`: Maximal number of CTMRG iterations per run
-- `ctmrg_miniter=4`: Minimal number of CTMRG carried out
-- `trscheme=FixedSpaceTruncation()`: Truncation scheme for SVDs and other decompositions
-- `fwd_alg=TensorKit.SDD()`: SVD algorithm that is used in the forward pass
-- `rrule_alg`: Reverse-rule for differentiating that SVD
-
-    ```
-    rrule_alg = Arnoldi(; tol=ctmrg_tol, krylovdim=48, verbosity=-1)
-    ```
-
-- `svd_alg=SVDAdjoint(; fwd_alg, rrule_alg)`: Combination of `fwd_alg` and `rrule_alg`
-- `projector_alg_type=HalfInfiniteProjector`: Default type of projector algorithm
-- `projector_alg`: Algorithm to compute CTMRG projectors
-
-    ```
-    projector_alg = projector_alg_type(; svd_alg, trscheme, verbosity=0)
-    ```
-
-- `ctmrg_alg`: Algorithm for performing CTMRG runs
-
-    ```
-    ctmrg_alg = SimultaneousCTMRG(
-        ctmrg_tol, ctmrg_maxiter, ctmrg_miniter, 2, projector_alg
-    )
-    ```
-
-# Optimization
-- `fpgrad_maxiter=30`: Maximal number of iterations for computing the CTMRG fixed-point gradient
-- `fpgrad_tol=1e-6`: Convergence tolerance for the fixed-point gradient iteration
-- `iterscheme=:fixed`: Scheme for differentiating one CTMRG iteration
-- `gradient_linsolver`: Default linear solver for the `LinSolver` gradient algorithm
-
-    ```
-    gradient_linsolver=KrylovKit.BiCGStab(; maxiter=fpgrad_maxiter, tol=fpgrad_tol)
-    ```
-
-- `gradient_eigsolve`: Default eigsolver for the `EigSolver` gradient algorithm
-
-    ```
-    gradient_eigsolver = KrylovKit.Arnoldi(; maxiter=fpgrad_maxiter, tol=fpgrad_tol, eager=true)
-    ```
-
-- `gradient_alg`: Algorithm to compute the gradient fixed-point
-
-    ```
-    gradient_alg = LinSolver(; solver=gradient_linsolver, iterscheme)
-    ```
-
-- `reuse_env=true`: If `true`, the current optimization step is initialized on the previous environment
-- `optimizer=LBFGS(32; maxiter=100, gradtol=1e-4, verbosity=3)`: Default `OptimKit.OptimizerAlgorithm` for PEPS optimization
-
-# OhMyThreads scheduler
-- `scheduler=Ref{Scheduler}(...)`: Multi-threading scheduler which can be accessed via `set_scheduler!`
-"""
-module Defaults
-    using TensorKit, KrylovKit, OptimKit, OhMyThreads
-    using PEPSKit:
-        LinSolver,
-        FixedSpaceTruncation,
-        SVDAdjoint,
-        HalfInfiniteProjector,
-        SimultaneousCTMRG
-
-    # CTMRG
-    const ctmrg_tol = 1e-8
-    const ctmrg_maxiter = 100
-    const ctmrg_miniter = 4
-    const sparse = false
-    const trscheme = FixedSpaceTruncation()
-    const fwd_alg = TensorKit.SDD()
-    const rrule_alg = Arnoldi(; tol=ctmrg_tol, krylovdim=48, verbosity=-1)
-    const svd_alg = SVDAdjoint(; fwd_alg, rrule_alg)
-    const projector_alg_type = HalfInfiniteProjector
-    const projector_alg = projector_alg_type(; svd_alg, trscheme, verbosity=0)
-    const ctmrg_alg = SimultaneousCTMRG(
-        ctmrg_tol, ctmrg_maxiter, ctmrg_miniter, 2, projector_alg
-    )
-
-    # Optimization
-    const fpgrad_maxiter = 30
-    const fpgrad_tol = 1e-6
-    const gradient_linsolver = KrylovKit.BiCGStab(; maxiter=fpgrad_maxiter, tol=fpgrad_tol)
-    const gradient_eigsolver = KrylovKit.Arnoldi(;
-        maxiter=fpgrad_maxiter, tol=fpgrad_tol, eager=true
-    )
-    const iterscheme = :fixed
-    const gradient_alg = LinSolver(; solver=gradient_linsolver, iterscheme)
-    const reuse_env = true
-    const optimizer = LBFGS(32; maxiter=100, gradtol=1e-4, verbosity=3)
-
-    # OhMyThreads scheduler defaults
-    const scheduler = Ref{Scheduler}()
-    """
-        set_scheduler!([scheduler]; kwargs...)
-
-    Set `OhMyThreads` multi-threading scheduler parameters.
-
-    The function either accepts a `scheduler` as an `OhMyThreads.Scheduler` or
-    as a symbol where the corresponding parameters are specificed as keyword arguments.
-    For instance, a static scheduler that uses four tasks with chunking enabled
-    can be set via
-    ```
-    set_scheduler!(StaticScheduler(; ntasks=4, chunking=true))
-    ```
-    or equivalently with 
-    ```
-    set_scheduler!(:static; ntasks=4, chunking=true)
-    ```
-    For a detailed description of all schedulers and their keyword arguments consult the
-    [`OhMyThreads` documentation](https://juliafolds2.github.io/OhMyThreads.jl/stable/refs/api/#Schedulers).
-
-    If no `scheduler` is passed and only kwargs are provided, the `DynamicScheduler`
-    constructor is used with the provided kwargs.
-
-    To reset the scheduler to its default value, one calls `set_scheduler!` without passing
-    arguments which then uses the default `DynamicScheduler()`. If the number of used threads is
-    just one it falls back to `SerialScheduler()`.
-    """
-    function set_scheduler!(sc=OhMyThreads.Implementation.NotGiven(); kwargs...)
-        if isempty(kwargs) && sc isa OhMyThreads.Implementation.NotGiven
-            scheduler[] = Threads.nthreads() == 1 ? SerialScheduler() : DynamicScheduler()
-        else
-            scheduler[] = OhMyThreads.Implementation._scheduler_from_userinput(
-                sc; kwargs...
-            )
-        end
-        return nothing
-    end
-    export set_scheduler!
-
-    function __init__()
-        return set_scheduler!()
-    end
-end
+include("algorithms/select_algorithm.jl")
 
 using .Defaults: set_scheduler!
 export set_scheduler!