pyFDN 0.3.0__tar.gz → 0.4.0__tar.gz

{pyfdn-0.3.0 → pyfdn-0.4.0}/CONTRIBUTING.rst

@@ -150,11 +150,11 @@ documentation sources, and tests:
   time-domain graph. ``process_fdn`` uses ``MatrixFIR`` for polynomial feedback
   matrices; ``SOSBank`` implements per-delay-line filter cascades used for
   frequency-dependent absorption.
-* ``src/pyFDN/graphicEQ/`` contains graphic-EQ and absorption-filter design,
-  while ``src/pyFDN/translate/`` converts between delay state-space, transfer
+* ``src/pyFDN/eq/`` contains every EQ and absorption-filter design, while
+  ``src/pyFDN/translate/`` converts between delay state-space, transfer
   function, pole-residue, impulse-response, and FLAMO representations.
-* ``src/pyFDN/train/`` contains the trainable FDN construction, objectives,
-  and optimization loop. ``src/pyFDN/auxiliary/`` holds shared analysis,
+* ``src/pyFDN/train/`` contains the trainable FDN construction, the composable
+  losses in ``train/losses/``, and the optimization loop. ``src/pyFDN/auxiliary/`` holds shared analysis,
   plotting, audio, delay, and numerical helpers.
 * ``examples/`` contains executable Marimo notebooks. Metadata at the top of
   each ``example_*.py`` file drives the generated documentation gallery.

pyfdn-0.4.0/HISTORY.rst

