Skip to content

Continuously unwaving - #14

Open
psionic-k wants to merge 247 commits into
masterfrom
continuously-unwaving
Open

psionic-k wants to merge 247 commits into
masterfrom
continuously-unwaving

Conversation

@psionic-k

@psionic-k psionic-k commented Aug 15, 2026 •

Copy link
Copy Markdown
Member

This PR represents the work to replace the DFT with a CWT and some extra tweaks to get to a viable 2026 spectrogram. The goal is about 1% GPU usage, full screen, 70dB dynamic range, 4k resolution. Adun Toridas.

  • You certify that you have the right to submit your changes under the terms of the project's licenses (MIT OR Apache-2.0)
wavelet

Something something that hack above
Sometimes my first-pass writing makes me wonder after I get away from it for
long enough.
drives me nuts when I find these old signatures.  Subconsciously probably been
avoiding test writing because I can't stand the with_context macro lol
Committing this file so we can record some final fixups with blame.

About to do some trimming of near-zero aprons and add some sanity checks.
The comment indicated that the threshold should be less than or equal to PI/c.
Well, PI/c is equal to PI/c.

Runtime cuts quite a bit, from 200ms to about 60ms.

du being the grid control parameter, this seems to control the sampling of the
mother wavelet before it is applied to genrate our daughter wavelets.
A more principled approach will focus on the resulting eps.  The summation of a
window applied to input will be used to tune this to a degree of no
consequence.
This is moving way too fast, but we'll come back when it breaks 🤡

Key questions I tried to

- Do the two transform methods agree with each other?
- Are either of the transforms correct?
- Is the resulting wavelet useful?
- Do we understand how to use this in a spectrogram?
- Do we understand what we traded for with key choices?

Okay, now time to go see if this breaks.

It's really irritating knowing that the anti-code-generation crowd wants the
wavelet library to be poured over by hand without ever putting the fucking thing
on screen to just SEE the smoke and then start triangulating what / how to
improve when there's something to motivate and prioritize...  It's completely
backwards and of course demanded by little birds chirping in the nest.

Absolute imbeciles.  The worst part is that these idiots know nothing about
getting to problems early in order to minimize risk and accelerate the delivery
of virtually everything else they ever WILL want.

Faster fucking horses.  Go to hell.
We need to generate filters.  The filters are very similar up to the decimation
level, so the new API focuses on scaling a single design by the decimation
factor.

the definitions of the guard bands still makes me want to reach for some actual
design tool that is main lobe aware, but that depends on the filter banks.  In
practice, we will have to calibrate after reassignment to level out the gaps
where a side lobe is obliterated by the ripple instead of properly attributed.

- introduced --terminal option and an early pass band solver band that can
  support more ripple when nobody is reading that region.
- CLI args changed to reflect emphasis on useful region of the new Nyquist
  post-decimation.
- Got rid of the estimator that had proven not useful anyway due to our maximal
  transition strategy.
- Printout is in dB
- RMS energy rather than peak scan.  Careful.  Post-fold, the RMS does not go
  up, but the location can change, and noise + noise = 2x noise.

Well, if we're lucky, an LLM is going to read this.  Good day!
We need the pass bands exposed in order to select a downsampling rate.  First
step is a struct to hang the settings off of..  and next it would be good to
define a filter group to just give it an f-center and sample rate and assign the
right downsampling rate index.

Also these weights are generally quite a bit better behaved.  The transition is
more attenuated overall and the stop band hits harder.  Delay is less.

Added yet unused 16x downsampling weights while seeing if it would keep working
by just continuing the same delay pattern.
10/10/10/10

Can't wait for some rejects who type with two fingers to see the commented
literal values in my weights module and presume that none of the decimal values
match binary without ever reading a goddamned line of the PMR tool that
generated them and then, from the depths of their smelly basements, convene in a
mass of stupidity to successfully "identify" the center of the center of all
slop.  There is a lot of laziness in the AI era, and far too much of it comes
from those who can't be left behind soon enough.

How do I know of these CHUDs and their basements?  "I can tell."

😼
Requires a lane mask.. I don't think divergent, instead just constraining to
lanes that will participate in actually writing an output.

