excitationsolve 2.2.0__tar.gz → 2.2.2__tar.gz

{excitationsolve-2.2.0/excitationsolve.egg-info → excitationsolve-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excitationsolve
-Version: 2.2.0
+Version: 2.2.2
 Summary: ExcitationSolve: a fast globally-informed gradient-free optimizer for physically-motivated ansätze constructed of excitation operators
 Author-email: Jonas Jäger <jojaeger@cs.ubc.ca>, "Thierry N. Kaldenbach" <Thierry.Kaldenbach@dlr.de>, Max Haas <Max.Haas@dlr.de>, Erik Schultheis <Erik.Schultheis@dlr.de>
 License:        Copyright 2025 Jonas Jäger, Thierry N. Kaldenbach, Max Haas, Erik Schultheis,
@@ -292,6 +292,16 @@ energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger

{excitationsolve-2.2.0 → excitationsolve-2.2.2}/README.md

@@ -49,6 +49,16 @@ energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger

{excitationsolve-2.2.0 → excitationsolve-2.2.2}/excitationsolve/__init__.py

@@ -1,3 +1,4 @@
 from excitationsolve.info import __version__, HOMEPAGE
 from excitationsolve.excitation_solve import excitation_solve_step, excitation_solve_step_shared_param
 from excitationsolve.excitation_solve_scipy import ExcitationSolveScipy
+from excitationsolve.parameter_prediction import optimal_theta, optimal_theta_pyscf

{excitationsolve-2.2.0 → excitationsolve-2.2.2}/excitationsolve/excitation_solve_scipy.py

@@ -3,6 +3,8 @@ import logging
 from collections.abc import Callable
 import numpy as np
 from scipy.optimize import OptimizeResult
+from scipy.optimize._optimize import _wrap_callback
+from scipy._lib._util import _call_callback_maybe_halt
 from excitationsolve import excitation_solve_step, excitation_solve_step_shared_param
 
 
@@ -14,7 +16,9 @@ class ExcitationSolveScipy:
         ```python
             excsolve_obj = ExcitationSolveScipy(maxiter=100, tol=1e-10, save_parameters=True)
             optimizer = excsolve_obj.minimize
-            res = scipy.optimize.minimize(cost, params, method=optimizer)
+            def callback(xk): # or callback(intermediate_result)
+                print(xk)
+            res = scipy.optimize.minimize(cost, params, method=optimizer, callback=callback, options=dict(parameter_occ=parameter_occ))
             energies = excsolve_obj.energies
             counts = excsolve_obj.nfevs
         ```
@@ -71,10 +75,30 @@ class ExcitationSolveScipy:
                                                    how many excitations share each parameter.
                                                    parameter_occ[i] is the number of times the i-th parameter occurs in different excitations.
                                                    Defaults to [1, 1, ...] (all set to 1).
+            callback (callable, optional): A callable called after each iteration. Supports a callable with the signature::
+
+                                                callback(intermediate_result: OptimizeResult)
+
+                                           where ``intermediate_result`` is a keyword parameter containing an
+                                           `OptimizeResult` with attributes ``x`` and ``fun``, the present values
+                                           of the parameter vector and objective function. Not all attributes of
+                                           `OptimizeResult` may be present. The name of the parameter must be
+                                           ``intermediate_result`` for the callback to be passed an `OptimizeResult`.
+                                           These methods will also terminate if the callback raises ``StopIteration``.
+                                           Also supports a signature like::
+
+                                                callback(xk)
+
+                                           where ``xk`` is the current parameter vector.
+                                           Introspection is used to determine which of the signatures above to
+                                           invoke.
 
         Returns:
             OptimizeResult: Scipy OptimizeResult object
         """
+        callback = kwargs.get("callback")
+        callback = _wrap_callback(callback)
+
         params_excsolve = np.array(x0.copy())
         num_params = len(params_excsolve)
 
@@ -155,6 +179,11 @@ class ExcitationSolveScipy:
             if len(self.energies_after_it) > 1 and np.abs(self.energies_after_it[-1] - self.energies_after_it[-2]) <= self.tol:
                 break
 
+            if callback is not None:
+                intermediate_result = OptimizeResult(x=np.copy(params_excsolve), fun=current_energy_excsolve)
+                if _call_callback_maybe_halt(callback, intermediate_result):
+                    break
+
         result = OptimizeResult()
         result.x = params_excsolve
         result.fun = current_energy_excsolve

{excitationsolve-2.2.0 → excitationsolve-2.2.2}/excitationsolve/info.py

@@ -1,3 +1,3 @@
-__version__ = "2.2.0"  # MAJOR.MINOR.PATCH, like in https://semver.org/
+__version__ = "2.2.2"  # MAJOR.MINOR.PATCH, like in https://semver.org/
 
 HOMEPAGE = "https://github.com/dlr-wf/ExcitationSolve"  # GitHub page

{excitationsolve-2.2.0 → excitationsolve-2.2.2/excitationsolve.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: excitationsolve
-Version: 2.2.0
+Version: 2.2.2
 Summary: ExcitationSolve: a fast globally-informed gradient-free optimizer for physically-motivated ansätze constructed of excitation operators
 Author-email: Jonas Jäger <jojaeger@cs.ubc.ca>, "Thierry N. Kaldenbach" <Thierry.Kaldenbach@dlr.de>, Max Haas <Max.Haas@dlr.de>, Erik Schultheis <Erik.Schultheis@dlr.de>
 License:        Copyright 2025 Jonas Jäger, Thierry N. Kaldenbach, Max Haas, Erik Schultheis,
@@ -292,6 +292,16 @@ energies = excsolve_obj.energies
 counts = excsolve_obj.nfevs
 ```
 
+### Testing
+To run the tests, install the needed dependencies with
+```bash
+uv pip install .[test]
+```
+and execute
+```bash
+pytest
+```
+
 
 ## Authors
 - Jonas Jäger

{excitationsolve-2.2.0 → excitationsolve-2.2.2}/excitationsolve.egg-info/SOURCES.txt

@@ -24,4 +24,5 @@ excitationsolve.egg-info/requires.txt
 excitationsolve.egg-info/top_level.txt
 tests/pyscf_molecules.py
 tests/tcc_helpers.py
-tests/tcc_tests.py
+tests/test_callback.py
+tests/test_tcc.py

excitationsolve-2.2.2/tests/test_callback.py

@@ -0,0 +1,266 @@
+import time
+import numpy as np
+import scipy
+import matplotlib.pyplot as plt
+from pyscf import scf, gto, fci, ao2mo
+from tencirchem import UCCSD
+import tcc_helpers
+import pyscf_molecules
+from excitationsolve import ExcitationSolveScipy
+import logging
+
+
+def test_tcc_h3plus_callback_xk():
+    logging.basicConfig(level=logging.INFO)
+
+    # molecule = pyscf_molecules.H_chain.build_hydrogen_chain(2)
+    molecule = pyscf_molecules.H3plus
+    symbols = molecule.symbols
+    basis = molecule.basis
+    geometry = molecule.geometry
+    charge = molecule.charge
+
+    atom = "; ".join([f"{a} {', '.join([str(x) for x in p.tolist()])}" for a, p in zip(symbols, geometry)])
+    symbols_unique, unique_counts = np.unique(symbols, return_counts=True)
+    molname = "".join([f"{a}{n}" for a, n in zip(symbols_unique, unique_counts)])
+    if charge > 0:
+        molname += "+" * np.abs(charge)
+    elif charge < 0:
+        molname += "-" * np.abs(charge)
+
+    unit = "Angstrom"  # Angstrom or Bohr
+    mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
+    _electrons = mol_pyscf.nelectron
+    rhf = scf.RHF(mol_pyscf)
+    _hf_energy = rhf.kernel()
+
+    _mo_occ = rhf.mo_occ
+
+    print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
+    tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
+    print(f"{tcc_uccsd.engine=}")
+    rhf.mo_coeff = tcc_uccsd.hf.mo_coeff
+
+    fci_calc = fci.FCI(mol_pyscf, rhf.mo_coeff)
+    fci_energy, ci_vector = fci_calc.kernel()
+    print(f"FCI Energy: {fci_energy} Ha")
+
+    reference_energy = fci_energy
+
+    # one_ao = mol_pyscf.intor_symmetric("int1e_kin") + mol_pyscf.intor_symmetric("int1e_nuc")
+    # two_ao = mol_pyscf.intor("int2e_sph")
+    # one_mo = np.einsum("pi,pq,qj->ij", rhf.mo_coeff, one_ao, rhf.mo_coeff) * 1.0
+    # two_mo = ao2mo.incore.full(two_ao, rhf.mo_coeff) * 1.0
+    # two_mo = two_mo.swapaxes(1, 2).swapaxes(2, 3)  # to physicist order
+    # core_constant = rhf.energy_nuc()
+
+    nelec = mol_pyscf.nelec
+    norb = mol_pyscf.nao
+
+    # energy_offset = core_constant
+
+    #####################################################################################
+    ##                                 Define Ansatz                                   ##
+    #####################################################################################
+    singles_pool = tcc_helpers.get_ex1_ops(norb, nelec)
+    doubles_pool = tcc_helpers.get_ex2_ops(norb, nelec)
+    singles_pool_sorted = sorted(singles_pool)
+    doubles_pool_sorted = sorted([(*sorted(x[:2]), *sorted(x[2:])) for x in doubles_pool])
+    # complete_pool = doubles_pool_sorted + singles_pool_sorted
+    complete_pool = singles_pool_sorted + doubles_pool_sorted
+
+    tcc_uccsd.ex_ops = complete_pool
+    # tcc_uccsd.param_ids = None
+    # tcc_uccsd.param_ids = [0, 0, 1]
+    print(f"{tcc_uccsd.param_ids=}")
+
+    n_params = len(complete_pool)
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+
+    #######################
+    # Manual optimization
+    times_tcc = []
+    eval_count_tcc = 0
+    counts_tcc = []
+    values_tcc = []
+    tcc_vqe_params_lst = []
+
+    def cost(x):
+        nonlocal times_tcc
+        nonlocal eval_count_tcc
+        nonlocal counts_tcc
+        nonlocal values_tcc
+
+        tcc_energy = tcc_uccsd.energy(x)
+        times_tcc.append(time.perf_counter())
+
+        eval_count_tcc += 1
+        print(
+            f"Optimizer evaluation #{eval_count_tcc}, Diff. to ref.: {np.abs(tcc_energy - reference_energy)}",
+            end="\r",
+            flush=True,
+        )
+        counts_tcc.append(eval_count_tcc)
+        values_tcc.append(tcc_energy)
+        tcc_vqe_params_lst.append(x)
+
+        return tcc_energy
+
+    callback_works = False
+
+    def callback(xk):
+        nonlocal callback_works
+        callback_works = True
+        print(f" ========= From callback: {xk=} =========")
+
+    maxiter = 100
+    excsolve_obj = ExcitationSolveScipy(maxiter=maxiter, tol=1e-10, save_parameters=True)
+    optimizer_func = excsolve_obj.minimize
+    _, parameter_occ = np.unique(tcc_uccsd.param_ids, return_counts=True)
+    options = dict(reference_energy=reference_energy, parameter_occ=parameter_occ)
+
+    n_params_tmp = tcc_uccsd.n_params
+    initial_params = np.zeros(n_params_tmp)
+    res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, callback=callback, options=options)
+    _params_tcc = res_tcc.x
+
+    print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")
+
+    # plt.plot(excsolve_obj.nfevs, np.abs(excsolve_obj.energies - reference_energy))
+    # plt.plot(excsolve_obj.nfevs_after_it, np.abs(excsolve_obj.energies_after_it - reference_energy), linestyle="", marker="x")
+    # for x in excsolve_obj.nfevs_after_it:
+    #     plt.axvline(x, linestyle="--", color="black", alpha=0.5)
+    # plt.yscale("log")
+    # plt.grid()
+    # plt.show()
+
+    assert callback_works, "Callback does not work!"
+
+
+def test_tcc_h3plus_callback_intermediateresult():
+    logging.basicConfig(level=logging.INFO)
+
+    # molecule = pyscf_molecules.H_chain.build_hydrogen_chain(2)
+    molecule = pyscf_molecules.H3plus
+    symbols = molecule.symbols
+    basis = molecule.basis
+    geometry = molecule.geometry
+    charge = molecule.charge
+
+    atom = "; ".join([f"{a} {', '.join([str(x) for x in p.tolist()])}" for a, p in zip(symbols, geometry)])
+    symbols_unique, unique_counts = np.unique(symbols, return_counts=True)
+    molname = "".join([f"{a}{n}" for a, n in zip(symbols_unique, unique_counts)])
+    if charge > 0:
+        molname += "+" * np.abs(charge)
+    elif charge < 0:
+        molname += "-" * np.abs(charge)
+
+    unit = "Angstrom"  # Angstrom or Bohr
+    mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
+    _electrons = mol_pyscf.nelectron
+    rhf = scf.RHF(mol_pyscf)
+    _hf_energy = rhf.kernel()
+
+    _mo_occ = rhf.mo_occ
+
+    print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
+    tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
+    print(f"{tcc_uccsd.engine=}")
+    rhf.mo_coeff = tcc_uccsd.hf.mo_coeff
+
+    fci_calc = fci.FCI(mol_pyscf, rhf.mo_coeff)
+    fci_energy, ci_vector = fci_calc.kernel()
+    print(f"FCI Energy: {fci_energy} Ha")
+
+    reference_energy = fci_energy
+
+    # one_ao = mol_pyscf.intor_symmetric("int1e_kin") + mol_pyscf.intor_symmetric("int1e_nuc")
+    # two_ao = mol_pyscf.intor("int2e_sph")
+    # one_mo = np.einsum("pi,pq,qj->ij", rhf.mo_coeff, one_ao, rhf.mo_coeff) * 1.0
+    # two_mo = ao2mo.incore.full(two_ao, rhf.mo_coeff) * 1.0
+    # two_mo = two_mo.swapaxes(1, 2).swapaxes(2, 3)  # to physicist order
+    # core_constant = rhf.energy_nuc()
+
+    nelec = mol_pyscf.nelec
+    norb = mol_pyscf.nao
+
+    # energy_offset = core_constant
+
+    #####################################################################################
+    ##                                 Define Ansatz                                   ##
+    #####################################################################################
+    singles_pool = tcc_helpers.get_ex1_ops(norb, nelec)
+    doubles_pool = tcc_helpers.get_ex2_ops(norb, nelec)
+    singles_pool_sorted = sorted(singles_pool)
+    doubles_pool_sorted = sorted([(*sorted(x[:2]), *sorted(x[2:])) for x in doubles_pool])
+    # complete_pool = doubles_pool_sorted + singles_pool_sorted
+    complete_pool = singles_pool_sorted + doubles_pool_sorted
+
+    tcc_uccsd.ex_ops = complete_pool
+    # tcc_uccsd.param_ids = None
+    # tcc_uccsd.param_ids = [0, 0, 1]
+    print(f"{tcc_uccsd.param_ids=}")
+
+    n_params = len(complete_pool)
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+
+    #######################
+    # Manual optimization
+    times_tcc = []
+    eval_count_tcc = 0
+    counts_tcc = []
+    values_tcc = []
+    tcc_vqe_params_lst = []
+
+    def cost(x):
+        nonlocal times_tcc
+        nonlocal eval_count_tcc
+        nonlocal counts_tcc
+        nonlocal values_tcc
+
+        tcc_energy = tcc_uccsd.energy(x)
+        times_tcc.append(time.perf_counter())
+
+        eval_count_tcc += 1
+        print(
+            f"Optimizer evaluation #{eval_count_tcc}, Diff. to ref.: {np.abs(tcc_energy - reference_energy)}",
+            end="\r",
+            flush=True,
+        )
+        counts_tcc.append(eval_count_tcc)
+        values_tcc.append(tcc_energy)
+        tcc_vqe_params_lst.append(x)
+
+        return tcc_energy
+
+    callback_works = False
+
+    def callback(intermediate_result):
+        nonlocal callback_works
+        callback_works = True
+        print(f" ========= From callback: {intermediate_result.x=} | {intermediate_result.fun=} =========")
+
+    maxiter = 100
+    excsolve_obj = ExcitationSolveScipy(maxiter=maxiter, tol=1e-10, save_parameters=True)
+    optimizer_func = excsolve_obj.minimize
+    _, parameter_occ = np.unique(tcc_uccsd.param_ids, return_counts=True)
+    options = dict(reference_energy=reference_energy, parameter_occ=parameter_occ)
+
+    n_params_tmp = tcc_uccsd.n_params
+    initial_params = np.zeros(n_params_tmp)
+    res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, callback=callback, options=options)
+    _params_tcc = res_tcc.x
+
+    print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")
+
+    # plt.plot(excsolve_obj.nfevs, np.abs(excsolve_obj.energies - reference_energy))
+    # plt.plot(excsolve_obj.nfevs_after_it, np.abs(excsolve_obj.energies_after_it - reference_energy), linestyle="", marker="x")
+    # for x in excsolve_obj.nfevs_after_it:
+    #     plt.axvline(x, linestyle="--", color="black", alpha=0.5)
+    # plt.yscale("log")
+    # plt.grid()
+    # plt.show()
+
+    assert callback_works, "Callback does not work!"

excitationsolve-2.2.0/tests/tcc_tests.py → excitationsolve-2.2.2/tests/test_tcc.py

@@ -30,11 +30,11 @@ def test_tcc_h3plus_mult_occurence():
 
     unit = "Angstrom"  # Angstrom or Bohr
     mol_pyscf = gto.M(atom=atom, basis=basis, charge=charge, unit=unit)
-    electrons = mol_pyscf.nelectron
+    _electrons = mol_pyscf.nelectron
     rhf = scf.RHF(mol_pyscf)
-    hf_energy = rhf.kernel()
+    _hf_energy = rhf.kernel()
 
-    mo_occ = rhf.mo_occ
+    _mo_occ = rhf.mo_occ
 
     print(f"Building TCC Hamiltonian for {molname} (early build to use TCC canonicalized MO-coefficients) ...")
     tcc_uccsd = UCCSD(rhf, init_method="zeros", run_hf=False, run_mp2=False, run_ccsd=False, run_fci=True)  # TCC params = -params
@@ -75,8 +75,8 @@ def test_tcc_h3plus_mult_occurence():
     print(f"{tcc_uccsd.param_ids=}")
 
     n_params = len(complete_pool)
-    params = np.zeros(n_params)
-    ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
+    _params = np.zeros(n_params)
+    _ex_ops = [(x[: len(x) // 2], x[len(x) // 2 :]) for x in complete_pool]
 
     #######################
     # Manual optimization
@@ -116,7 +116,7 @@ def test_tcc_h3plus_mult_occurence():
     n_params_tmp = tcc_uccsd.n_params
     initial_params = np.zeros(n_params_tmp)
     res_tcc = scipy.optimize.minimize(cost, initial_params, method=optimizer_func, options=options)
-    params_tcc = res_tcc.x
+    _params_tcc = res_tcc.x
 
     print(f"\nFinal energy difference: {(res_tcc.fun - reference_energy):.2e}")