pyAFQ 3.0__tar.gz → 3.2__tar.gz

{pyafq-3.0 → pyafq-3.2}/AFQ/_fixes.py

@@ -223,7 +223,7 @@ def tensor_odf(evals, evecs, sphere, num_batches=100):
 
 
 def gaussian_weights(
-    bundle, assignment_idxs=None, n_points=100, return_mahalnobis=False, stat=np.mean
+    bundle, assignment_idxs=None, n_points=100, return_mahalanobis=False, stat=np.mean
 ):
     """
     Calculate weights for each streamline/node in a bundle, based on a
@@ -270,7 +270,7 @@ def gaussian_weights(
 
     n_sls, n_nodes, _ = sls.shape
 
-    if n_sls < 15:  # Cov^-1 unstable under this amount
+    def _weighting_failed():
         weights = np.ones((n_sls, n_nodes))
         logger.warning(
             (
@@ -278,46 +278,72 @@ def gaussian_weights(
                 "weighting everything evenly"
             )
         )
-        if return_mahalnobis:
+        if return_mahalanobis:
             return np.full((n_sls, n_nodes), np.nan)
         else:
             return weights / np.sum(weights, 0)
+
+    if n_sls < 15:  # Cov^-1 unstable under this amount
+        return _weighting_failed()
     else:
         weights = np.zeros((n_sls, n_nodes))
 
     if assignment_idxs is None:
-        working_groups = np.tile(np.arange(n_nodes), (n_sls, 1))
+        mu = stat(sls, axis=0)
+        diff = sls - mu
+
+        cov = np.einsum("snj,snk->njk", diff, diff) / n_sls
+        cov = 0.5 * (cov + cov.transpose(0, 2, 1))
+
+        eigvals, eigvecs = np.linalg.eigh(cov)
+        eigvals = np.clip(eigvals, 0, None)
+
+        max_ev = eigvals.max(axis=1, keepdims=True)
+        tol = np.finfo(eigvals.dtype).eps * np.maximum(max_ev, 1e-6) * cov.shape[-1]
+        inv_eigvals = np.where(
+            eigvals > tol, 1.0 / np.where(eigvals > tol, eigvals, 1.0), 0.0
+        )
+
+        inv_cov = np.einsum("nij,nj,nkj->nik", eigvecs, inv_eigvals, eigvecs)
+
+        m = np.einsum("snj,njk,snk->sn", diff, inv_cov, diff)
+        np.clip(m, 0, None, out=m)
+        weights = np.sqrt(m)
+
+        degenerate = max_ev.ravel() <= 0
+        if np.any(degenerate):
+            return _weighting_failed()
     else:
         working_groups = np.asarray(assignment_idxs)
 
-    flat_coords = sls.reshape(-1, 3)
-    flat_groups = working_groups.reshape(-1)
-    unique_ids = np.unique(flat_groups)
+        flat_coords = sls.reshape(-1, 3)
+        flat_groups = working_groups.reshape(-1)
+        unique_ids = np.unique(flat_groups)
 
-    for gid in unique_ids:
-        mask = flat_groups == gid
-        group_data = flat_coords[mask]
+        for gid in unique_ids:
+            mask = flat_groups == gid
+            group_data = flat_coords[mask]
 
-        if len(group_data) < 15:
-            continue
+            if len(group_data) < 15:
+                continue
 
-        mu = stat(group_data, axis=0)
-        diff = group_data - mu
+            mu = stat(group_data, axis=0)
+            diff = group_data - mu
 
-        cov = np.cov(group_data.T, ddof=0)
+            cov = np.cov(group_data.T, ddof=0)
 
-        # Ensure positive semi-definite
-        if np.any(np.linalg.eigvals(cov) < 0):
-            eigenvalues, eigenvectors = np.linalg.eigh((cov + cov.T) / 2)
-            eigenvalues[eigenvalues < 0] = 0
-            cov = eigenvectors @ np.diag(eigenvalues) @ eigenvectors.T
+            # Ensure positive semi-definite
+            if np.any(np.linalg.eigvals(cov) < 0):
+                eigenvalues, eigenvectors = np.linalg.eigh((cov + cov.T) / 2)
+                eigenvalues[eigenvalues < 0] = 0
+                cov = eigenvectors @ np.diag(eigenvalues) @ eigenvectors.T
 
-        if np.any(cov > 0):
-            weights.ravel()[mask] = np.sqrt(
-                np.einsum("ij,jk,ik->i", diff, pinvh(cov), diff)
-            )
+            if np.any(cov > 0):
+                weights.ravel()[mask] = np.sqrt(
+                    np.einsum("ij,jk,ik->i", diff, pinvh(cov), diff)
+                )
 
-    if return_mahalnobis:
+    if return_mahalanobis:
         return weights
 
     with np.errstate(divide="ignore"):
@@ -325,7 +351,14 @@ def gaussian_weights(
     w_inv[np.isinf(w_inv)] = 0
 
     denom = np.sum(w_inv, axis=0)
-    return np.divide(w_inv, denom, out=np.zeros_like(w_inv), where=denom != 0)
+    w = np.divide(w_inv, denom, out=np.zeros_like(w_inv), where=denom != 0)
+    col_sums = w.sum(axis=0)
+    if np.max(np.abs(col_sums - 1)) > 1e-3:
+        return _weighting_failed()
+    else:
+        final_sums = w.sum(axis=0, keepdims=True)
+        np.divide(w, final_sums, out=w, where=final_sums != 0)
+        return w
 
 
 def make_gif(show_m, out_path, n_frames=36, az_ang=-10, duration=150):

{pyafq-3.0 → pyafq-3.2}/AFQ/api/bundle_dict.py

@@ -300,6 +300,7 @@ def default_bd():
                     templates["SLF_roi1_L"],
                     templates["IFO_roi1_L"],
                     templates["pARC_xroi1_L"],
+                    templates["TPSPL_roi1_L"],
                 ],
                 "space": "template",
                 "start": templates["pARC_L_start"],
@@ -316,6 +317,7 @@ def default_bd():
                     templates["SLF_roi1_R"],
                     templates["IFO_roi1_R"],
                     templates["pARC_xroi1_R"],
+                    templates["TPSPL_roi1_R"],
                 ],
                 "space": "template",
                 "start": templates["pARC_R_start"],
@@ -325,6 +327,44 @@ def default_bd():
                 "length": {"min_len": 30},
                 "primary_axis": "I/S",
             },
+            "Left Temporo-parietal": {
+                "cross_midline": False,
+                "include": [
+                    templates["SLFt_roi2_L"],
+                    templates["TPSPL_roi1_L"],
+                ],
+                "exclude": [
+                    templates["SLF_roi1_L"],
+                    templates["IFO_roi1_L"],
+                    templates["pARC_xroi1_L"],
+                ],
+                "space": "template",
+                "start": templates["pARC_L_start"],
+                "end": templates["pARC_L_end"],
+                "Left Arcuate": {"overlap": 20},
+                "Left Optic Radiation": {"core": "Right"},
+                "length": {"min_len": 30},
+                "primary_axis": "I/S",
+            },
+            "Right Temporo-parietal": {
+                "cross_midline": False,
+                "include": [
+                    templates["SLFt_roi2_R"],
+                    templates["TPSPL_roi1_R"],
+                ],
+                "exclude": [
+                    templates["SLF_roi1_R"],
+                    templates["IFO_roi1_R"],
+                    templates["pARC_xroi1_R"],
+                ],
+                "space": "template",
+                "start": templates["pARC_R_start"],
+                "end": templates["pARC_R_end"],
+                "Right Arcuate": {"overlap": 20},
+                "Right Optic Radiation": {"core": "Left"},
+                "length": {"min_len": 30},
+                "primary_axis": "I/S",
+            },
             "Left Vertical Occipital": {
                 "cross_midline": False,
                 "space": "template",

{pyafq-3.0 → pyafq-3.2}/AFQ/data/fetch.py

@@ -783,6 +783,8 @@ template_fnames = [
     "VOF_xroi1_R.nii.gz",
     "VOF_xroi2_L.nii.gz",
     "VOF_xroi2_R.nii.gz",
+    "TPSPL_roi1_L.nii.gz",
+    "TPSPL_roi1_R.nii.gz",
 ]
 
 
@@ -903,6 +905,8 @@ template_remote_fnames = [
     "62582596",
     "62582599",
     "62582602",
+    "64928463",
+    "64928466",
 ]
 
 
@@ -1024,6 +1028,8 @@ template_md5_hashes = [
     "0cda34ce714759bad909fcf9051f3d64",
     "6b65a5e178853e993f52b438ffb0f6c6",
     "e36f5adf08eb3efd5849397f0f8ef6a4",
+    "4418a1277ff768a5752368edda2bbcac",
+    "44db3c4b841bca2e8b56ef4f650fa3d5",
 ]
 
 fetch_templates = _make_reusable_fetcher(

{pyafq-3.0 → pyafq-3.2}/AFQ/models/dki.py

@@ -11,14 +11,6 @@ import AFQ.utils.models as ut
 __all__ = ["fit_dki", "predict"]
 
 
-def _fit(gtab, data, mask=None, return_S0_hat=False):
-    dkimodel = dki.DiffusionKurtosisModel(gtab, return_S0_hat=return_S0_hat)
-    return dkimodel.fit(
-        data,
-        mask=mask,
-    )
-
-
 def fit_dki(
     data_files,
     bval_files,

{pyafq-3.0 → pyafq-3.2}/AFQ/models/msmt.py

@@ -28,12 +28,6 @@ def _fit(self, data, mask=None):
     for i in range(A.shape[0]):
         A[i] /= np.linalg.norm(A[i])
 
-    A_outer = np.empty((n, n, m), dtype=np.float64)
-    for k in range(m):
-        for i in range(n):
-            for j in range(n):
-                A_outer[i, j, k] = A[k, i] * A[k, j]
-
     Q = R.T @ R
 
     A = csr_matrix(A)

{pyafq-3.0 → pyafq-3.2}/AFQ/recognition/cleaning.py

@@ -105,7 +105,7 @@ def clean_by_orientation_mahalanobis(
         m_dist = gaussian_weights(
             fgarray_dists,
             assignment_idxs=assignment_idxs,
-            return_mahalnobis=True,
+            return_mahalanobis=True,
             n_points=None,
             stat=np.mean,
         )
@@ -253,7 +253,7 @@ def clean_bundle(
     while rounds_elapsed < clean_rounds:
         # This calculates the Mahalanobis for each streamline/node:
         m_dist = gaussian_weights(
-            fgarray, return_mahalnobis=True, n_points=None, stat=stat
+            fgarray, return_mahalanobis=True, n_points=None, stat=stat
         )
         logger.debug(f"Shape of fgarray: {np.asarray(fgarray).shape}")
         logger.debug(f"Shape of m_dist: {m_dist.shape}")

{pyafq-3.0 → pyafq-3.2}/AFQ/recognition/clustering.py

@@ -19,13 +19,13 @@ import AFQ.recognition.utils as abu
 import AFQ.utils.streamlines as aus
 
 
-@njit(parallel=True)
+@njit(parallel=True, fastmath=True, cache=True)
 def _compute_mean_euclidean_matrix(group_n, group_m):
     len_n = group_n.shape[0]
     len_m = group_m.shape[0]
     num_points = group_n.shape[1]
 
-    dist_matrix = np.empty((len_n, len_m), dtype=np.float64)
+    dist_matrix = np.empty((len_n, len_m), dtype=np.float32)
 
     for i in prange(len_n):
         for j in range(len_m):
@@ -144,7 +144,13 @@ def spectral_atlas_label(
 
 
 def subcluster_by_atlas(
-    sub_trk, mapping, dwi_ref, cluster_indices, atlas_data=None, n_points=20
+    sub_trk,
+    mapping,
+    dwi_ref,
+    cluster_indices,
+    atlas_data=None,
+    n_points=20,
+    batch_size=int(5e4),
 ):
     """
     Use an existing atlas to label a new set of streamlines, and return the