I didn't like that we were reading from data ahead of the read head.  We would
not output the results... but why read it?  Nothing good can ever come of such a
read, so if the mask doesn't diverge, we should not read it.
Wanted to push this behavior up into the abstraction real quick.

The part where coherent memory doesn't need flushing will later subsume it.
* Old crimes:

- giving an address to the downstream for it to store in its control data.  Push
  constants are the right way.  Otherwise the runtime can't dual-write swap the
  address out to compact memory use.
- `CHANNELS`.  Why would this be static?
- `channel_offsets` might make sense if the memory is not laid out right there
- Doing client math to.... decide the fucking dispatch geometry before we even
  know how the shader works?  WTF is that?

* As a consequence of un-criming these crimes:

- DeviceRingView goes away
- DeviceAudioView, an actually good name, uses a single device address + channel
  count + sample count to tell shaders downstream where to find their input
- Nobody can even ask to see the allocation until they are doing something in
  the ImportSink callback, so we can potentially give that callback to someone
  else with a new audio source...
- A bunch of stupid methods gone from the consumer

A whole lot of shitty comments and things went away...  A whole lot of imprecise
wording and early ideas went away.

* NOW FOR THE PROSPERITY:

- Write more code
- The motivation for un-criming this module AND THE GUIDING LIGHTS THAT MADE IT
  CLEAR WHAT NEEDED TO HAPPEN

...All came from writing more code.

It was writing the shaders that made me appreciate the simplicity of certain
dispatch geometry, wrapping math, and ways of representing the location,
geometry, and state of the data with just a few u32s.  That was what made it
clear how much of the current module, which was very easy to pare down, needed
to die.

This module was bad.  Now it is a lot less bad.  So don't be a pussy.  Nothing
against pussies, but my god, we've been telling people for TWENTY FUCKING YEARS
that you will figure things out faster only by **getting to the motivating
problems faster**.

The only people who want "clean code" want other people to do everything for
them and then to show up, read some library examples, copy some stack overfLLM,
and collect a check.  They cannot write the code they profess to want, to
admire.  They can upvote it.  They can download it.  They can talk about how
good it is and how they're a good person who has good coding moral habits.  YET
THEY STILL CANNOT MAKE IT AND DO NOT KNOW WHERE IT COMES FROM.  They just "know"
that's what they want.

It is important for Open Source to be high quality, higher than most commercial
code, if the Open Source strategy is going to work.  Nonetheless, always
remember, programmers day in and day out wade through the tail waters of
Chernobyl beating alligators to death bare-handed and feeding them to mutated
piranhas to clear a path through lousy code, which is most commercial code, code
they are paid not to moralize about.  We can do it.  We will do it.  We need
only the motivation, and motivation comes from something WORKING.  Something
that consumers and businesses WANT.  Get to the **motivating problems** because
that is what pulls things along at the highest rate per unit of time input.

So just write code 👍
You'll never believe it... the data was already there.
follow up to 995c17c

- switch old RingLayout type in the callback to new DeviceAudioView
- get rid of split allocation / instantiation
@psionic-k

Copy link
Copy Markdown
Member Author

Planning out the work leveling on the GPU.

     16..31      104 bins
     32..63      2047 bins
     64..127     462 bins
    128..255     419 bins
    256..511     415 bins
    512..1023    393 bins
total taps 655402
  • Q = 4 at 4k resolution, with the downsampling, we have call it a million taps.
  • The 32-63 taps are going to process multiple times per audio server tick.
  • Longer bins might get a tick every few frames

Going to do some overlap ratio math to see how the multiple frames of the short bins per audio server tick turns into extra work at that scale. Sleepy. With bin load in hand, we an level the work across the device.

Don't know how it will go, but the device is going to walk all over this workload if I do it right.

@psionic-k

Copy link
Copy Markdown
Member Author
running 1 test
=== TAP LENGTHS (ring size / latency, not cost) ===
     32..63      226 bins
     64..127     2019 bins
    128..255     407 bins
    256..511     404 bins
    512..1023    403 bins
   1024..2047    381 bins

