Update Katz_FD

[PiethonProgram]

Fixed Katz_FD implementation by utilizing Euclidean distances. Also modified test cases to include tests for new method.

[raphaelvallat]

Thank you @PiethonProgram — I'll aim to review the PR later this week. In the meantime, please make sure that the CI tests and lint tests are all passing.

[PiethonProgram]

Applied formatting changes and should pass lint cases.

Changed self.assertEqual(np.round(katz_fd(x_k), 3), VALUE) from VALUE = 5.783 to 1.503 to reflect formula change
Please double check calculations ^

[raphaelvallat]

Hi @PiethonProgram,

I think that this implementation can be simplified, for example by following the proposed new implementation in: #34, or by leveraging the Neurokit2 implementation (which as of present gives the same output as Antropy): https://github.com/neuropsychology/NeuroKit/blob/45c9ad90d863ebf4e9d043b975a10d9f8fdeb06b/neurokit2/complexity/fractal_katz.py#L6

[PiethonProgram]

Sounds good, I will make the adjustments.

[PiethonProgram]

Hello, I have taken a look at the implementations you mentioned. Are you sure it can be simplified? Previous implementations that you mentioned are shorter since they are all single-channel.
If you want to only offer single-channel feature extraction then I can make the changes, but otherwise, unless you want to try and decrease time using Numba, I don't think there is much I can "simplify."

[raphaelvallat]

Good point about the support for ND arrays. I have not yet found the time to do a deep dive into this, but can we just take the existing implementation of Antropy (see below) and replace the distance calculation by the Euclidean distance?

dists = np.abs(np.diff(x, axis=axis))
ll = dists.sum(axis=axis)
ln = np.log10(ll / dists.mean(axis=axis))
aux_d = x - np.take(x, indices=[0], axis=axis)
d = np.max(np.abs(aux_d), axis=axis)
kfd = np.squeeze(ln / (ln + np.log10(d / ll)))

or is there more to your implementation that I'm missing?

Thank you

[PiethonProgram]

I think the essence of the code is the same, but some additional "bits" are needed when using Euclidean distance in n-dimensions in order to check for distances from one to the other.
If we were only speaking in 1-dimension, then yes, we can simply just replace the distance calculation line.

[PiethonProgram]

Should I be concerned with the unsuccessful checks :
Python tests / build (macos-latest, 3.8) (pull_request)
Python tests / build (macos-latest, 3.9) (pull_request)
Python tests / build (macos-latest, 3.10) (pull_request)

It seems the issue is related to GitHub versions, and not the code itself.

[raphaelvallat]

Yeah don't worry about the CI failures, I need to make some upgrade to the GitHub Actions workflow. Thanks!

[PiethonProgram]

Reformatted and "simplified" code.

Note : Black formatting caused line 208 in fractal.py to expand into 7 lines (likely due to nested parenthesis restrictions) <= No impact on functions, just aesthetics.

[raphaelvallat]

Hey,

Thanks again for the implementation and the PR.

1. I was looking at the output of the proposed implementation, and it seems that, regardless of the complexity of the input time-series, the output values are always between 1 and 1.01. The original paper described that the value should be ~1.5 for random signals:

Under this formulation, fractal dimensions range from D = 1.0, for strainght lines through approximately D = 1.15 for random-walk waveforms, to D approaching 1.5 for the most convoluted waveforms.

import stochastic.processes.noise as sn
rng = np.random.default_rng(seed=42)

X = np.vstack([
    np.arange(1000),
    np.sin(2 * np.pi * 1 * np.arange(1000) / 100),
    sn.FractionalGaussianNoise(hurst=0.1, rng=rng).sample(1000),
    sn.FractionalGaussianNoise(hurst=0.9, rng=rng).sample(1000),
    rng.random(1000),
    rng.random(1000)]
)
katz_new(X)

array([1.        , 1.00014255, 1.03727155, 1.00000014, 1.01079616, 1.01072551])

2. I also have found this paper which uses the same definition as the current implementation in Antropy:

fractalfract-08-00009.pdf

3. I also took a stab at improving the current implementation based on the neurokit2 implementation:

def katz(x):
    # Define total length of curve
    dists = np.abs(np.diff(x, axis=axis))
    length = np.sum(dists, axis=axis)
    
    # Average distance between successive points
    a = np.mean(dists, axis=axis)
    
    # Compute farthest distance between starting point and any other point
    d = np.max(np.abs(x.T - x[..., 0]).T, axis=axis)
    return np.log10(length / a) / (np.log10(d / a))

[PiethonProgram]

Hi @raphaelvallat , thanks for the catch.

1. I will look into it for possible issues
2. I believe the implementation in the paper refers to single dimension time-series
3. will build and test on this. Solid implementation

[PiethonProgram]

Hi @raphaelvallat ,

1. I wasn’t able to replicate the exact output from your implementation, but I’ve adjusted it to ensure it functions as expected. It now produces consistent results.
2. It appears that the approach described in the report differs from our current implementation, though both seem to yield the same output when tested.

Please let me know your thoughts.

[raphaelvallat]

Thank you for looking into this! Two very minor comments but otherwise I think we are good to merge.

To clarify for others: this PR is just a simplification of the existing implementation. It does not update the distance calculation to use Euclidean distance, as originally discussed in #34

[raphaelvallat]

remove extra line

[raphaelvallat]

feel free to remove this commented line

[PiethonProgram]

Hi, the changes have been made. Please let me know if there is anything else, and thank you for your cooperation as well.