[ENH] Tidy up the rocket transformers

[TonyBagnall]

Describe the feature or idea you want to propose

Its time to tidy up the convolutional transformers, will collate all issues here and make tasks for smaller PRs. Replaces #208

To Do

• Combine minirocket and minirocket variable length
• GPU implementations, benchmark vs CPU [ENH] ROCKET variants in GPU implementation #313 [MNT] Test consistency between CPU & GPU version of ROCKET #1248
• Profile memory usage [BUG] Excessive memory consumption of ROCKET #1126
• Tidy up multirocket implementation, remove duplicate methods and repeated code from minirocket
• Decorate numba functions in rocket, test if any speed up
• Test for numpy 2 compatibility, and optimise (e.g. G = _X + _X + _X)

Done

• Minirocket has hard coded arrays that reduce readability. Replace with a numba function Done: [ENH] Remove two hard coded arrays from minirocket #1698
• Combine minirocket and minirocket multivariate [ENH] Merge MiniRocket and MiniRocketMultivariate #1708
• Benchmark variants against alternative implementations [ENH] Benchmark ROCKET variants against other implementations #214
• Combine two multirocket variants into one [ENH] Merge MultiRocket and MultiRocketMultivariate #1711

[TonyBagnall]

Time wise results as expected, also comparable to other implementations. This to transform different length series in a univariate collection size of 100, length on x axis, y axis is seconds

[TonyBagnall]

after #1781, next issue is to allow variable length. #1746 PR does it by taking numba inside the loop, but it slows it down unacceptably. An alternative, which is already in Rocket, is not to give types in njit arguments. Surprisingly, Rocket does not do this

@njit(fastmath=True, cache=True)
def _apply_kernel_univariate(X, weights, length, bias, dilation, padding):
    n_timepoints = len(X)

    output_length = (n_timepoints + (2 * padding)) - ((length - 1) * dilation)

whereas minirocket does

@njit(
    "float32[:,:](float32[:,:],Tuple((int32[:],int32[:],int32[:],int32[:],float32["
    ":])), int32[:,:])",
    fastmath=True,
    parallel=True,
    cache=True,
)
def _static_transform_uni(X, parameters, indices):

without them, its much easier to use multivariate, but crucially need to assess any performance hit. So some timing experiments

1. Run minirocket both with and without the annotation and time it, passing 3D numpy
2. Run rocket both with and without the annotation and time it (possible speed up for main),

based on these results, either remove type annotation and adapt to lists of numpy or add them and use split functions

[TonyBagnall]

Code to test 1 and 2, including direct code without

def timing_experiment_n_cases_main():
    import time
    # Build numba functions
    X = np.random.random(size=(10, 1, 100)).astype(np.float32)
    r = MiniRocket(random_state=0)
    p1 = r.fit_transform(X)
    r2 = MiniRocket(random_state=0)
    p2= r2.fit_transform(X)
    r3 =BadPlaceMiniRocket(random_state=0)
    r4 = BadPlaceMiniRocketMultivariate(random_state=0)
    p3= r3.fit_transform(X)
    p4=r4.fit_transform(X)

    for i in range(500,31000,500):
        X1 = make_example_3d_numpy(n_cases=i, n_channels=1, n_timepoints=500,
                                   return_y=False).astype(np.float32)
        X2 = make_example_3d_numpy(n_cases=i, n_channels=5, n_timepoints=100,
                                   return_y=False).astype(np.float32)

        from aeon.transformations.collection.convolution_based._minirocket import \
            _static_fit, _static_transform_uni, _static_transform_multi
        start = time.time()
        r.fit_transform(X1)
        t1 = time.time() - start
        start = time.time()
        r.fit_transform(X2)
        t2 = time.time() - start
        start = time.time()
        p1=_static_fit(X1)
        X_= X1.squeeze(1)
        _static_transform_uni(X_,p1,MiniRocket._indices)
        t3 = time.time() - start
        start = time.time()
        p1=_static_fit(X2)
        _static_transform_multi(X2,p1,MiniRocket._indices)
        t4 = time.time() - start
        start = time.time()
        r2._fit_transform(X1)
        t5 = time.time() - start
        start = time.time()
        r2._fit_transform(X2)
        t6 = time.time() - start
        start = time.time()
        r3.fit_transform(X1)
        t7 = time.time() - start
        start = time.time()
        r4.fit_transform(X2)
        t8 = time.time() - start

        print(i,",",t1,",",t2,",",t3,",",t4,",",t5,",",t6,",",t7,",",t8)