=== COST (COLA 8x) ===
  /1   rate    48000   637 bins     244.61 MMAC/s  worst window    127 taps =     2.6 ms
  /2   rate    24000   402 bins      77.18 MMAC/s  worst window    127 taps =     5.3 ms
  /4   rate    12000   402 bins      38.59 MMAC/s  worst window    127 taps =    10.6 ms
  /8   rate     6000   402 bins      19.30 MMAC/s  worst window    127 taps =    21.2 ms
  /16  rate     3000  1997 bins      47.93 MMAC/s  worst window   1971 taps =   657.0 ms
  
  total 427.61 MMAC/s
  • Low pitch bins see a MAC bump, but not even significant compared to the 24kHz and 48kHz bins
  • This is 0.5 GFLOPs, 1GFLOP for two channels, or roughly 2/5000th of my GPU's full MAC bandwidth. At lowest clock speed, maybe 12/5000 or less than 1%.
  • Weight binning above shows roughly 600k weights or about 2MB... The goal is to get the entirety of audio and weights into registers, cache, and LDS.

Headroom

  • Future downsampling work can focus on the full-rate bins. A decent number of them, especially longer ones, are actually below 1/2 Nyquist but are in what the current 2x downsampling considers to be "the transition band". If we free up the low frequency ripple for the region we don't need, we can reclaim some of that and generate an acceptable but shorter transition band and still get the black noise floor, but ultimately anything near the new Nyquist is probably unsalvageable. The transition is either eating the output or reflecting into it the closer we try to get.
  • Similarly in other bands, more aggressive transition structures and low-end ripple allowance may create headroom to shift some bins down to a next lower sample rate from every current pass band.

The PMR tool needs a configuration option for allowing strong ripple, but not amplification, in the low parts of the pass band so that we can hit our targets with a shorter transition.

Delay...

That 657ms delay on the 20Hz will be slightly aided by reassigned energies from faster bins as long as they can see 20Hz. But the problem always remains. We can't see a full extrema within one frame. We can't see a full cycle in under three frames at 60Hz. The energy will hit middle-of-window in half of 1971 taps, 1000 taps on a 3kHz signal is less than stellar.

An auxiliary window that is the minimum required for the main lobe to reject the next image is about the only tool left in the box. We have to trade worse pitch for better time resolution and then use more cross-correlation between related bins to recover pitch and amplitude. Late corrections from longer Qs won't be instantaneously available.

I'm going to clean up the tests (throwing them in integration tests) and try to implement the current state of things with some minor tweaks from these estimates.

It would be nice to decide on a common header pattern for consuming outputs,
GPU driven or host driven styles of consumption.

Downstream might want GPU driven style:
- give us one pointer and a Slang library to unpack the header.

Downstram might want smart host style:
- pack up and re-marshal a big pile of shit

The GPU driven style is more convenient, but we have to pile-of-shit-before we
can run.
I am throwing this into history.  Scrutiny may follow.
@psionic-k
psionic-k force-pushed the continuously-unwaving branch from f14733a to 36eaade Compare August 15, 2026 17:48
@psionic-k
psionic-k force-pushed the continuously-unwaving branch from 52bf690 to 15dc60e Compare August 15, 2026 17:48
Highly generated.  Looked at waves.  They are truncated and tapered.

Tests demonstrate some expected loss of fidelity.  The halo testing is wildly
insufficient.  Let's see it on the screen before we clutch our pearls amirite?
This feels very not done, but I feel very tired.  There is a Teeth that doesn't
belong to a Comb and a lot of this feels like duplication going in the wrong
direction, but it does fix the basic problem with floor being some clueless scan
of some arbitrary octaves, making the whole thing very rho dependent.

Truncation test regains the assert, and that is the correctness. Skirt test is
also a lot less garbage, but that is next for some updating.
r_hat_chirp test indicates this is the best before low Q begins degrading
It's the law.  Always use these semantics.  Taps are the filter points in a
complete hop, which is never folded.  Weights are physical in memory.
Looks like using the mirror as a fallback and probably silently failing.
Anyway, well behaved so far.
was working on something else that won't be delivered, but it does make sense to have.
The sharper taper really do deliver on many tests, but as we get to very short
filters, a failure shows up.  Super low knee values are a bit dangerous.

Gamma = 2.0 has a slight bobble at very specific `u`, but IIRC the fallback just
makes this a bump.  Lower gamma has a virtue for filter **banks** that is being
explored.

