rapidtide 3.0.4__py3-none-any.whl → 3.0.6__py3-none-any.whl

rapidtide/DerivativeDelay.py

@@ -1,209 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-#   Copyright 2016-2025 Blaise Frederick
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-#
-#
-"""
-A class to impmement regressor refinement
-"""
-import copy
-
-import numpy as np
-
-import rapidtide.fit as tide_fit
-import rapidtide.io as tide_io
-import rapidtide.miscmath as tide_math
-import rapidtide.refinedelay as tide_refinedelay
-import rapidtide.resample as tide_resample
-import rapidtide.stats as tide_stats
-import rapidtide.util as tide_util
-from rapidtide.tests.utils import mse
-
-
-class DerivativeDelay:
-    def __init__(
-        self,
-        internalvalidfmrishape,
-        internalvalidpaddedfmrishape,
-        pid,
-        outputname,
-        initial_fmri_x,
-        paddedinitial_fmri_x,
-        os_fmri_x,
-        genlagtc,
-        sharedmem=False,
-        gausssigma=-1,
-        numderivs=1,
-        lagminthresh=0.25,
-        lagmaxthresh=3.0,
-        sigmathresh=1000.0,
-        cleanrefined=False,
-        bipolar=False,
-        fixdelay=False,
-        includemask=None,
-        excludemask=None,
-        LGR=None,
-        nprocs=1,
-        detrendorder=1,
-        alwaysmultiproc=False,
-        showprogressbar=True,
-        chunksize=50000,
-        padtrs=10,
-        refineprenorm="var",
-        refineweighting=None,
-        refinetype="pca",
-        pcacomponents=0.8,
-        dodispersioncalc=False,
-        dispersioncalc_lower=-5.0,
-        dispersioncalc_upper=5.0,
-        dispersioncalc_step=0.5,
-        windowfunc="hamming",
-        passes=3,
-        maxpasses=15,
-        convergencethresh=None,
-        interptype="univariate",
-        usetmask=False,
-        tmask_y=None,
-        tmaskos_y=None,
-        fastresamplerpadtime=45.0,
-        debug=False,
-        rt_floattype="float64",
-        rt_floatset=np.float64,
-    ):
-        self.outputname = outputname
-        self.numderivs = numderivs
-        if gausssigma < 0.0:
-            # set gausssigma automatically
-            self.gausssigma = np.mean([xdim, ydim, slicedim]) / 2.0
-        else:
-            self.gausssigma = gausssigma
-        self.debug = debug
-        self.setgenlagtc(genlagtc)
-
-    def setgenlagtc(self, genlagtc):
-        self.genlagtc = genlagtc
-
-    def getderivratios(
-        self, fmri_data_valid, validvoxels, initial_fmri_x, lagtimes_valid, corrmask_valid
-    ):
-        print("Refinement calibration start")
-        regressderivratios = tide_refinedelay.getderivratios(
-            fmri_data_valid,
-            validvoxels,
-            initial_fmri_x,
-            lagtimes_valid,
-            corrmask_valid,
-            self.genlagtc,
-            "glm",
-            self.outputname,
-            oversamptr,
-            sLFOfitmean,
-            rvalue,
-            r2value,
-            fitNorm[:, : (self.numderivs + 1)],
-            fitcoeff[:, : (self.numderivs + 1)],
-            movingsignal,
-            lagtc,
-            filtereddata,
-            LGR,
-            TimingLGR,
-            therunoptions,
-            regressderivs=self.numderivs,
-            debug=self.debug,
-        )
-
-    def calibrate(self):
-        if self.numderivs == 1:
-            medfiltregressderivratios, filteredregressderivratios, delayoffsetMAD = (
-                tide_refinedelay.filterderivratios(
-                    regressderivratios,
-                    (xsize, ysize, numslices),
-                    validvoxels,
-                    (xdim, ydim, slicedim),
-                    gausssigma=args.delayoffsetgausssigma,
-                    patchthresh=args.delaypatchthresh,
-                    rt_floattype=rt_floattype,
-                    debug=args.debug,
-                )
-            )
-
-            # find the mapping of derivative ratios to delays
-            tide_refinedelay.trainratiotooffset(
-                self.genlagtc,
-                initial_fmri_x,
-                self.outputname,
-                args.outputlevel,
-                mindelay=args.mindelay,
-                maxdelay=args.maxdelay,
-                numpoints=args.numpoints,
-                debug=args.debug,
-            )
-            TimingLGR.info("Refinement calibration end")
-
-            # now calculate the delay offsets
-            TimingLGR.info("Calculating delay offsets")
-            delayoffset = np.zeros_like(filteredregressderivratios)
-            if args.focaldebug:
-                print(f"calculating delayoffsets for {filteredregressderivratios.shape[0]} voxels")
-            for i in range(filteredregressderivratios.shape[0]):
-                delayoffset[i], closestoffset = tide_refinedelay.ratiotodelay(
-                    filteredregressderivratios[i]
-                )
-            refinedvoxelstoreport = filteredregressderivratios.shape[0]
-        else:
-            medfiltregressderivratios = np.zeros_like(regressderivratios)
-            filteredregressderivratios = np.zeros_like(regressderivratios)
-            delayoffsetMAD = np.zeros(args.refineregressderivs, dtype=float)
-            for i in range(args.refineregressderivs):
-                (
-                    medfiltregressderivratios[i, :],
-                    filteredregressderivratios[i, :],
-                    delayoffsetMAD[i],
-                ) = tide_refinedelay.filterderivratios(
-                    regressderivratios[i, :],
-                    (xsize, ysize, numslices),
-                    validvoxels,
-                    (xdim, ydim, slicedim),
-                    gausssigma=args.delayoffsetgausssigma,
-                    patchthresh=args.delaypatchthresh,
-                    rt_floattype=rt_floattype,
-                    debug=args.debug,
-                )
-
-    def getdelays(self):
-        # now calculate the delay offsets
-        delayoffset = np.zeros_like(filteredregressderivratios[0, :])
-        if self.debug:
-            print(f"calculating delayoffsets for {filteredregressderivratios.shape[1]} voxels")
-        for i in range(filteredregressderivratios.shape[1]):
-            delayoffset[i] = tide_refinedelay.coffstodelay(
-                filteredregressderivratios[:, i],
-                mindelay=self.mindelay,
-                maxdelay=self.maxdelay,
-            )
-        refinedvoxelstoreport = filteredregressderivratios.shape[1]
-
-    def savestats(self):
-        namesuffix = "_desc-delayoffset_hist"
-        tide_stats.makeandsavehistogram(
-            delayoffset,
-            therunoptions["histlen"],
-            1,
-            self.outputname + namesuffix,
-            displaytitle="Histogram of delay offsets calculated from coefficient ratios",
-            dictvarname="delayoffsethist",
-            thedict=None,
-        )

