antspymm 1.4.5__py3-none-any.whl → 1.4.8__py3-none-any.whl

antspymm/mm.py

@@ -3882,9 +3882,13 @@ def joint_dti_recon(
         print("recon after distortion correction", flush=True)
 
     if impute:
+        print("impute begin", flush=True)
         img_LRdwp=impute_dwi( img_LRdwp, verbose=True )
+        print("impute done", flush=True)
     elif censor:
+        print("censor begin", flush=True)
         img_LRdwp, reg_LR['bvals'], reg_LR['bvecs'] = censor_dwi( img_LRdwp, reg_LR['bvals'], reg_LR['bvecs'], verbose=True )
+        print("censor done", flush=True)
     if impute and img_RL is not None:
         img_RLdwp=impute_dwi( img_RLdwp, verbose=True )
     elif censor and img_RL is not None:
@@ -5355,6 +5359,7 @@ def PerAF( x, mask, globalmean=True ):
     return outimg
 
 
+
 def resting_state_fmri_networks( fmri, fmri_template, t1, t1segmentation,
     f=[0.03, 0.08],
     FD_threshold=5.0,
@@ -7281,8 +7286,8 @@ def mm(
                 img_RL=dw_image[1],
                 bval_RL=bvals[1],
                 bvec_RL=bvecs[1],
-                motion_correct='SyN', # set to False if using input from qsiprep
-                denoise=True,
+                motion_correct=dti_motion_correct, # set to False if using input from qsiprep
+                denoise=dti_denoise,
                 verbose = verbose)
         mydti = output_dict['DTI']
         # summarize dwi with T1 outputs
@@ -10601,9 +10606,9 @@ def censor_dwi( dwi, bval, bvec, threshold = 0.20, imputeb0=False, mask=None, ve
     list1 = segment_timeseries_by_meanvalue( dwi )['highermeans']
     if imputeb0:
         dwib = impute_timeseries( dwi, list1 ) # focus on the dwi - not the b0
-        looped, list2 = loop_timeseries_censoring( dwib, threshold, mask )
+        looped, list2 = loop_timeseries_censoring( dwib, threshold, mask, verbose=verbose)
     else:
-        looped, list2 = loop_timeseries_censoring( dwi, threshold, mask )
+        looped, list2 = loop_timeseries_censoring( dwi, threshold, mask, verbose=verbose )
     if verbose:
         print( list1 )
         print( list2 )
@@ -10626,18 +10631,21 @@ def flatten_time_series(time_series):
     n_volumes = time_series.shape[3]
     return time_series.reshape(-1, n_volumes).T
 
-def calculate_loop_scores(flattened_series, n_neighbors=20):
+def calculate_loop_scores_full(flattened_series, n_neighbors=20, verbose=True ):
     """
     Calculate Local Outlier Probabilities for each volume.
     
     :param flattened_series: A 2D numpy array from flatten_time_series.
     :param n_neighbors: Number of neighbors to use for calculating LOF scores.
+    :param verbose: boolean
     :return: An array of LoOP scores.
     """
     from PyNomaly import loop
     from sklearn.neighbors import NearestNeighbors
     from sklearn.preprocessing import StandardScaler
     # replace nans with zero
+    if verbose:
+        print("loop: nan_to_num")
     flattened_series=np.nan_to_num(flattened_series, nan=0)
     scaler = StandardScaler()
     scaler.fit(flattened_series)
@@ -10645,12 +10653,109 @@ def calculate_loop_scores(flattened_series, n_neighbors=20):
     data=np.nan_to_num(data, nan=0)
     if n_neighbors > int(flattened_series.shape[0]/2.0):
         n_neighbors = int(flattened_series.shape[0]/2.0)
+    if verbose:
+        print("loop: nearest neighbors init")
     neigh = NearestNeighbors(n_neighbors=n_neighbors, metric='minkowski')
+    if verbose:
+        print("loop: nearest neighbors fit")
     neigh.fit(data)
     d, idx = neigh.kneighbors(data, return_distance=True)
+    if verbose:
+        print("loop: probability")
     m = loop.LocalOutlierProbability(distance_matrix=d, neighbor_matrix=idx, n_neighbors=n_neighbors).fit()
     return m.local_outlier_probabilities[:]
 
+
+def calculate_loop_scores(flattened_series, n_neighbors=20, 
+                                           n_features_sample=10000, seed=42, verbose=True):
+    """
+    Approximate LoOP scores using a random subset of features to reduce memory usage.
+
+    Parameters:
+        flattened_series (np.ndarray): 2D array of shape (n_samples, n_features)
+        n_neighbors (int): Number of neighbors for LOF/LoOP computation
+        n_features_sample (int): Number of features to sample for approximation
+        seed (int): Random seed for reproducible feature sampling
+        verbose (bool): If True, print detailed progress and dimensions
+
+    Returns:
+        np.ndarray: 1D array of local outlier probabilities (length n_samples)
+    """
+    import numpy as np
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.neighbors import NearestNeighbors
+    from PyNomaly import loop
+
+    # -------------------------------
+    # Step 1: Input stats and cleanup
+    # -------------------------------
+    X = np.nan_to_num(flattened_series, nan=0).astype(np.float32)
+    n_samples, n_features = X.shape
+
+    if verbose:
+        print("\n[LoOP Approximation - Verbose Mode]")
+        print(f"- Original input shape: {X.shape} (samples x features)")
+        print(f"- Requested sampled features: {n_features_sample}")
+    
+    if n_features_sample > n_features:
+        n_features_sample = n_features
+        if verbose:
+            print(f"- Requested n_features_sample exceeds available features. Using all {n_features} features.")
+
+    # -------------------------------
+    # Step 2: Feature sampling
+    # -------------------------------
+    rng = np.random.default_rng(seed)
+    sampled_indices = rng.choice(n_features, n_features_sample, replace=False)
+    X_sampled = X[:, sampled_indices]
+
+    if verbose:
+        print(f"- Sampled feature shape: {X_sampled.shape} (samples x sampled_features)")
+        print(f"- Random seed for reproducibility: {seed}")
+
+    # -------------------------------
+    # Step 3: Standardization
+    # -------------------------------
+    scaler = StandardScaler(copy=False)
+    X_sampled = scaler.fit_transform(X_sampled)
+    X_sampled = np.nan_to_num(X_sampled, nan=0)
+
+    # -------------------------------
+    # Step 4: KNN setup for LoOP
+    # -------------------------------
+    if n_neighbors >= n_samples:
+        n_neighbors = max(1, n_samples // 2)
+        if verbose:
+            print(f"- Adjusted n_neighbors to {n_neighbors} (was too large for available samples).")
+
+    if verbose:
+        print(f"- Performing KNN using Minkowski distance (default p=2, Euclidean)")
+        print(f"- Each point will use its {n_neighbors} nearest neighbors for local density estimation")
+
+    neigh = NearestNeighbors(n_neighbors=n_neighbors)
+    neigh.fit(X_sampled)
+    dists, indices = neigh.kneighbors(X_sampled, return_distance=True)
+
+    # -------------------------------
+    # Step 5: LoOP probability calculation
+    # -------------------------------
+    if verbose:
+        print(f"- Distance matrix shape: {dists.shape} (samples x n_neighbors)")
+        print(f"- Neighbor index matrix shape: {indices.shape}")
+        print("- Estimating Local Outlier Probabilities (LoOP)...")
+
+    model = loop.LocalOutlierProbability(
+        distance_matrix=dists,
+        neighbor_matrix=indices,
+        n_neighbors=n_neighbors
+    ).fit()
+
+    if verbose:
+        print("- LoOP scoring complete.\n")
+
+    return model.local_outlier_probabilities[:]
+
+
 def score_fmri_censoring(cbfts, csf_seg, gm_seg, wm_seg ):
     """
     Process CBF time series to remove high-leverage points.
@@ -10718,7 +10823,7 @@ def score_fmri_censoring(cbfts, csf_seg, gm_seg, wm_seg ):
     cbfts_recon_ants = ants.copy_image_info(cbfts, cbfts_recon_ants)
     return cbfts_recon_ants, indx
 
-def loop_timeseries_censoring(x, threshold=0.5, mask=None, verbose=False):
+def loop_timeseries_censoring(x, threshold=0.5, mask=None, n_features_sample=10000, verbose=True):
     """
     Censor high leverage volumes from a time series using Local Outlier Probabilities (LoOP).
 
@@ -10726,6 +10831,7 @@ def loop_timeseries_censoring(x, threshold=0.5, mask=None, verbose=False):
     x (ANTsImage): A 4D time series image.
     threshold (float): Threshold for determining high leverage volumes based on LoOP scores.
     mask (antsImage): restricts to a ROI
+    n_features_sample (int): feature sample size default 5000
     verbose (bool)
 
     Returns:
@@ -10739,10 +10845,12 @@ def loop_timeseries_censoring(x, threshold=0.5, mask=None, verbose=False):
         flattened_series = flatten_time_series(x.numpy())
     else:
         flattened_series = ants.timeseries_to_matrix( x, mask )
-    loop_scores = calculate_loop_scores(flattened_series)
+    if verbose:
+        print("loop_timeseries_censoring: flattened")
+    loop_scores = calculate_loop_scores(flattened_series, n_features_sample=n_features_sample, verbose=verbose )
     high_leverage_volumes = np.where(loop_scores > threshold)[0]
     if verbose:
-        print("LOOP High Leverage Volumes:", high_leverage_volumes)
+        print("loop_timeseries_censoring: High Leverage Volumes:", high_leverage_volumes)
     new_asl = remove_volumes_from_timeseries(x, high_leverage_volumes)
     return new_asl, high_leverage_volumes
 

{antspymm-1.4.5.dist-info → antspymm-1.4.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: antspymm
-Version: 1.4.5
+Version: 1.4.8
 Summary: multi-channel/time-series medical image processing with antspyx
 Author-email: "Avants, Gosselin, Tustison, Reardon" <stnava@gmail.com>
 License: Apache 2.0
@@ -19,9 +19,12 @@ Requires-Dist: nibabel
 Requires-Dist: scipy
 Requires-Dist: siq
 Requires-Dist: scikit-learn
+Dynamic: license-file
 
 # ANTsPyMM
 
+[![DOI](https://zenodo.org/badge/423404500.svg)](https://doi.org/10.5281/zenodo.15131653)
+
 [![CircleCI](https://dl.circleci.com/status-badge/img/gh/ANTsX/ANTsPyMM/tree/main.svg?style=svg)](https://dl.circleci.com/status-badge/redirect/gh/ANTsX/ANTsPyMM/tree/main)
 
 ![mapping](https://i.imgur.com/qKqYjU9.jpeg)

antspymm-1.4.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+antspymm/__init__.py,sha256=ZdNJyHwS6rzq59v0OK3tE3qSTD0za2iULzSLGkM_0uc,4527
+antspymm/mm.py,sha256=tJXaT-81XEjNjCOhmGKCjSRB7HEM2z_mlAWxKwJlc3M,517529
+antspymm-1.4.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+antspymm-1.4.8.dist-info/METADATA,sha256=ETYrQeMwhaF6LkNzhXZrN2htysVl3rvUmUX2yJymHsw,25781
+antspymm-1.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+antspymm-1.4.8.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
+antspymm-1.4.8.dist-info/RECORD,,

{antspymm-1.4.5.dist-info → antspymm-1.4.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.7.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

antspymm-1.4.5.dist-info/RECORD

@@ -1,7 +0,0 @@
-antspymm/__init__.py,sha256=ZdNJyHwS6rzq59v0OK3tE3qSTD0za2iULzSLGkM_0uc,4527
-antspymm/mm.py,sha256=CKNLB3F00E5BOvNHTLoHXGN7l3fXzr9Tt3Oc-BiSvfM,513311
-antspymm-1.4.5.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-antspymm-1.4.5.dist-info/METADATA,sha256=68JOQDfbTRq3y5NrC3R_BsELpzGbupAYA55L72wektY,25668
-antspymm-1.4.5.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
-antspymm-1.4.5.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
-antspymm-1.4.5.dist-info/RECORD,,