Other stuff, just tired of looking at the uncommitted settings.
This was just a short gadget made while exploring banks, not individual filters.
@psionic-k
psionic-k force-pushed the continuously-unwaving branch from bb18bd0 to 57ff20a Compare September 25, 2026 01:43
- Grid now carries wavelet's Shape
- Taper uses analytic slope estimate beyond ANALYTIC_DB, -120dB, avoiding the
  region where oscillations begin.
- All Tapers clamp to F32_MIN_CLIFF to avoid tapering what the sum on the device
  can't see anyway.  This preserves body in cases where, for example, the
  Cylinder taper would core the algebraic tail almost completely and only make
  the filter worse overall.
- If the ANALYTIC_DB is set too low, we get a warning and a fallback whenever
  slope is reversed, meaning we're not falling back early enough.

Fixes non-finite weights detected by debug_assert in `Bin::write`.
The clamps were a bit off.  Curvature oscillation also begins sooner than
expected, and the analytic result is yielding a more consistent spectrum.
- the floor is now always the antipode, within some reasonable radius.  provides
  a consistent surrogate signal for roll-off, floor curvature, etc.  Any floors
  in the positive spectrum are unreliable if they are forced to land somewhere
  on a wide skirt, making the floor readings depend on Q and truncation, exactly
  not what we ever wanted

- PSL now reads dips, skips very minor dips, and can walk out of a well near the
  main lobe for cases similar to the ultraspherical, which absolutely happen
  when looking at large numbers of test points.

- overall inspection and harness code was simplified incidentally.

- Skirt test rework now quite a bit more useful.  about to integrate PSL into
  our primary metrics.  Along with the antipode floor, PSL gives us a very
  strong idea about how much dynamic range we have available.
got rid of the arbitrary dB floor and did energy-distance / energy, which yields
a real calculation that can, like SNR, feel pretty dB-ish.. while truly being
dB-ish.  Center frequency was chosen as the "distance" normalizer, so dB values
compare different filters well.
This commit is basically a draft of the future™, not a very complete version.
Tests exist, but they are development tests and will not be committed yet.

Q goes up proportionate to 1/N

Q-effective goes up proportionate to N^{-3/2}

If increase the filter length to Q = 8, we need 8x the filter length.  The same
taps buy 22.6x the Q-effective.  The faster growth in pitch precision is quite
welcome, especially for lower pitches.

A future consequence will be lower Q even in "constant Q" style bank arrangment.
Our existing APIs were going to struggle to answer how high Q must be and how
low the PSL of a filter must be.  A Calibration structure will cut a few
mother wavelets at different Q, using one set of Restriction and Refinement etc, and
then cut a bunch of wavelets.  From the wavelets, it creates a rough map that
can then predict the settings needed to different kinds of goals.

We build up our PSL estimation in order to support calibration.  PSL, fold, and
floor are some of the more essential and accurate results.

Some older pieces of APIs like `from_noise_floor` etc are going to fall behind
for a bit.  While creating the filter bank, the new workflows will be figured
out.
@psionic-k

Copy link
Copy Markdown
Member Author

Back to not building for viz. Created a calibration thing to enable predicting the filter settings necessary for each bin instead guess-and-check style post-calibration. The new Q-effective treatment is going to be super valuable for reducing the required size of lower pitch bins. Seems like the final push has taken shape. Once the CQT is delivered, the clouds will part and the white wolf will return from the celestial plain.

The old "kappa" was just some bullshit before I had the bright idea of adding up
the response energy * main lobe distance.

Showing two-sided E * dB better serves the role of showing us the skew in the
skirt.

E * dB is our primary tool for qualifying main lobe shapes.  If E * dB goes up,
we know we have more energy mass outside the target main lobe.  The measure is
robust against weird pre-PSL shapes, meaning it filters dippy shoulders well.
A real bump however will light up like a Christmas tree.

Dropped some columns I wasn't interested in reading, including "kappa".
The `WaveletSpec` is not something that answers questions like a `Bin`.  We use
`with_*` on `Bin` because the `Bin` API is primarily for querying but supports
mutation.  `WaveletSpec` is mostly pure mutation.
Code generator-san confused the ideas.  We're going to rename to q_reassign or
q_r for short elsewhere because q_eff is kind of ambiguous with q_real.