@@ -0,0 +1,91 @@
+=======
+History
+=======
+
+0.4.0 (2026-08-23)
+------------------
+
+* **Breaking:** replace ``train_fdn``'s ``mode`` string, and the ``target``,
+  ``criteria``, ``sparsity_alpha`` and ``mss_nfft`` arguments that went with
+  it, with a composed loss object. An objective is now written out --
+  ``FlatMagnitude() + 0.2 * Sparsity(param(model, "feedback"))`` -- and every
+  loss is a function of the impulse response, carried as a ``Response``, so
+  losses own their reference data and one objective can fit two different
+  references. ``pyFDN.train.objectives`` and ``build_objective`` are gone.
+* **Breaking:** collect every EQ design in ``pyFDN.eq`` (formerly
+  ``pyFDN.graphicEQ``) behind one ``EQDesign`` interface, with ``GraphicEQ``,
+  ``FirstOrderShelf`` and ``OnePole`` sharing a single implementation across
+  the numpy and torch backends.
+* **Breaking:** remove ``absorption_filters`` and ``absorption_to_rt``; the FIR
+  absorption path they served has no callers left.
+* **Breaking:** name the three filter hooks ``post_delay``, ``post_matrix`` and
+  ``post_output`` everywhere -- on ``FDNBuild``, in the FLAMO graph, in the
+  plots and in the JSON schema -- and add the slot for the third. The build
+  schema is version 2; version 1 files no longer load.
+* Fix colorless training on a lossless FDN, whose poles sit on the unit circle
+  and leave ``|H|`` unbounded. ``build_fdn`` now defaults ``alias_decay_db``
+  from ``rt`` (``LOSSLESS_ALIAS_DECAY_DB`` when ``rt`` is None) and
+  ``trainable_from_build`` threads it into every module, so a magnitude
+  objective sees a bounded response.
+* Train the decay: ``DecayFilter`` parametrizes the in-loop absorption filter
+  by reverberation time per band, so the loop stays contractive for every value
+  the parameter can take, and takes either one RT curve for the network or one
+  per delay line. ``OutputEQ`` trains the output filter outside the recursion,
+  the only part of an FDN that shapes the spectral envelope without touching
+  the decay. Both are passed as the ``post_delay`` and ``post_output`` hooks of
+  ``trainable_from_build``.
+* Add the losses that go with it: ``AsymmetricFlatMagnitude``,
+  ``FlatSpectrogram``, ``MatchEnergyDecay``, ``MatchCumulativeEnergy``,
+  ``MatchMagnitude``, ``MatchSpectrogram``, ``MatchMelSpectrogram``,
+  ``MatchImpulseResponse``, ``Energy``, ``Sparsity``, ``L1`` and ``L2``.
+* Resolve trainable parameters by name: ``param(model, "feedback")`` fails
+  where you write it with the list of available names, and ``params(model)``
+  enumerates them.
+* Export the FLAMO graph builders (``assemble_fdn_core``, ``wrap_fdn_shell``,
+  ``gain_module``, ``delay_module``, ``matrix_module``, ``fir_matrix_module``,
+  ``sos_filter_module``, ``hook_module``, ``DecayFilter``, ``OutputEQ``) from
+  the top-level namespace.
+* Make ``build_to_impz`` apply all three hooks, so it no longer rejects builds
+  that carry an output EQ, and make ``extract_build`` refuse a hook it cannot
+  bake rather than silently dropping it.
+* Add an example notebook that fits every parameter of an FDN, decay included,
+  to a measured concert-hall RIR, and document the loss rationale and
+  measurements in ``docs/training_losses.rst``.
+* Fix stereo orientation in ``labeled_audio``, which decoded a stereo render as
+  thousands of channels.
+* Check packaging metadata in CI and fail the documentation build on notebook
+  cell errors.
+
+0.3.0 (2026-08-17)
+------------------
+
+* **Breaking:** replace the ``pyFDN.dsp`` subpackage with ``pyFDN.td``. The
+  top-level ``FeedbackDelay``, ``FIRMatrixFilter`` and ``SOSFilterBank``
+  exports are gone; use ``pyFDN.td`` operators instead.
+* **Breaking:** ship the packaged colorless-FDN presets as JSON rather than
+  MATLAB ``.mat`` files.
+* Add ``pyFDN.td``, a time-domain block-based processing graph built on NumPy
+  alone (no torch, no FFT), with the ``Series``, ``Parallel`` and
+  ``Recursion`` connectors and stateful ``Gain``, ``Delay``, ``SOSBank``,
+  ``MatrixFIR``, ``MatrixConvolver`` and ``TimeVaryingMatrix`` operators.
+* Add ``load_fdn_build``, ``save_fdn_build``, ``fdn_build_from_dict`` and
+  ``fdn_build_to_dict`` for reading and writing FDN builds as JSON.
+* Add an FDN-to-FAUST example that compiles a pyFDN design with adac, and a
+  reverberation-enhancement example.
+* Improve the example gallery and stop tracking generated documentation in the
+  repository.
+* Test on Python 3.14 in CI and the documentation build.
+
+0.2.0 (2026-08-10)
+------------------
+
+* Package compact audio examples and predefined colorless-FDN coefficients so
+  browser-hosted tutorials work without repository-relative files.
+* Add public APIs for packaged audio, FDN presets, and paper references.
+* Add generated documentation galleries and wheel-content checks.
+* Keep decay-estimation dependencies optional for a smaller core installation.
+
+0.1.0 (2025-07-02)
+------------------
+
+* First release on PyPI.