rapidtide/calcandfitcorrpairs.py

@@ -1,262 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-#   Copyright 2016-2025 Blaise Frederick
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-#
-#
-import gc
-import logging
-import warnings
-
-import numpy as np
-from tqdm import tqdm
-
-import rapidtide.correlate as tide_corr
-import rapidtide.fit as tide_fit
-import rapidtide.multiproc as tide_multiproc
-
-warnings.simplefilter(action="ignore", category=FutureWarning)
-LGR = logging.getLogger("GENERAL")
-
-
-def _procOneVoxelCorrelation(
-    thedata,
-    index,
-    neighborindex,
-    Fs,
-    dofit=False,
-    lagmin=-12.5,
-    lagmax=12.5,
-    widthmax=100.0,
-    negsearch=15.0,
-    possearch=15.0,
-    padding=0,
-    debug=False,
-):
-    tc1 = thedata[index, :]
-    tc2 = thedata[neighborindex, :]
-    if np.any(tc1) != 0.0 and np.any(tc2) != 0.0:
-        thesimfunc = tide_corr.fastcorrelate(
-            tc1,
-            tc2,
-            zeropadding=padding,
-            usefft=True,
-            debug=debug,
-        )
-        similarityfunclen = len(thesimfunc)
-        similarityfuncorigin = similarityfunclen // 2 + 1
-
-        negpoints = int(negsearch * Fs)
-        pospoints = int(possearch * Fs)
-        trimsimfunc = thesimfunc[
-            similarityfuncorigin - negpoints : similarityfuncorigin + pospoints
-        ]
-        offset = 0.0
-        trimtimeaxis = (
-            (
-                np.arange(0.0, similarityfunclen) * (1.0 / Fs)
-                - ((similarityfunclen - 1) * (1.0 / Fs)) / 2.0
-            )
-            - offset
-        )[similarityfuncorigin - negpoints : similarityfuncorigin + pospoints]
-        if dofit:
-            (
-                maxindex,
-                maxtime,
-                maxcorr,
-                maxsigma,
-                maskval,
-                failreason,
-                peakstart,
-                peakend,
-            ) = tide_fit.simfuncpeakfit(
-                trimsimfunc,
-                trimtimeaxis,
-                useguess=False,
-                maxguess=0.0,
-                displayplots=False,
-                functype="correlation",
-                peakfittype="gauss",
-                searchfrac=0.5,
-                lagmod=1000.0,
-                enforcethresh=True,
-                allowhighfitamps=False,
-                lagmin=lagmin,
-                lagmax=lagmax,
-                absmaxsigma=1000.0,
-                absminsigma=0.25,
-                hardlimit=True,
-                bipolar=False,
-                lthreshval=0.0,
-                uthreshval=1.0,
-                zerooutbadfit=True,
-                debug=False,
-            )
-        else:
-            maxtime = trimtimeaxis[np.argmax(trimsimfunc)]
-            maxcorr = np.max(trimsimfunc)
-            maskval = 1
-            failreason = 0
-        if debug:
-            print(f"{maxtime=}")
-            print(f"{maxcorr=}")
-            print(f"{maskval=}")
-            print(f"{negsearch=}")
-            print(f"{possearch=}")
-            print(f"{Fs=}")
-            print(f"{len(trimtimeaxis)=}")
-            print(trimsimfunc, trimtimeaxis)
-        return index, neighborindex, maxcorr, maxtime, maskval, failreason
-    else:
-        return index, neighborindex, 0.0, 0.0, 0, 0
-
-
-def correlationpass(
-    fmridata,
-    referencetc,
-    theCorrelator,
-    fmri_x,
-    os_fmri_x,
-    lagmininpts,
-    lagmaxinpts,
-    corrout,
-    meanval,
-    nprocs=1,
-    alwaysmultiproc=False,
-    oversampfactor=1,
-    interptype="univariate",
-    showprogressbar=True,
-    chunksize=1000,
-    rt_floatset=np.float64,
-    rt_floattype="float64",
-):
-    """
-
-    Parameters
-    ----------
-    fmridata
-    referencetc - the reference regressor, already oversampled
-    theCorrelator
-    fmri_x
-    os_fmri_x
-    tr
-    lagmininpts
-    lagmaxinpts
-    corrout
-    meanval
-    nprocs
-    oversampfactor
-    interptype
-    showprogressbar
-    chunksize
-    rt_floatset
-    rt_floattype
-
-    Returns
-    -------
-
-    """
-    inputshape = np.shape(fmridata)
-    volumetotal = 0
-    thetc = np.zeros(np.shape(os_fmri_x), dtype=rt_floattype)
-    theglobalmaxlist = []
-    if nprocs > 1 or alwaysmultiproc:
-        # define the consumer function here so it inherits most of the arguments
-        def correlation_consumer(inQ, outQ):
-            while True:
-                try:
-                    # get a new message
-                    val = inQ.get()
-
-                    # this is the 'TERM' signal
-                    if val is None:
-                        break
-
-                    # process and send the data
-                    outQ.put(
-                        _procOneVoxelCorrelation(
-                            val,
-                            idx1,
-                            idx2,
-                            Fs,
-                            dofit=False,
-                            lagmin=-12.5,
-                            lagmax=12.5,
-                            widthmax=100.0,
-                            negsearch=15.0,
-                            possearch=15.0,
-                            padding=0,
-                            debug=False,
-                        )
-                    )
-
-                except Exception as e:
-                    print("error!", e)
-                    break
-
-        data_out = tide_multiproc.run_multiproc(
-            correlation_consumer,
-            inputshape,
-            None,
-            nprocs=nprocs,
-            showprogressbar=showprogressbar,
-            chunksize=chunksize,
-        )
-
-        # unpack the data
-        volumetotal = 0
-        for voxel in data_out:
-            maxcorr[voxel[0], voxel[1]] = voxel[2]
-            maxtime[voxel[0], voxel[1]] = voxel[3]
-            maskval[voxel[0], voxel[1]] = voxel[4]
-            failreason[voxel[0], voxel[1]] = voxel[5]
-            volumetotal += 1
-        del data_out
-    else:
-        for vox in tqdm(
-            range(0, inputshape[0]),
-            desc="Voxel",
-            disable=(not showprogressbar),
-        ):
-            (
-                dummy,
-                meanval[vox],
-                corrout[vox, :],
-                thecorrscale,
-                theglobalmax,
-            ) = _procOneVoxelCorrelation(
-                vox,
-                thetc,
-                theCorrelator,
-                fmri_x,
-                fmridata[vox, :],
-                os_fmri_x,
-                oversampfactor=oversampfactor,
-                interptype=interptype,
-                rt_floatset=rt_floatset,
-                rt_floattype=rt_floattype,
-            )
-            theglobalmaxlist.append(theglobalmax + 0)
-            volumetotal += 1
-    LGR.info(f"\nSimilarity function calculated on {volumetotal} voxels")
-
-    # garbage collect
-    uncollected = gc.collect()
-    if uncollected != 0:
-        LGR.info(f"garbage collected - unable to collect {uncollected} objects")
-    else:
-        LGR.info("garbage collected")
-
-    return volumetotal, theglobalmaxlist, thecorrscale