- q_r: effective resolution with reassignment factored in
- q_real: realized q, after truncation and everything.  deep enough truncation
  eats into the filter body and causes the bandwidth to go up.
Executive summary:

- tail modeling in `Shape` uses much more accurate approximation, similar to
  `QuadJet`
- restriction uses improved model from `Shape`.
- Taper responds to tail oscillation, obtaining about -10dB and removing
  spectrum combs in the skirt and floor!
- `from_noise_floor` and `noise_floor_is_delivered` gone.
- `truncation_is_predictable` is a rough implementation of the new `Calibration`
   bin request API to be delivered next

The first goal of calibration was to support an API for requesting bins based on
PSL, which can be interpreted as the useful dynamic range.

An old problem, the medium-ish quality of the `tail_db` approximation, emerged
as a central hurdle.  Use of the same approximation in a restriction gate became
entangled.

A fairly convoluted narrative developed...

- Improving the analytic model for tail truncation turned out to be quite
  feasible.  QuadJet itself contains approximations of QuadJet in the form of
  the saddle expansion.  These are generally not bad and much better than the
  Guassian + algebraic tail model they replace at the cost of some complexity.

- The tapering in the restriction module was using a separate, also shitty
  analytic tail model to avoid the ripple at large u.  The *gate* for this
  behavior causes floor oscillations and was screwing with the calibration,
  which can adapt to one shitty model but a shitty model and an empirical result
  from QuadJet that were arbitrarily gated.

- While making the taper re-use the improved model through `Shape`, it was
  realized that *the tail ripple was not being accounted for when applying
  tapers!*  If we core a cylinder out of a rippling tail, we're making it
  oscillate at a *higher* relative amplitude!   So this was fixed incidentally
  at the cost of being an unreadable commit.

- The old `from_noise_floor` API was dropped to make way for replacement with a
  PSL based API on the `Calibration`.

- Tests such as `noise_floor_is_delivered` were removed

- A very basic, very rough draft of requesting a filter via PSL from
  `Calibration` as bolted onto the `truncation_is_predictable` test, which had
  already been augmented to report PSL, so the whole change was delivered
  together.

Adun Toridas
Testing showed zero effects down to much lower grid resolution.  Improves baking
speeds.  Quadrature tends to random-walk the unbiased error, so precision
doesn't really wander that far at lower grid spacings.
see mod comments

and let u/Wb9VBScxu2uZJHeq2E3W observe that as long as some write the commits
while others talk about hypothetical virtues with abstract benefits, the talkers
can live in infamy.
Couldn't deny the `r_hat` tests looked a bit better.  Everything else looked
fine.  Just going with them until better testing / spectral tuning is available.

In particular, the refinment nulls are not mirrored with these settings.  Not
sure what that's about.  Might have changed something else.
probably just get rid of it and associated gate.

for now, this prevents a random jump in the floor behavior that calibration was
very capable of seeing and then trying to fit and making the fit look less
good...

applying the tapers in a ripple-accommodating manner was by far the bigger win
since it meant dips in the ripple weren't being almost zeroed.

there are other options.  too tired to write them out coherently.  but there is another.
- bins no longer add an arbitrary extra tap.  this made the math more
  consistent and consequently calibration tightened up
- calibration's printout was drastically overhauled for readability after
  figuring out what values could be useful
- load quantum is in the calibration matrix
- how some values are scored was updated for the (not load quantum) N tap
  quantization of resolved u.
- calibration was re-organized around PSL requests since it behaves better and
  consequently makes all other calibration land better

Just read the calibration output and be much more pleased with this second-ish
pass.
@psionic-k

Copy link
Copy Markdown
Member Author

Remaining work between me in the shader writing is mostly about filter bank planning. I'm exploiting some effects where the effective pitch resolution scales as N^{-3/2} instead of N. The Q and truncation calibration work feed that work. Measuring the effective pitch resolution is also the decider for "What is a good filter setting?" Did the planning tonight.

The the DC main lobe compression, chord deconfusion, and high pitch avoidance of noise floor and Nyquist fold of the skirt are among three known problems that need some engineering to pick the right length, shape, and truncation for each filter. Testing focused on transient response has greatly increased the capability to evaluate changes where it will matter the most. Developing the pitch precision calibration will provide another layer that starts telling us where spectral tuning wins can be had.