{pyfdn-0.3.0 → pyfdn-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyFDN
-Version: 0.3.0
+Version: 0.4.0
 Summary: Python library for Feedback Delay Networks
 Author: Sebastian J. Schlecht, Facundo Franchino, Jeremy Bai
 Maintainer: Facundo Franchino, Sebastian J. Schlecht

{pyfdn-0.3.0 → pyfdn-0.4.0}/docs/api_reference.rst

@@ -83,14 +83,9 @@ Acoustics & Absorption
    :toctree: generated/
    :nosignatures:
 
-   pyFDN.absorption_filters
-   pyFDN.first_order_absorption
-   pyFDN.first_order_shelving_eq
-   pyFDN.one_pole_absorption
    pyFDN.sos_gain_per_sample_curves
    pyFDN.echo_density
    pyFDN.edc
-   pyFDN.absorption_to_rt
    pyFDN.estimate_initial_level_bands
    pyFDN.estimate_rt_bands
    pyFDN.octave_bands
@@ -100,16 +95,31 @@ Acoustics & Absorption
    pyFDN.slope_amplitude_to_level
    pyFDN.slope_to_rt
 
-Graphic EQ
-----------
+EQ & Absorption Design (``pyFDN.eq``)
+--------------------------------------
+
+Three designs of the same two filters -- an FDN's in-loop absorption and its
+output EQ -- behind one interface. A design carries its own target and maps it
+to biquad sections in numpy or in torch from a single implementation, which is
+what a trainable :class:`pyFDN.DecayFilter` or :class:`pyFDN.OutputEQ` runs
+inside a training loop.
 
 .. autosummary::
    :toctree: generated/
    :nosignatures:
 
+   pyFDN.EQDesign
+   pyFDN.GraphicEQ
+   pyFDN.FirstOrderShelf
+   pyFDN.OnePole
    pyFDN.design_geq
+   pyFDN.geq_sos
+   pyFDN.geq_design_matrix
    pyFDN.graphic_eq
    pyFDN.absorption_geq
+   pyFDN.first_order_absorption
+   pyFDN.first_order_shelving_eq
+   pyFDN.one_pole_absorption
    pyFDN.probe_sos
    pyFDN.shelving_filter
    pyFDN.bandpass_filter
@@ -151,6 +161,29 @@ Delay Utilities
    pyFDN.flamo_time_response
    pyFDN.flamo_freq_response
 
+Building a FLAMO Graph
+----------------------
+
+An FDN as FLAMO modules, assembled from numpy values. The three filter hooks --
+``post_delay`` inside the loop, ``post_matrix`` on the feedback path,
+``post_output`` on the wet signal -- are the same three
+:func:`pyFDN.process_fdn` takes, in the same positions and under the same names.
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   pyFDN.assemble_fdn_core
+   pyFDN.wrap_fdn_shell
+   pyFDN.gain_module
+   pyFDN.delay_module
+   pyFDN.matrix_module
+   pyFDN.fir_matrix_module
+   pyFDN.sos_filter_module
+   pyFDN.hook_module
+   pyFDN.DecayFilter
+   pyFDN.OutputEQ
+
 Polynomial & Matrix Maths
 --------------------------
 
@@ -265,6 +298,38 @@ Training
    pyFDN.Trainable
    pyFDN.train_fdn
    pyFDN.TrainLog
+   pyFDN.LOSSLESS_ALIAS_DECAY_DB
+
+Training Objectives
+-------------------
+
+An objective is a weighted sum of losses, composed with ``+`` and ``*``. Losses
+on the impulse response read a :class:`pyFDN.Response`; losses on a model
+parameter take a :class:`pyFDN.ParamRef` from :func:`pyFDN.param`.
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   pyFDN.Response
+   pyFDN.model_response
+   pyFDN.param
+   pyFDN.params
+   pyFDN.ParamRef
+   pyFDN.Loss
+   pyFDN.FlatMagnitude
+   pyFDN.AsymmetricFlatMagnitude
+   pyFDN.FlatSpectrogram
+   pyFDN.MatchMagnitude
+   pyFDN.MatchSpectrogram
+   pyFDN.MatchMelSpectrogram
+   pyFDN.MatchImpulseResponse
+   pyFDN.MatchEnergyDecay
+   pyFDN.MatchCumulativeEnergy
+   pyFDN.Energy
+   pyFDN.Sparsity
+   pyFDN.L1
+   pyFDN.L2
 
 Plotting
 --------

{pyfdn-0.3.0 → pyfdn-0.4.0}/docs/conf.py

@@ -148,6 +148,17 @@ marimo_cache_notebooks = False
 #
 # This patch lives in conf.py (our repo), so the installed sphinx-marimo package
 # stays pristine and deployment (RTD / GitHub Actions) needs no vendored changes.
+#
+# Cell errors are build failures: a notebook that raises still produces HTML,
+# with the traceback baked in where the output should be, so a broken example
+# reaches the published site looking like a rendered page. We record every
+# notebook whose export exited non-zero and fail the build at the end (see
+# ``setup`` below) instead of aborting on the first one, so a single run reports
+# all of them. Set ``PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS=1`` to downgrade this back
+# to a warning when you need a build out of a knowingly broken notebook.
+_marimo_export_failures: "list[tuple[str, str]]" = []
+
+
 def _patch_marimo_static_export():
     import subprocess
 
@@ -173,8 +184,8 @@ def _patch_marimo_static_export():
         # `html` (not `html-wasm`) executes the notebook server-side with the real
         # venv and embeds the outputs. marimo returns a non-zero exit code when any
         # cell raises during execution, but it still writes the HTML (with the error
-        # baked in), so we log a warning and keep going rather than aborting the
-        # whole docs build on one bad notebook.
+        # baked in), so we record the failure and keep going; the build-finished
+        # handler turns the collected failures into a build error.
         proc = subprocess.run(
             [
                 "marimo",
@@ -190,9 +201,10 @@ def _patch_marimo_static_export():
         )
         if proc.returncode != 0:
             print(
-                f"[conf.py] WARNING: '{relative_path}' had cell errors during static "
+                f"[conf.py] ERROR: '{relative_path}' had cell errors during static "
                 f"export (output still written):\n{proc.stderr.strip()}"
             )
+            _marimo_export_failures.append((str(relative_path), proc.stderr.strip()))
 
         return {
             "name": output_name,
@@ -205,3 +217,30 @@ def _patch_marimo_static_export():
 
 
 _patch_marimo_static_export()
+
+
+def _fail_on_marimo_export_errors(app, exception):
+    """Fail the build if any notebook raised while being exported."""
+    # The build already failed for another reason; don't mask it.
+    if exception is not None or not _marimo_export_failures:
+        return
+
+    report = "\n\n".join(
+        f"{path}:\n{stderr}" for path, stderr in _marimo_export_failures
+    )
+    if os.environ.get("PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS") == "1":
+        print(
+            f"[conf.py] WARNING: {len(_marimo_export_failures)} notebook(s) had cell "
+            f"errors; failing is disabled via PYFDN_DOCS_ALLOW_NOTEBOOK_ERRORS:\n{report}"
+        )
+        return
+
+    raise RuntimeError(
+        f"{len(_marimo_export_failures)} example notebook(s) raised during static "
+        f"export. The generated HTML contains the traceback instead of the intended "
+        f"output, so this must not be published:\n\n{report}"
+    )
+
+
+def setup(app):
+    app.connect("build-finished", _fail_on_marimo_export_errors)

{pyfdn-0.3.0 → pyfdn-0.4.0}/docs/index.rst

@@ -58,6 +58,7 @@ feedback matrices, designing loop filters, and inspecting pole locations.
    usage
    examples_gallery
    api_reference
+   training_losses
    modules
    contributing
    authors

pyfdn-0.4.0/docs/training_losses.rst

@@ -0,0 +1,99 @@
+===============================
+Training losses: design notes
+===============================
+
+Why the losses in :mod:`pyFDN.train.losses` are shaped the way they are. The
+reasoning is qualitative on purpose: what is stated here is a design choice and
+its rationale, not a benchmark. Behaviour is FDN- and seed-dependent, so measure
+your own case before assuming any of it transfers.
+
+
+Flatness on the training grid depends on ``nfft``
+=================================================
+
+:class:`~pyFDN.FlatMagnitude` measures ``|H|`` at the model's DFT bins, so its
+frequency resolution *is* the model's ``nfft``. The truncation to ``nfft``
+samples is a rectangular window, so the peak-to-median range of ``|H|`` grows
+with ``nfft``, and the mean-squared error weights the tallest modes ever more
+heavily. Loss values are therefore comparable across runs at one ``nfft`` and
+not across different ones. A multi-resolution loss
+(:class:`~pyFDN.FlatSpectrogram`), whose analysis windows set their own
+resolution, is the way out.
+
+The optimization crosses long plateaus on ``FlatMagnitude``; ``train_fdn``'s
+default ``patience=10`` stops inside one. Raise it for a converged fit.
+
+
+Asymmetric flatness: peaks over dips
+====================================
+
+:class:`~pyFDN.AsymmetricFlatMagnitude` raises the two sides of the deviation
+from flat to different powers so peaks cost more than dips. The exponent, not a
+weight, is what makes it bite: at ``peak_power=4`` a peak twice as tall costs
+sixteen times as much. Flat stays the unique minimum at every ``peak_power``
+(normalizing by RMS forces ``<(1 + d)^2> = 1``), and the loss is gain-invariant.
+
+It is deliberately **not** in decibels: ``∂dB/∂|H| ∝ 1/|H|``, so in dB the
+deepest nulls dominate the gradient however lightly weighted. In linear
+magnitude the gradient is ``∝ p·(d⁺)^(p-1)``, largest at the tallest peaks,
+while a dip is bounded at ``d = -1``.
+
+The cost is steps and steadiness: that same gradient vanishes near the optimum,
+so a higher exponent takes longer to converge and varies more from seed to seed.
+The advantage over ``FlatMagnitude`` is not unconditional. Loss values are not
+comparable across ``peak_power``, or with ``FlatMagnitude``; compare the
+responses.
+
+
+Multi-resolution flatness: average over frames first
+====================================================
+
+:class:`~pyFDN.FlatSpectrogram` averages the short-time magnitudes over frames
+into a Welch estimate *before* measuring flatness. Asking each individual frame
+to be flat instead is actively harmful: an isolated echo inside a short frame
+already has a flat frame spectrum, so that objective rewards an impulsive,
+comb-filtered IR.
+
+
+Energy decay vs. spectrogram distance
+=====================================
+
+:class:`~pyFDN.MatchEnergyDecay` compares octave-band Schroeder curves. A
+magnitude spectrogram distance is not a substitute for fitting a decay: it
+compares two signals frame by frame, and two rooms with identical decay have
+uncorrelated fine structure, so predicting *silence* scores better there than
+predicting the right amount of the wrong detail. Fitted to a measured room, a
+spectrogram distance is minimized by an FDN whose RT falls well short of the
+measurement, where an energy-decay loss is not.
+
+
+Doubly-cumulated energy
+=======================
+
+:class:`~pyFDN.MatchCumulativeEnergy` integrates the short-time power spectrum
+twice — backwards in time and along frequency — and scores the RMS difference of
+the two surfaces after a compressive power.
+
+**Why cumulate twice.** The time direction is Schroeder backward integration
+(the reason ``MatchEnergyDecay`` exists). The frequency direction replaces
+splitting into octave bands: band edges are an arbitrary quantization a fit can
+satisfy on average while getting the shape wrong, whereas a cumulative sum is
+the limit of ever-finer bands and is monotone and smooth in both axes, which a
+gradient values. Read down the ``t = 0`` edge and you have the integrated
+spectrum (colour); read across the ``f = 0`` edge and you have the full-band
+decay; the interior ties them together band by band.
+
+**Compression, not decibels.** The surface spans the whole dynamic range of the
+decay, so a plain MSE would see only the first frames. Raising the normalized
+surface to a fractional ``power`` (0.5 default) compresses that range while
+staying bounded, its gradient ``∝ x^(p-1)`` finite everywhere the floor allows.
+A logarithm is worse: it turns the silence *below* the response into an
+unbounded penalty dominated by whichever bin is nearest zero.
+
+**Which way the frequency cumulation runs.** Cumulating downwards alone — the
+default, and the plain reading of "energy above this frequency" — leaves the
+bottom octave with almost no gradient, and a fit that has to *find* a decay
+tends to abandon it there. ``frequency="both"`` scores both directions and
+averages, which recovers the low end; it is the setting to reach for when the
+decay is not given. This is a matter of weighting rather than frequency
+resolution, so a longer analysis window is not the fix.

{pyfdn-0.3.0 → pyfdn-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyFDN"
-version = "0.3.0"
+version = "0.4.0"
 description = "Python library for Feedback Delay Networks"
 readme = "README.rst"
 authors = [
@@ -113,7 +113,7 @@ include = ["pyFDN*"]
 # triggers on. Usage: bump-my-version bump {major|minor|patch}
 
 [tool.bumpversion]
-current_version = "0.3.0"
+current_version = "0.4.0"
 allow_dirty = false
 commit = true
 message = "Bump version: {current_version} → {new_version}"

{pyfdn-0.3.0 → pyfdn-0.4.0}/src/pyFDN/__init__.py

@@ -3,15 +3,13 @@
 from importlib import import_module
 
 __author__ = "Facundo Franchino"
-__version__ = "0.3.0"
+__version__ = "0.4.0"
 
 __all__ = [
     # acoustics
-    "absorption_filters",
     "echo_density",
     "estimate_initial_level_bands",
     "estimate_rt_bands",
-    "absorption_to_rt",
     "edc",
     "first_order_absorption",
     "first_order_shelving_eq",
@@ -32,6 +30,17 @@ __all__ = [
     "flamo_time_response",
     "flamo_freq_response",
     "flamo_process",
+    # building a FLAMO FDN graph from numpy values
+    "assemble_fdn_core",
+    "wrap_fdn_shell",
+    "gain_module",
+    "delay_module",
+    "matrix_module",
+    "fir_matrix_module",
+    "sos_filter_module",
+    "hook_module",
+    "DecayFilter",
+    "OutputEQ",
     "audio_metadata",
     "available_audio",
     "load_audio",
@@ -70,10 +79,16 @@ __all__ = [
     "shift_matrix",
     "shift_matrix_distribute",
     "tiny_rotation_matrix",
-    # graphicEQ
+    # eq
     "absorption_geq",
     "bandpass_filter",
+    "EQDesign",
+    "FirstOrderShelf",
+    "GraphicEQ",
+    "OnePole",
     "design_geq",
+    "geq_design_matrix",
+    "geq_sos",
     "graphic_eq",
     "probe_sos",
     "shelving_filter",
@@ -133,10 +148,35 @@ __all__ = [
     # training
     "build_fdn",
     "trainable_from_build",
+    "LOSSLESS_ALIAS_DECAY_DB",
     "build_set_decay",
     "Trainable",
     "train_fdn",
     "TrainLog",
+    # training: what a loss sees
+    "Response",
+    "model_response",
+    "impulse_excitation",
+    "param",
+    "params",
+    "ParamRef",
+    # training: losses
+    "Loss",
+    "ResponseLoss",
+    "ParameterLoss",
+    "FlatMagnitude",
+    "AsymmetricFlatMagnitude",
+    "FlatSpectrogram",
+    "MatchMagnitude",
+    "MatchSpectrogram",
+    "MatchMelSpectrogram",
+    "MatchImpulseResponse",
+    "MatchEnergyDecay",
+    "MatchCumulativeEnergy",
+    "Energy",
+    "Sparsity",
+    "L1",
+    "L2",
     # plotting
     "animate",
     "plot_db_per_sample",
@@ -192,17 +232,12 @@ __all__ = [
 
 # acoustics and absorption
 from .auxiliary.acoustics import (
-    absorption_filters,
-    absorption_to_rt,
     echo_density,
     edc,
     estimate_initial_level_bands,
     estimate_rt_bands,
-    first_order_absorption,
-    first_order_shelving_eq,
     octave_band_filterbank,
     octave_bands,
-    one_pole_absorption,
     rt_to_gain_per_sample,
     rt_to_slope,
     slope_amplitude_to_level,
@@ -227,7 +262,21 @@ from .auxiliary.delay import (
     ms_to_smp,
     swap_flamo_recursion_paths,
 )
-from .auxiliary.flamo import flamo_freq_response, flamo_process, flamo_time_response
+from .auxiliary.flamo import (
+    DecayFilter,
+    OutputEQ,
+    assemble_fdn_core,
+    delay_module,
+    fir_matrix_module,
+    flamo_freq_response,
+    flamo_process,
+    flamo_time_response,
+    gain_module,
+    hook_module,
+    matrix_module,
+    sos_filter_module,
+    wrap_fdn_shell,
+)
 from .auxiliary.flamo_graph import (
     extract_build,
     flamo_model_to_nodes,
@@ -307,6 +356,23 @@ from .build_io import (
     load_fdn_build,
     save_fdn_build,
 )
+from .eq import (
+    EQDesign,
+    FirstOrderShelf,
+    GraphicEQ,
+    OnePole,
+    absorption_geq,
+    bandpass_filter,
+    design_geq,
+    first_order_absorption,
+    first_order_shelving_eq,
+    geq_design_matrix,
+    geq_sos,
+    graphic_eq,
+    one_pole_absorption,
+    probe_sos,
+    shelving_filter,
+)
 from .generate.allpass_FDN import allpass_completion
 from .generate.allpass_FDN.allpass_completion import (
     apply_diagonal_similarity,
@@ -360,14 +426,6 @@ from .generate.schroeder_reverberator import schroeder_reverberator
 from .generate.SDN import SDN
 from .generate.shift_matrix import shift_matrix
 from .generate.shift_matrix_distribute import shift_matrix_distribute
-from .graphicEQ import (
-    absorption_geq,
-    bandpass_filter,
-    design_geq,
-    graphic_eq,
-    probe_sos,
-    shelving_filter,
-)
 from .presets import available_fdn_presets, load_fdn_preset
 
 # fdn processing
@@ -376,10 +434,33 @@ from .references import paper_link, paper_reference
 
 # training (torch/flamo are imported lazily inside these)
 from .train import (
+    L1,
+    L2,
+    LOSSLESS_ALIAS_DECAY_DB,
+    AsymmetricFlatMagnitude,
+    Energy,
+    FlatMagnitude,
+    FlatSpectrogram,
+    Loss,
+    MatchCumulativeEnergy,
+    MatchEnergyDecay,
+    MatchImpulseResponse,
+    MatchMagnitude,
+    MatchMelSpectrogram,
+    MatchSpectrogram,
+    ParameterLoss,
+    ParamRef,
+    Response,
+    ResponseLoss,
+    Sparsity,
     Trainable,
     TrainLog,
     build_fdn,
     build_set_decay,
+    impulse_excitation,
+    model_response,
+    param,
+    params,
     train_fdn,
     trainable_from_build,
 )

{pyfdn-0.3.0 → pyfdn-0.4.0}/src/pyFDN/auxiliary/__init__.py

@@ -11,6 +11,7 @@ from .allpass import (
 from .audio import load_audio
 from .flamo import (
     assemble_fdn_core,
+    core_alias_decay_db,
     delay_module,
     fir_matrix_module,
     flamo_freq_response,
@@ -18,7 +19,6 @@ from .flamo import (
     flamo_time_response,
     gain_module,
     matrix_module,
-    output_layer,
     sos_filter_module,
     wrap_fdn_shell,
 )
@@ -40,7 +40,7 @@ __all__ = [
     "matrix_module",
     "assemble_fdn_core",
     "wrap_fdn_shell",
-    "output_layer",
+    "core_alias_decay_db",
     "flamo_time_response",
     "flamo_freq_response",
     "flamo_process",