rapidtide/transformerdlfilter.py

@@ -1,126 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-#
-#   Copyright 2016-2025 Blaise Frederick
-#
-#   Licensed under the Apache License, Version 2.0 (the "License");
-#   you may not use this file except in compliance with the License.
-#   You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#   Unless required by applicable law or agreed to in writing, software
-#   distributed under the License is distributed on an "AS IS" BASIS,
-#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#   See the License for the specific language governing permissions and
-#   limitations under the License.
-#
-#
-"""This module contains all an alternate filter routine"""
-import tensorflow as tf
-from tensorflow.keras.layers import (
-    Dense,
-    Dropout,
-    Input,
-    LayerNormalization,
-    MultiHeadAttention,
-)
-from tensorflow.keras.models import Model
-
-
-# Positional Encoding to add temporal information to the sequence
-class PositionalEncoding(tf.keras.layers.Layer):
-    def __init__(self, sequence_len, d_model):
-        super(PositionalEncoding, self).__init__()
-        self.pos_encoding = self.positional_encoding(sequence_len, d_model)
-
-    def get_angles(self, pos, i, d_model):
-        angle_rates = 1 / tf.pow(10000, (2 * (i // 2)) / tf.cast(d_model, tf.float32))
-        return pos * angle_rates
-
-    def positional_encoding(self, sequence_len, d_model):
-        angle_rads = self.get_angles(
-            tf.range(sequence_len)[:, tf.newaxis], tf.range(d_model)[tf.newaxis, :], d_model
-        )
-
-        # Apply sin to even indices in the array; cos to odd indices
-        sines = tf.sin(angle_rads[:, 0::2])
-        cosines = tf.cos(angle_rads[:, 1::2])
-
-        pos_encoding = tf.concat([sines, cosines], axis=-1)
-        pos_encoding = pos_encoding[tf.newaxis, ...]
-        return tf.cast(pos_encoding, tf.float32)
-
-    def call(self, x):
-        return x + self.pos_encoding[:, : tf.shape(x)[1], :]
-
-
-# Transformer block implementation
-class TransformerBlock(tf.keras.layers.Layer):
-    def __init__(self, d_model, num_heads, ff_dim, rate=0.1):
-        super(TransformerBlock, self).__init__()
-        self.att = MultiHeadAttention(num_heads=num_heads, key_dim=d_model)
-        self.ffn = tf.keras.Sequential(
-            [
-                Dense(ff_dim, activation="relu"),  # Feed Forward Network
-                Dense(d_model),
-            ]
-        )
-        self.layernorm1 = LayerNormalization(epsilon=1e-6)
-        self.layernorm2 = LayerNormalization(epsilon=1e-6)
-        self.dropout1 = Dropout(rate)
-        self.dropout2 = Dropout(rate)
-
-    def call(self, x, training):
-        attn_output = self.att(x, x)  # Self-attention
-        attn_output = self.dropout1(attn_output, training=training)
-        out1 = self.layernorm1(x + attn_output)  # Add & Norm
-
-        ffn_output = self.ffn(out1)  # Feed forward
-        ffn_output = self.dropout2(ffn_output, training=training)
-        return self.layernorm2(out1 + ffn_output)  # Add & Norm
-
-
-# Building the Transformer-based Cardiac Waveform Filter model
-def build_transformer_model(
-    input_shape, d_model=128, num_heads=4, ff_dim=512, num_layers=3, dropout_rate=0.1
-):
-    inputs = Input(shape=input_shape)
-
-    # Positional Encoding
-    x = PositionalEncoding(input_shape[0], d_model)(inputs)
-
-    # Stack Transformer layers
-    for _ in range(num_layers):
-        x = TransformerBlock(d_model, num_heads, ff_dim, rate=dropout_rate)(x)
-
-    # Output layer for waveform filtering (regression to the original signal)
-    outputs = Dense(1, activation="linear")(x)
-
-    model = Model(inputs=inputs, outputs=outputs)
-    return model
-
-
-# Compile and train the model
-def compile_and_train_model(
-    model, train_data, train_labels, val_data, val_labels, epochs=50, batch_size=32
-):
-    model.compile(optimizer="adam", loss="mse", metrics=["mae"])
-    history = model.fit(
-        train_data,
-        train_labels,
-        validation_data=(val_data, val_labels),
-        epochs=epochs,
-        batch_size=batch_size,
-    )
-    return history
-
-
-# Example usage:
-# Assuming train_data and train_labels are the time-series data of cardiac signals
-input_shape = (1000, 1)  # For example, 1000 time points with 1 feature (cardiac waveform)
-transformer_model = build_transformer_model(input_shape)
-transformer_model.summary()
-
-# After this, you would use your train_data and val_data (cardiac waveforms) to train the model.
-# Example: compile_and_train_model(transformer_model, train_data, train_labels, val_data, val_labels)