@psionic-k

Copy link
Copy Markdown
Member Author

I've been working on the gather implementation. Projecting the sound onto the 4k little filters is the scatter. The gather is where the output goes to the bins.

=== GATHER SURVEY, chirps and vibrato (Q 5, γ 3, floor -80 dB, 440 filters and 440 bins per octave, cola 8, W 192 (240 Hz)) ===
  881 tracks over every case's band, history margin 36.540970760065306 σ, per unit truth
  error is the mean over seeds against each seed's truth
  truth carries each frame at the Σ μ the bank saw
  bias scores the mean profile against the mean truth
  outside is truth held by the reservoirs, bank is Σ μ / Σ truth before rescaling

                           band ¢ frames   R  bins  outside    bank      se
            chirp    -130 to +130      6   8    99   -0.00%  0.9999  0.0000
test dsp::wavelet::tests::gather::test::survey_modulation has been running for over 60 seconds
            decay      -60 to +60      8   8    47   -0.00%  1.0444  0.0000
          vibrato      -60 to +60      4   8    47   -0.00%  1.0000  0.0000
  vibrato cluster      -80 to +80      4   8    63   -0.00%  1.0189  0.1902

  11280 bin outputs per reader

  pitch shape W₁ against seen, level normalized, cents, error (bias)
                           neutral            floor            basin           vortex              ap3
            chirp      62.3 (62.3)        3.1 (3.1)        1.5 (1.5)        1.5 (1.5)        2.2 (2.2)
            decay      30.2 (30.2)        7.2 (7.2)        2.5 (2.5)        4.0 (4.0)        5.7 (5.7)
          vibrato      26.6 (11.0)        4.0 (2.4)      12.1 (11.7)      11.6 (11.0)        6.6 (4.6)
  vibrato cluster      25.3 (20.2)       10.2 (4.9)       13.3 (8.8)       13.4 (8.4)       13.1 (7.6)

  time shape W₁ against seen, level normalized, frames, error (bias)
                           neutral            floor            basin           vortex              ap3
            chirp    1.684 (1.684)    0.159 (0.159)    0.031 (0.031)    0.031 (0.031)    0.083 (0.083)
            decay    0.000 (0.000)    0.000 (0.000)    0.366 (0.366)    0.415 (0.415)    0.016 (0.016)
          vibrato    0.781 (0.000)    0.235 (0.000)    0.443 (0.063)    0.391 (0.000)    0.371 (0.052)
  vibrato cluster    0.548 (0.214)    0.425 (0.197)    0.578 (0.357)    0.584 (0.362)    0.540 (0.267)

  gain dB, mean ± sd over frames
                           neutral            floor            basin           vortex              ap3
            chirp     -2.36 ± 0.27     -0.02 ± 0.02     -0.00 ± 0.00     -0.00 ± 0.00     -0.00 ± 0.00
            decay     -4.95 ± 0.00     -0.02 ± 0.00     -0.00 ± 0.00     -0.00 ± 0.00     -0.00 ± 0.00
          vibrato     -4.99 ± 0.02     -0.06 ± 0.03     -0.01 ± 0.00     -0.02 ± 0.01     -0.01 ± 0.01
  vibrato cluster     -3.87 ± 0.13     -0.22 ± 0.34     -0.19 ± 0.33     -0.22 ± 0.34     -0.11 ± 0.23

The ap3 name is evidence of the amount of iteration.

Feature-biased models were developed to learn things, techniques. Apophasis is a feature-neutral model that just reach initial sanity. Full lineage will be described in commit notes, just before burning down all of the garbage designs that paved the way.

A feature-neutral model is useful because, while a feature-biased model may "sharpen" better, it will introduce artifacts and lies in various real world circumstances. A feature-unbiased model has the variance conserved honestly (bias variance tradeoff) and sharpens what can be honestly sharpened.

After I get the mass conservation level, we will probably have one of the better tools on the planet. The fundamentals just don't support making inferences beyond a certain degree. References implementations included to evidence claims.

@psionic-k