@@ -165,6 +171,8 @@ def subcluster_by_atlas(
         See `afd.read_org800_templates` as a reference.
     n_points : int, optional
         Number of points to resample streamlines to for labeling. Default is 20.
+    batch_size : int, optional
+        Number of streamlines to process in a batch. Default is 50,000.
     """
 
     if atlas_data is None:
@@ -177,13 +185,33 @@ def subcluster_by_atlas(
     atlas_fgarray = np.array(abu.resample_tg(moved_atlas_sft.streamlines, n_points))
 
     sub_trk.to_rasmm()
-    sub_fgarray = np.array(abu.resample_tg(sub_trk.streamlines, n_points))
-
-    cluster_idxs, _ = spectral_atlas_label(
-        sub_fgarray,
-        atlas_fgarray,
-        atlas_data=atlas_data,
-        cluster_indices=cluster_indices,
-    )
-
-    return cluster_idxs
+    n_sub = len(sub_trk.streamlines)
+
+    if n_sub <= batch_size:
+        sub_fgarray = np.asarray(
+            abu.resample_tg(sub_trk.streamlines, n_points), dtype=np.float32
+        )
+        cluster_idxs, _ = spectral_atlas_label(
+            sub_fgarray,
+            atlas_fgarray,
+            atlas_data=atlas_data,
+            cluster_indices=cluster_indices,
+        )
+        return cluster_idxs
+
+    all_idxs = np.empty(n_sub, dtype=np.int64)
+    for start in range(0, n_sub, batch_size):
+        end = min(start + batch_size, n_sub)
+        batch_sls = sub_trk.streamlines[start:end]
+        batch_fgarray = np.asarray(
+            abu.resample_tg(batch_sls, n_points), dtype=np.float32
+        )
+        batch_idxs, _ = spectral_atlas_label(
+            batch_fgarray,
+            atlas_fgarray,
+            atlas_data=atlas_data,
+            cluster_indices=cluster_indices,
+        )
+        all_idxs[start:end] = batch_idxs
+
+    return all_idxs