Copy link
Copy Markdown
Member Author
=== GATHER SURVEY, tone polyphony (Q 5, γ 3, floor -80 dB, 440 filters and 440 bins per octave, cola 8, W 192 (240 Hz)) ===
  845 tracks over every case's band, history margin 157.84009649034286 σ, per unit truth
  error is the mean over seeds against each seed's truth
  truth carries each frame at the Σ μ the bank saw
  bias scores the mean profile against the mean truth
  outside is truth held by the reservoirs, bank is Σ μ / Σ truth before rescaling

                       band ¢ frames   R  bins  outside    bank      se
test dsp::wavelet::tests::gather::test::survey_polyphony has been running for over 60 seconds
     monotone      -40 to +40      4   8    33   -0.00%  1.0000  0.0000
    semitones      -80 to +80      4   8    63   -0.00%  1.0000  0.0230
    bracket ¼      -40 to +40      4   8    33   -0.00%  1.0000  0.0886
  bracket 20¢      -40 to +40      4   8    33   -0.00%  1.0000  0.1884
      cluster      -40 to +40      4   8    33   -0.00%  1.0000  0.2084
       masker      -40 to +40      4   8    33   99.01%  1.0000  0.0003

  7296 bin outputs per reader

  pitch shape W₁ against seen, level normalized, cents, error (bias)
                       neutral            floor            CLEAN            basin       ap4 select
     monotone      21.0 (21.0)        7.1 (7.1)        0.2 (0.2)        0.1 (0.1)        0.0 (0.0)
    semitones      20.9 (20.9)      21.8 (21.7)      46.7 (46.8)      21.7 (21.7)        2.2 (2.2)
    bracket ¼      20.4 (20.4)        6.6 (6.5)        4.1 (3.6)        3.4 (2.9)        2.6 (2.4)
  bracket 20¢      12.4 (12.4)        6.0 (6.0)      10.2 (10.2)        9.7 (9.7)        9.8 (9.8)
      cluster      10.9 (10.9)        6.4 (6.2)      11.4 (10.7)        9.6 (9.0)        9.7 (9.6)
       masker      21.1 (21.1)      14.1 (14.1)        8.4 (8.4)        9.1 (9.1)        0.3 (0.3)

  time shape W₁ against seen, level normalized, frames, error (bias)
                       neutral            floor            CLEAN            basin       ap4 select
     monotone    0.000 (0.000)    0.000 (0.000)    0.000 (0.000)    0.000 (0.000)    0.000 (0.000)
    semitones    0.009 (0.000)    0.058 (0.008)    0.173 (0.024)    0.051 (0.007)    0.004 (0.000)
    bracket ¼    0.000 (0.000)    0.326 (0.004)    1.002 (0.051)    0.924 (0.009)    0.681 (0.004)
  bracket 20¢    0.001 (0.000)    0.071 (0.001)    0.089 (0.004)    0.869 (0.229)    0.998 (0.062)
      cluster    0.002 (0.000)    0.261 (0.031)    0.490 (0.062)    0.448 (0.022)    0.311 (0.036)
       masker    0.007 (0.000)    0.004 (0.000)    0.010 (0.001)    0.002 (0.000)    0.010 (0.000)

  gain dB, mean ± sd over frames
                       neutral            floor            CLEAN            basin       ap4 select
     monotone     -6.50 ± 0.00     -0.03 ± 0.00     -0.00 ± 0.00     -0.00 ± 0.00     -0.00 ± 0.00
    semitones     -4.00 ± 0.12     -0.56 ± 0.30     -0.62 ± 0.25     -0.46 ± 0.26     -0.13 ± 0.01
    bracket ¼     -6.51 ± 0.00     -0.03 ± 0.00     -0.02 ± 0.01     -0.00 ± 0.00     -0.00 ± 0.00
  bracket 20¢     -6.55 ± 0.09     -0.28 ± 0.58     -0.17 ± 0.23     -0.24 ± 0.58     -0.06 ± 0.13
      cluster     -6.62 ± 0.13     -1.02 ± 1.39     -0.73 ± 1.05     -0.58 ± 0.79     -0.82 ± 1.73
       masker     -6.39 ± 0.07     -2.35 ± 0.03     -2.04 ± 0.03     -1.08 ± 0.08     -0.67 ± 0.09

Deep into the bias vs variance tradeoffs. More places to do work, but also getting past time to de-risk the shader implementation. Satisfied that I know what could be done if we wanted to go farther at extracting the unbiased signal.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant