Add files using upload-large-folder tool

MindEyeV2/antspy/ants/core/__init__.py

@@ -0,0 +1,42 @@
+from .ants_image_io import (image_header_info,
+                            image_clone,
+                            image_read,
+                            dicom_read,
+                            image_write,
+                            make_image,
+                            from_numpy,
+                            from_numpy_like,
+                            new_image_like)
+from .ants_image import (ANTsImage,
+                         copy_image_info,
+                         set_origin,
+                         get_origin,
+                         set_direction,
+                         get_direction,
+                         set_spacing,
+                         get_spacing,
+                         is_image,
+                         from_pointer)
+from .ants_metric_io import (new_ants_metric,
+                             create_ants_metric,
+                             supported_metrics)
+from .ants_transform_io import (create_ants_transform,
+                                new_ants_transform,
+                                read_transform,
+                                write_transform,
+                                transform_from_displacement_field,
+                                transform_to_displacement_field,
+                                fsl2antstransform)
+from .ants_transform import (ANTsTransform,
+                             set_ants_transform_parameters,
+                             get_ants_transform_parameters,
+                             get_ants_transform_fixed_parameters,
+                             set_ants_transform_fixed_parameters,
+                             apply_ants_transform,
+                             apply_ants_transform_to_point,
+                             apply_ants_transform_to_vector,
+                             apply_ants_transform_to_image,
+                             invert_ants_transform,
+                             compose_ants_transforms,
+                             transform_index_to_physical_point,
+                             transform_physical_point_to_index)

MindEyeV2/antspy/ants/core/ants_image_io.py

@@ -0,0 +1,529 @@
+"""
+Image IO
+"""
+
+__all__ = [
+    "image_header_info",
+    "image_clone",
+    "image_read",
+    "dicom_read",
+    "image_write",
+    "make_image",
+    "from_numpy",
+    "from_numpy_like",
+    "new_image_like"
+]
+
+import os
+import json
+import numpy as np
+import warnings
+
+import ants
+from ants.internal import get_lib_fn, short_ptype, infer_dtype
+from ants.decorators import image_method
+
+_supported_pclasses = {"scalar", "vector", "rgb", "rgba","symmetric_second_rank_tensor"}
+_supported_ptypes = {"unsigned char", "unsigned int", "float", "double"}
+_supported_ntypes = {"uint8", "uint32", "float32", "float64"}
+_unsupported_ptypes = {"char", "unsigned short", "short", "int"}
+_unsupported_ptype_map = {
+    "char": "float",
+    "unsigned short": "unsigned int",
+    "short": "float",
+    "int": "float",
+}
+_image_type_map = {"scalar": "", "vector": "V", "rgb": "RGB", "rgba": "RGBA", "symmetric_second_rank_tensor": "SSRT" }
+_ptype_type_map = {
+    "unsigned char": "UC",
+    "unsigned int": "UI",
+    "float": "F",
+    "double": "D",
+}
+
+_ntype_type_map = {"uint8": "UC", "uint32": "UI", "float32": "F", "float64": "D"}
+_npy_to_itk_map = {
+    "uint8": "unsigned char",
+    "uint32": "unsigned int",
+    "float32": "float",
+    "float64": "double",
+}
+
+_image_read_dict = {}
+for itype in {"scalar", "vector", "rgb", "rgba", "symmetric_second_rank_tensor"}:
+    _image_read_dict[itype] = {}
+    for p in _supported_ptypes:
+        _image_read_dict[itype][p] = {}
+        for d in {2, 3, 4}:
+            ita = _image_type_map[itype]
+            pa = _ptype_type_map[p]
+            _image_read_dict[itype][p][d] = "imageRead%s%s%i" % (ita, pa, d)
+
+def from_numpy(
+    data, origin=None, spacing=None, direction=None, has_components=False, is_rgb=False
+):
+    """
+    Create an ANTsImage object from a numpy array
+
+    ANTsR function: `as.antsImage`
+
+    Arguments
+    ---------
+    data : ndarray
+        image data array
+
+    origin : tuple/list
+        image origin
+
+    spacing : tuple/list
+        image spacing
+
+    direction : list/ndarray
+        image direction
+
+    has_components : boolean
+        whether the image has components
+
+    Returns
+    -------
+    ANTsImage
+        image with given data and any given information
+    """
+
+    # this is historic but should be removed once tests can pass without it
+    if data.dtype.name == 'float64':
+        data = data.astype('float32')
+
+    # if dtype is not supported, cast to best available
+    best_dtype = infer_dtype(data.dtype)
+    if best_dtype != data.dtype:
+        data = data.astype(best_dtype)
+
+    img = _from_numpy(data.T.copy(), origin, spacing, direction, has_components, is_rgb)
+    return img
+
+
+def _from_numpy(
+    data, origin=None, spacing=None, direction=None, has_components=False, is_rgb=False
+):
+    """
+    Internal function for creating an ANTsImage
+    """
+    if is_rgb:
+        has_components = True
+    ndim = data.ndim
+    if has_components:
+        ndim -= 1
+    dtype = data.dtype.name
+    ptype = _npy_to_itk_map[dtype]
+
+    data = np.array(data)
+
+    if origin is None:
+        origin = tuple([0.0] * ndim)
+    if spacing is None:
+        spacing = tuple([1.0] * ndim)
+    if direction is None:
+        direction = np.eye(ndim)
+
+    libfn = get_lib_fn("fromNumpy%s%i" % (_ntype_type_map[dtype], ndim))
+
+    if not has_components:
+        itk_image = libfn(data, data.shape[::-1])
+        ants_image = ants.from_pointer(itk_image)
+        ants_image.set_origin(origin)
+        ants_image.set_spacing(spacing)
+        ants_image.set_direction(direction)
+        ants_image._ndarr = data
+    else:
+        arrays = [data[i, ...].copy() for i in range(data.shape[0])]
+        data_shape = arrays[0].shape
+        ants_images = []
+        for i in range(len(arrays)):
+            tmp_ptr = libfn(arrays[i], data_shape[::-1])
+            tmp_img = ants.from_pointer(tmp_ptr)
+            tmp_img.set_origin(origin)
+            tmp_img.set_spacing(spacing)
+            tmp_img.set_direction(direction)
+            tmp_img._ndarr = arrays[i]
+            ants_images.append(tmp_img)
+        ants_image = ants.merge_channels(ants_images)
+        if is_rgb:
+            ants_image = ants_image.vector_to_rgb()
+    return ants_image
+
+
+def make_image(
+    imagesize,
+    voxval=0,
+    spacing=None,
+    origin=None,
+    direction=None,
+    has_components=False,
+    pixeltype="float",
+):
+    """
+    Make an image with given size and voxel value or given a mask and vector
+
+    ANTsR function: `makeImage`
+
+    Arguments
+    ---------
+    shape : tuple/ANTsImage
+        input image size or mask
+
+    voxval : scalar
+        input image value or vector, size of mask
+
+    spacing : tuple/list
+        image spatial resolution
+
+    origin  : tuple/list
+        image spatial origin
+
+    direction : list/ndarray
+        direction matrix to convert from index to physical space
+
+    components : boolean
+        whether there are components per pixel or not
+
+    pixeltype : float
+        data type of image values
+
+    Returns
+    -------
+    ANTsImage
+    """
+    if ants.is_image(imagesize):
+        img = imagesize.clone()
+        sel = imagesize > 0
+        if voxval.ndim > 1:
+            voxval = voxval.flatten()
+        if (len(voxval) == int((sel > 0).sum())) or (len(voxval) == 0):
+            img[sel] = voxval
+        else:
+            raise ValueError(
+                "Num given voxels %i not same as num positive values %i in `imagesize`"
+                % (len(voxval), int((sel > 0).sum()))
+            )
+        return img
+    else:
+        if isinstance(voxval, (tuple, list, np.ndarray)):
+            array = np.asarray(voxval).astype("float32").reshape(imagesize)
+        else:
+            array = np.full(imagesize, voxval, dtype="float32")
+        image = from_numpy(
+            array,
+            origin=origin,
+            spacing=spacing,
+            direction=direction,
+            has_components=has_components,
+        )
+        return image.clone(pixeltype)
+
+
+def image_header_info(filename):
+    """
+    Read file info from image header
+
+    ANTsR function: `antsImageHeaderInfo`
+
+    Arguments
+    ---------
+    filename : string
+        name of image file from which info will be read
+
+    Returns
+    -------
+    dict
+    """
+    if not os.path.exists(filename):
+        raise Exception("filename does not exist")
+
+    libfn = get_lib_fn("antsImageHeaderInfo")
+    retval = libfn(filename)
+    retval["dimensions"] = tuple(retval["dimensions"])
+    retval["origin"] = tuple([round(o, 4) for o in retval["origin"]])
+    retval["spacing"] = tuple([round(s, 4) for s in retval["spacing"]])
+    retval["direction"] = np.round(retval["direction"], 4)
+    return retval
+
+def image_clone(image, pixeltype=None):
+    """
+    Clone an ANTsImage
+
+    ANTsR function: `antsImageClone`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to clone
+
+    dtype : string (optional)
+        new datatype for image
+
+    Returns
+    -------
+    ANTsImage
+    """
+    return image.clone(pixeltype)
+
+
+def image_read(filename, dimension=None, pixeltype="float", reorient=False):
+    """
+    Read an ANTsImage from file
+
+    ANTsR function: `antsImageRead`
+
+    Arguments
+    ---------
+    filename : string
+        Name of the file to read the image from.
+
+    dimension : int
+        Number of dimensions of the image read. This need not be the same as
+        the dimensions of the image in the file. Allowed values: 2, 3, 4.
+        If not provided, the dimension is obtained from the image file
+
+    pixeltype : string
+        C++ datatype to be used to represent the pixels read. This datatype
+        need not be the same as the datatype used in the file.
+        Options: unsigned char, unsigned int, float, double
+
+    reorient : boolean | string
+        if True, the image will be reoriented to RPI if it is 3D
+        if False, nothing will happen
+        if string, this should be the 3-letter orientation to which the
+            input image will reoriented if 3D.
+        if the image is 2D, this argument is ignored
+
+    Returns
+    -------
+    ANTsImage
+    """
+    if filename.endswith(".npy"):
+        filename = os.path.expanduser(filename)
+        img_array = np.load(filename)
+        if os.path.exists(filename.replace(".npy", ".json")):
+            with open(filename.replace(".npy", ".json")) as json_data:
+                img_header = json.load(json_data)
+            ants_image = from_numpy(
+                img_array,
+                origin=img_header.get("origin", None),
+                spacing=img_header.get("spacing", None),
+                direction=np.asarray(img_header.get("direction", None)),
+                has_components=img_header.get("components", 1) > 1,
+            )
+        else:
+            img_header = {}
+            ants_image = from_numpy(img_array)
+
+    else:
+        filename = os.path.expanduser(filename)
+        if not os.path.exists(filename):
+            raise ValueError("File %s does not exist!" % filename)
+
+        hinfo = image_header_info(filename)
+        ptype = hinfo["pixeltype"]
+        pclass = hinfo["pixelclass"]
+        ndim = hinfo["nDimensions"]
+        ncomp = hinfo["nComponents"]
+        is_rgb = False
+        if pclass == "rgb":
+            pclass = "vector"
+        if pclass == "rgba":
+            pclass = "vector"
+        if pclass == "symmetric_second_rank_tensor":
+            pclass = "vector"
+#        is_rgb = True if pclass == "rgb" else False
+        if dimension is not None:
+            ndim = dimension
+
+        # error handling on pixelclass
+        if pclass not in _supported_pclasses:
+            raise ValueError("Pixel class %s not supported!" % pclass)
+
+        # error handling on pixeltype
+        if ptype in _unsupported_ptypes:
+            ptype = _unsupported_ptype_map.get(ptype, "unsupported")
+            if ptype == "unsupported":
+                raise ValueError("Pixeltype %s not supported" % ptype)
+
+        # error handling on dimension
+        if (ndim < 2) or (ndim > 4):
+            raise ValueError("Found %i-dimensional image - not supported!" % ndim)
+
+        libfn = get_lib_fn(_image_read_dict[pclass][ptype][ndim])
+        itk_pointer = libfn(filename)
+
+        ants_image = ants.from_pointer(itk_pointer)
+
+        if pixeltype is not None:
+            ants_image = ants_image.clone(pixeltype)
+
+    if (reorient != False) and (ants_image.dimension == 3):
+        if reorient == True:
+            ants_image = ants_image.reorient_image2("RPI")
+        elif isinstance(reorient, str):
+            ants_image = ants_image.reorient_image2(reorient)
+
+    return ants_image
+
+
+def dicom_read(directory, pixeltype="float"):
+    """
+    Read a set of dicom files in a directory into a single ANTsImage.
+    The origin of the resulting 3D image will be the origin of the
+    first dicom image read.
+
+    Arguments
+    ---------
+    directory : string
+        folder in which all the dicom images exist
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.dicom_read('~/desktop/dicom-subject/')
+    """
+    slices = []
+    imgidx = 0
+    for imgpath in os.listdir(directory):
+        if imgpath.endswith(".dcm"):
+            if imgidx == 0:
+                tmp = image_read(
+                    os.path.join(directory, imgpath), dimension=3, pixeltype=pixeltype
+                )
+                origin = tmp.origin
+                spacing = tmp.spacing
+                direction = tmp.direction
+                tmp = tmp.numpy()[:, :, 0]
+            else:
+                tmp = image_read(
+                    os.path.join(directory, imgpath), dimension=2, pixeltype=pixeltype
+                ).numpy()
+
+            slices.append(tmp)
+            imgidx += 1
+
+    slices = np.stack(slices, axis=-1)
+    return from_numpy(slices, origin=origin, spacing=spacing, direction=direction)
+
+@image_method
+def image_write(image, filename, ri=False):
+    """
+    Write an ANTsImage to file
+
+    ANTsR function: `antsImageWrite`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to save to file
+
+    filename : string
+        name of file to which image will be saved
+
+    ri : boolean
+        if True, return image. This allows for using this function in a pipeline:
+            >>> img2 = img.smooth_image(2.).image_write(file1, ri=True).threshold_image(0,20).image_write(file2, ri=True)
+        if False, do not return image
+    """
+    if filename.endswith(".npy"):
+        img_array = image.numpy()
+        img_header = {
+            "origin": image.origin,
+            "spacing": image.spacing,
+            "direction": image.direction.tolist(),
+            "components": image.components,
+        }
+
+        np.save(filename, img_array)
+        with open(filename.replace(".npy", ".json"), "w") as outfile:
+            json.dump(img_header, outfile)
+    else:
+        image.to_file(filename)
+
+    if ri:
+        return image
+
+@image_method
+def clone(image, pixeltype=None):
+    """
+    Create a copy of the given ANTsImage with the same data and info, possibly with
+    a different data type for the image data. Only supports casting to
+    uint8 (unsigned char), uint32 (unsigned int), float32 (float), and float64 (double)
+
+    Arguments
+    ---------
+    dtype: string (optional)
+        if None, the dtype will be the same as the cloned ANTsImage. Otherwise,
+        the data will be cast to this type. This can be a numpy type or an ITK
+        type.
+        Options:
+            'unsigned char' or 'uint8',
+            'unsigned int' or 'uint32',
+            'float' or 'float32',
+            'double' or 'float64'
+
+    Returns
+    -------
+    ANTsImage
+    """
+    if pixeltype is None:
+        pixeltype = image.pixeltype
+
+    if pixeltype not in _supported_ptypes:
+        raise ValueError('Pixeltype %s not supported. Supported types are %s' % (pixeltype, _supported_ptypes))
+
+    if image.has_components and (not image.is_rgb):
+        comp_imgs = ants.split_channels(image)
+        comp_imgs_cloned = [comp_img.clone(pixeltype) for comp_img in comp_imgs]
+        return ants.merge_channels(comp_imgs_cloned, channels_first=image.channels_first)
+    else:
+        p1_short = short_ptype(image.pixeltype)
+        p2_short = short_ptype(pixeltype)
+        ndim = image.dimension
+        fn_suffix = '%s%i' % (p2_short,ndim)
+        libfn = get_lib_fn('antsImageClone%s'%fn_suffix)
+        pointer_cloned = libfn(image.pointer)
+        return ants.from_pointer(pointer_cloned)
+
+copy = clone
+
+@image_method
+def new_image_like(image, data):
+    """
+    Create a new ANTsImage with the same header information, but with
+    a new image array.
+
+    Arguments
+    ---------
+    data : ndarray or py::capsule
+        New array or pointer for the image.
+        It must have the same shape as the current
+        image data.
+
+    Returns
+    -------
+    ANTsImage
+    """
+    if not isinstance(data, np.ndarray):
+        raise ValueError('data must be a numpy array')
+    if not image.has_components:
+        if data.shape != image.shape:
+            raise ValueError('given array shape (%s) and image array shape (%s) do not match' % (data.shape, image.shape))
+    else:
+        if (data.shape[-1] != image.components) or (data.shape[:-1] != image.shape):
+            raise ValueError('given array shape (%s) and image array shape (%s) do not match' % (data.shape[1:], image.shape))
+
+    return from_numpy(data, origin=image.origin,
+        spacing=image.spacing, direction=image.direction,
+        has_components=image.has_components)
+
+def from_numpy_like(data, image):
+    return new_image_like(image, data)

MindEyeV2/antspy/ants/math/__init__.py

@@ -0,0 +1,14 @@
+from .averaging import average_images
+from .get_centroids import get_centroids
+from .get_neighborhood import get_neighborhood_in_mask, get_neighborhood_at_voxel
+from .hausdorff_distance import hausdorff_distance
+from .image_similarity import image_similarity
+from .metrics import image_mutual_information
+from .quantile import (ilr,
+                       rank_intensity,
+                       quantile,
+                       regress_poly,
+                       regress_components,
+                       get_average_of_timeseries,
+                       compcor,
+                       bandpass_filter_matrix)

MindEyeV2/antspy/ants/math/averaging.py

@@ -0,0 +1,100 @@
+import os
+from tempfile import mktemp
+
+import numpy as np
+
+import ants
+
+__all__ = ['average_images']
+
+
+def average_images( x, normalize=True, mask=None, imagetype=0, sum_image_threshold=3, return_sum_image=False, verbose=False ):
+    """
+    average a list of images
+
+    images will be resampled automatically to the largest image space;
+    this is not a registration so images should be in the same physical
+    space to begin with.
+
+    x : a list containing either filenames or antsImages 
+
+    normalize : boolean
+
+    mask : None or integer; this will perform a masked averaging which can 
+        be useful when images have only partial coverage. integer greater 
+        than zero will perform morphological closing.
+
+    imagetype : integer
+        choose 0/1/2/3 mapping to scalar/vector/tensor/time-series
+
+    sum_image_threshold : integer
+        only average regions with overlap greater than or equal to this value
+
+    return_sum_image : boolean
+        returns the average and the image that show ROI overlap; primarily for debugging
+
+    verbose : boolean
+        will print progress
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> x0=[ ants.get_data('r16'), ants.get_data('r27'), ants.get_data('r62'), ants.get_data('r64') ]
+    >>> x1=[]
+    >>> for k in range(len(x0)):
+    >>>     x1.append( ants.image_read( x0[k] ) )
+    >>> avg=ants.average_images(x0)
+    >>> avg1=ants.average_images(x1)
+    >>> avg2=ants.average_images(x1,mask=0)
+	>>> avg3=ants.average_images(x1,mask=1,normalize=True)
+    """
+    import numpy as np
+
+    def gli( y, normalize=False ):
+        if isinstance(y,str):
+            y=ants.image_read(y)
+        if normalize:
+            y=y/y.mean()
+        return y
+
+    biggest=0
+    biggestind=0
+    for k in range( len( x ) ):
+        locimg = gli( x[k], False )
+        sz=np.prod( locimg.shape )
+        if sz > biggest:
+            biggest=sz
+            biggestind=k
+
+    avg = gli( x[biggestind], False ) * 0
+    scl = float( 1.0 / len(x))
+    if mask is not None:
+        sumimg = gli( x[biggestind], False ) * 0
+
+    for k in range( len( x ) ):
+        if verbose and k % 20 == 0:
+            print( str(k)+'...', end='',flush=True)
+        locimg = gli( x[k], normalize )
+        temp = ants.resample_image_to_target( locimg, avg, interp_type='linear', imagetype=imagetype )
+        avg = avg + temp
+        if mask is not None:
+            fgmask = ants.threshold_image(temp,'Otsu',1)
+            if mask > 0:
+                fgmask = ants.morphology(fgmask,"close",mask)
+            sumimg = sumimg + fgmask
+
+    if return_sum_image:
+        return avg * scl, sumimg
+    if mask is None:
+        avg = avg * scl
+    else:
+        nonzero = sumimg > sum_image_threshold
+        tozero = sumimg <= sum_image_threshold
+        avg[nonzero] = avg[nonzero] / sumimg[nonzero]
+        avg[tozero] = 0
+    return avg        
+

MindEyeV2/antspy/ants/math/get_centroids.py

@@ -0,0 +1,58 @@
+__all__ = ["get_centroids"]
+
+import numpy as np
+import ants
+from ants.decorators import image_method
+
+@image_method
+def get_centroids(image, clustparam=0):
+    """
+    Reduces a variate/statistical/network image to a set of centroids
+    describing the center of each stand-alone non-zero component in the image
+
+    ANTsR function: `getCentroids`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image from which centroids will be calculated
+
+    clustparam : integer
+        look at regions greater than or equal to this size
+
+    Returns
+    -------
+    ndarray
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read( ants.get_ants_data( "r16" ) )
+    >>> image = ants.threshold_image( image, 90, 120 )
+    >>> image = ants.label_clusters( image, 10 )
+    >>> cents = ants.get_centroids( image )
+    """
+    imagedim = image.dimension
+    if clustparam > 0:
+        mypoints = ants.label_clusters(image, clustparam, max_thresh=1e15)
+    if clustparam == 0:
+        mypoints = image.clone()
+    mypoints = ants.label_stats(mypoints, mypoints)
+    nonzero = mypoints[["LabelValue"]] > 0
+    mypoints = mypoints[nonzero["LabelValue"]]
+    mypoints = mypoints.iloc[:, :]
+    x = mypoints.x
+    y = mypoints.y
+
+    if imagedim == 3:
+        z = mypoints.z
+    else:
+        z = np.zeros(mypoints.shape[0])
+
+    if imagedim == 4:
+        t = mypoints.t
+    else:
+        t = np.zeros(mypoints.shape[0])
+
+    centroids = np.stack([x, y, z, t]).T
+    return centroids

MindEyeV2/antspy/ants/math/get_neighborhood.py

@@ -0,0 +1,187 @@
+
+__all__ = ['get_neighborhood_in_mask',
+           'get_neighborhood_at_voxel']
+
+import numpy as np
+
+import ants
+
+from ants.internal import get_lib_fn
+from ants.decorators import image_method
+
+@image_method
+def get_neighborhood_in_mask(image, mask, radius, physical_coordinates=False,
+                            boundary_condition=None, spatial_info=False, get_gradient=False):
+    """
+    Get neighborhoods for voxels within mask.
+    
+    This converts a scalar image to a matrix with rows that contain neighbors 
+    around a center voxel
+    
+    ANTsR function: `getNeighborhoodInMask`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to get values from
+    
+    mask : ANTsImage
+        image indicating which voxels to examine. Each voxel > 0 will be used as the 
+        center of a neighborhood
+    
+    radius : tuple/list
+        array of values for neighborhood radius (in voxels)
+    
+    physical_coordinates : boolean
+        whether voxel indices and offsets should be in voxel or physical coordinates
+    
+    boundary_condition : string (optional)
+        how to handle voxels in a neighborhood, but not in the mask.
+            None : fill values with `NaN`
+            `image` : use image value, even if not in mask
+            `mean` : use mean of all non-NaN values for that neighborhood
+    
+    spatial_info : boolean
+        whether voxel locations and neighborhood offsets should be returned along with pixel values.
+    
+    get_gradient : boolean
+        whether a matrix of gradients (at the center voxel) should be returned in 
+        addition to the value matrix (WIP)
+
+    Returns
+    -------
+    if spatial_info is False:
+        if get_gradient is False:
+            ndarray
+                an array of pixel values where the number of rows is the size of the 
+                neighborhood and there is a column for each voxel
+
+        else if get_gradient is True:
+            dictionary w/ following key-value pairs:
+                values : ndarray
+                    array of pixel values where the number of rows is the size of the 
+                    neighborhood and there is a column for each voxel.
+
+                gradients : ndarray
+                    array providing the gradients at the center voxel of each 
+                    neighborhood
+        
+    else if spatial_info is True:
+        dictionary w/ following key-value pairs:
+            values : ndarray
+                array of pixel values where the number of rows is the size of the 
+                neighborhood and there is a column for each voxel.
+
+            indices : ndarray
+                array provinding the center coordinates for each neighborhood
+
+            offsets : ndarray
+                array providing the offsets from center for each voxel in a neighborhood
+
+    Example
+    -------
+    >>> import ants
+    >>> r16 = ants.image_read(ants.get_ants_data('r16'))
+    >>> mask = ants.get_mask(r16)
+    >>> mat = ants.get_neighborhood_in_mask(r16, mask, radius=(2,2))
+    """
+    if not ants.is_image(image):
+        raise ValueError('image must be ANTsImage type')
+    if not ants.is_image(mask):
+        raise ValueError('mask must be ANTsImage type')
+    if isinstance(radius, (int, float)):
+        radius = [radius]*image.dimension
+    if (not isinstance(radius, (tuple,list))) or (len(radius) != image.dimension):
+        raise ValueError('radius must be tuple or list with length == image.dimension')
+
+    boundary = 0
+    if boundary_condition == 'image':
+        boundary = 1
+    elif boundary_condition == 'mean':
+        boundary = 2
+    
+    libfn = get_lib_fn('getNeighborhoodMatrix%s' % image._libsuffix)
+    retvals = libfn(image.pointer, 
+                    mask.pointer, 
+                    list(radius),
+                    int(physical_coordinates), 
+                    int(boundary),
+                    int(spatial_info),
+                    int(get_gradient))
+
+    if not spatial_info:
+        if get_gradient:
+            retvals['values'] = np.asarray(retvals['values'])
+            retvals['gradients'] = np.asarray(retvals['gradients'])
+        else:
+            retvals = np.asarray(retvals['matrix'])
+    else:
+        retvals['values'] = np.asarray(retvals['values'])
+        retvals['indices'] = np.asarray(retvals['indices'])
+        retvals['offsets'] = np.asarray(retvals['offsets'])
+
+    return retvals
+
+@image_method
+def get_neighborhood_at_voxel(image, center, kernel, physical_coordinates=False):
+    """
+    Get a hypercube neighborhood at a voxel. Get the values in a local 
+    neighborhood of an image.
+    
+    ANTsR function: `getNeighborhoodAtVoxel`
+
+    Arguments
+    ---------
+    image : ANTsImage
+        image to get values from.
+    
+    center : tuple/list
+        indices for neighborhood center
+    
+    kernel : tuple/list
+        either a collection of values for neighborhood radius (in voxels) or 
+        a binary collection of the same dimension as the image, specifying the shape of the neighborhood to extract
+    
+    physical_coordinates : boolean
+        whether voxel indices and offsets should be in voxel 
+        or physical coordinates
+
+    Returns
+    -------
+    dictionary w/ following key-value pairs:
+        values : ndarray
+            array of neighborhood values at the voxel
+
+        indices : ndarray
+            matrix providing the coordinates for each value
+
+    Example
+    -------
+    >>> import ants
+    >>> img = ants.image_read(ants.get_ants_data('r16'))
+    >>> center = (2,2)
+    >>> radius = (3,3)
+    >>> retval = ants.get_neighborhood_at_voxel(img, center, radius)
+    """
+    if not ants.is_image(image):
+        raise ValueError('image must be ANTsImage type')
+
+    if (not isinstance(center, (tuple,list))) or (len(center) != image.dimension):
+        raise ValueError('center must be tuple or list with length == image.dimension')
+
+    if (not isinstance(kernel, (tuple,list))) or (len(kernel) != image.dimension):
+        raise ValueError('kernel must be tuple or list with length == image.dimension')
+
+    radius = [int((k-1)/2) for k in kernel]
+
+    libfn = get_lib_fn('getNeighborhood%s' % image._libsuffix)
+    retvals = libfn(image.pointer, 
+                    list(center), 
+                    list(kernel), 
+                    list(radius), 
+                    int(physical_coordinates))
+    for k in retvals.keys():
+        retvals[k] = np.asarray(retvals[k])
+    return retvals
+
+

MindEyeV2/antspy/ants/math/hausdorff_distance.py

@@ -0,0 +1,40 @@
+__all__ = ["hausdorff_distance"]
+
+from ants.decorators import image_method
+from ants.internal import get_lib_fn
+
+@image_method
+def hausdorff_distance(image1, image2):
+    """
+    Get Hausdorff distance between non-zero pixels in two images
+
+    ANTsR function: `hausdorffDistance`
+
+    Arguments
+    ---------
+    source image : ANTsImage
+        Source image
+
+    target_image : ANTsImage
+        Target image
+
+    Returns
+    -------
+    data frame with "Distance" and "AverageDistance"
+
+    Example
+    -------
+    >>> import ants
+    >>> r16 = ants.image_read( ants.get_ants_data('r16') )
+    >>> r64 = ants.image_read( ants.get_ants_data('r64') )
+    >>> s16 = ants.kmeans_segmentation( r16, 3 )['segmentation']
+    >>> s64 = ants.kmeans_segmentation( r64, 3 )['segmentation']
+    >>> stats = ants.hausdorff_distance(s16, s64)
+    """
+    image1_int = image1.clone("unsigned int")
+    image2_int = image2.clone("unsigned int")
+
+    libfn = get_lib_fn("hausdorffDistance%iD" % image1_int.dimension)
+    d = libfn(image1_int.pointer, image2_int.pointer)
+
+    return d

MindEyeV2/antspy/ants/math/image_similarity.py

@@ -0,0 +1,67 @@
+
+
+__all__ = ['image_similarity']
+
+import ants
+from ants.decorators import image_method
+
+@image_method
+def image_similarity(fixed_image, moving_image, metric_type='MeanSquares',
+                    fixed_mask=None, moving_mask=None,
+                    sampling_strategy='regular', sampling_percentage=1.):
+    """
+    Measure similarity between two images.
+    NOTE: Similarity is actually returned as distance (i.e. dissimilarity)
+    per ITK/ANTs convention. E.g. using Correlation metric, the similarity
+    of an image with itself returns -1.
+
+    ANTsR function: `imageSimilarity`
+
+    Arguments
+    ---------
+    fixed : ANTsImage
+        the fixed image
+
+    moving : ANTsImage
+        the moving image
+
+    metric_type : string
+        image metric to calculate
+            MeanSquares
+            Correlation
+            ANTSNeighborhoodCorrelation
+            MattesMutualInformation
+            JointHistogramMutualInformation
+            Demons
+
+    fixed_mask : ANTsImage (optional)
+        mask for the fixed image
+
+    moving_mask : ANTsImage (optional)
+        mask for the moving image
+
+    sampling_strategy : string (optional)
+        sampling strategy, default is full sampling
+            None (Full sampling)
+            random
+            regular
+
+    sampling_percentage : scalar
+        percentage of data to sample when calculating metric
+        Must be between 0 and 1
+
+    Returns
+    -------
+    scalar
+
+    Example
+    -------
+    >>> import ants
+    >>> x = ants.image_read(ants.get_ants_data('r16'))
+    >>> y = ants.image_read(ants.get_ants_data('r30'))
+    >>> metric = ants.image_similarity(x,y,metric_type='MeanSquares')
+    """
+    metric = ants.create_ants_metric(fixed_image, moving_image, metric_type, fixed_mask,
+                        moving_mask, sampling_strategy, sampling_percentage)
+    return metric.get_value()
+

MindEyeV2/antspy/ants/math/metrics.py

@@ -0,0 +1,43 @@
+
+ 
+
+__all__ = ['image_mutual_information']
+
+
+from ants.decorators import image_method
+from ants.internal import get_lib_fn
+
+@image_method
+def image_mutual_information(image1, image2):
+    """
+    Compute mutual information between two ANTsImage types
+
+    ANTsR function: `antsImageMutualInformation`
+    
+    Arguments
+    ---------
+    image1 : ANTsImage
+        image 1
+
+    image2 : ANTsImage
+        image 2
+
+    Returns
+    -------
+    scalar
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read( ants.get_ants_data('r16') ).clone('float')
+    >>> mi = ants.image_read( ants.get_ants_data('r64') ).clone('float')
+    >>> mival = ants.image_mutual_information(fi, mi) # -0.1796141
+    """
+    if (image1.pixeltype != 'float') or (image2.pixeltype != 'float'):
+        raise ValueError('Both images must have float pixeltype')
+
+    if image1.dimension != image2.dimension:
+        raise ValueError('Both images must have same dimension')
+
+    libfn = get_lib_fn('antsImageMutualInformation%iD' % image1.dimension)
+    return libfn(image1.pointer, image2.pointer)

MindEyeV2/antspy/ants/math/quantile.py

@@ -0,0 +1,447 @@
+
+__all__ = ['ilr',
+           'rank_intensity',
+           'quantile',
+           'regress_poly',
+           'regress_components',
+           'get_average_of_timeseries',
+           'compcor',
+           'bandpass_filter_matrix' ]
+
+import numpy as np
+from numpy.polynomial import Legendre
+from scipy import linalg
+from scipy.stats import pearsonr
+from scipy.stats import rankdata
+import pandas as pd
+from pandas import DataFrame
+import statsmodels.api as sm
+import statsmodels.formula.api as smf
+
+import ants
+from ants.decorators import image_method
+
+def rank_intensity( x, mask=None, get_mask=True, method='max',  ):
+    """
+    Rank transform the intensity of the input image with or without masking.
+    Intensities will transform from [0,1,2,55] to [0,1,2,3] so this may not be
+    appropriate for quantitative images - however, you never know.  rank
+    transformations generally improve robustness so it is an empirical question
+    that should be evaluated.
+
+    Arguments
+    ---------
+
+    x : ANTsImage
+        input image
+
+    mask : ANTsImage
+        optional mask
+
+    get_mask: boolean
+        will estimate a mask when none provided
+
+    method : a scipy rank method (max,min,average,dense)
+
+
+    return: transformed image
+
+    Example
+    -------
+    >>> img = ants.image_read(ants.get_data('r16'))
+    >>> ants.rank_intensity(img)
+    """
+    if mask is not None:
+        fir = rankdata( (x*mask).numpy(), method=method )
+    elif mask is None and get_mask == True:
+        mask = ants.get_mask( x )
+        fir = rankdata( (x*mask).numpy(), method=method )
+    else:
+        fir = rankdata( x.numpy(), method=method )
+    fir = fir - 1
+    fir = fir.reshape( x.shape )
+    rimg = ants.from_numpy( fir.astype(float)  )
+    rimg = ants.iMath(rimg,"Normalize")
+    ants.copy_image_info( x, rimg )
+    if mask is not None:
+        rimg = rimg * mask
+    return( rimg )
+
+
+def ilr( data_frame, voxmats, ilr_formula, verbose = False ):
+    """
+    Image-based linear regression.
+
+    This function simplifies calculating p-values from linear models
+    in which there is a similar formula that is applied many times
+    with a change in image-based predictors.  Image-based variables
+    are stored in the input matrix list. They should be named
+    consistently in the input formula and in the image list.  If they
+    are not, an error will be thrown.  All input matrices should have
+    the same number of rows and columns.
+
+    This function takes advantage of statsmodels R-style formulas.
+
+    ANTsR function: `ilr`
+
+    Arguments
+    ---------
+
+    data_frame: This data frame contains all relevant predictors except for
+        the matrices associated with the image variables.  One should convert
+        any categorical predictors ahead of time using `pd.get_dummies`.
+
+    voxmats: The named list of matrices that contains the changing
+        predictors.
+
+    ilr_formula: This is a character string that defines a valid regression
+        formula in the R-style.
+
+    verbose:  will print a little bit of diagnostic information that allows
+        a degree of model checking
+
+    Returns
+    -------
+
+    A list of different matrices that contain names derived from the
+    formula and the coefficients of the regression model.  The size of
+    the output values ( p-values, t-values, parameter values ) will match
+    the input matrix and, as such, can be converted to an image via `make_image`
+
+    Example
+    -------
+
+    >>> nsub = 20
+    >>> mu, sigma = 0, 1
+    >>> outcome = np.random.normal( mu, sigma, nsub )
+    >>> covar = np.random.normal( mu, sigma, nsub )
+    >>> mat = np.random.normal( mu, sigma, (nsub, 500 ) )
+    >>> mat2 = np.random.normal( mu, sigma, (nsub, 500 ) )
+    >>> data = {'covar':covar,'outcome':outcome}
+    >>> df = pd.DataFrame( data )
+    >>> vlist = { "mat1": mat, "mat2": mat2 }
+    >>> myform = " outcome ~ covar * mat1 "
+    >>> result = ants.ilr( df, vlist, myform)
+    >>> myform = " mat2 ~ covar + mat1 "
+    >>> result = ants.ilr( df, vlist, myform)
+
+    """
+
+    nvoxmats = len( voxmats )
+    if nvoxmats < 1 :
+        raise ValueError('Pass at least one matrix to voxmats list')
+    keylist = list(voxmats.keys())
+    firstmat = keylist[0]
+    voxshape = voxmats[firstmat].shape
+    nvox = voxshape[1]
+    nmats = len( keylist )
+    for k in keylist:
+        if voxmats[firstmat].shape != voxmats[k].shape:
+            raise ValueError('Matrices must have same number of rows (samples)')
+
+    # test voxel
+    vox = 0
+    nrows = data_frame.shape[0]
+    data_frame_vox = data_frame.copy()
+    for k in range( nmats ):
+        data = {keylist[k]: np.random.normal(0,1,nrows) }
+        temp = pd.DataFrame( data )
+        data_frame_vox = pd.concat([data_frame_vox.reset_index(drop=True),temp], axis=1 )
+    mod = smf.ols(formula=ilr_formula, data=data_frame_vox )
+    res = mod.fit()
+    modelNames = res.model.exog_names
+    if verbose:
+        print( data_frame_vox )
+        print(res.summary())
+    nOutcomes = len( modelNames )
+    tValsOut = list()
+    pValsOut = list()
+    bValsOut = list()
+    for k in range( len( modelNames ) ):
+        bValsOut.append( np.zeros( nvox ) )
+        pValsOut.append( np.zeros( nvox ) )
+        tValsOut.append( np.zeros( nvox ) )
+
+    data_frame_vox = data_frame.copy()
+    for v in range( nmats ):
+        data = {keylist[v]: voxmats[keylist[v]][:,k] }
+        temp = pd.DataFrame( data )
+        data_frame_vox = pd.concat([data_frame_vox.reset_index(drop=True),temp], axis=1 )
+    for k in range( nvox ):
+        # first get the correct data frame
+        for v in range( nmats ):
+            data_frame_vox[ keylist[v] ] = voxmats[keylist[v]][:,k]
+        # then get the local model results
+        mod = smf.ols(formula=ilr_formula, data=data_frame_vox )
+        res = mod.fit()
+        tvals = res.tvalues
+        pvals = res.pvalues
+        bvals = res.params
+        for v in range( len( modelNames ) ):
+            bValsOut[v][k] = bvals.iloc[v]
+            pValsOut[v][k] = pvals.iloc[v]
+            tValsOut[v][k] = tvals.iloc[v]
+
+    bValsOutDict = { }
+    tValsOutDict = { }
+    pValsOutDict = { }
+    for v in range( len( modelNames ) ):
+        bValsOutDict[ 'coef_' + modelNames[v] ] = bValsOut[v]
+        tValsOutDict[ 'tval_' + modelNames[v] ] = tValsOut[v]
+        pValsOutDict[ 'pval_' + modelNames[v] ] = pValsOut[v]
+
+    return {
+        'modelNames': modelNames,
+        'coefficientValues': bValsOutDict,
+        'pValues': pValsOutDict,
+        'tValues': tValsOutDict }
+
+
+@image_method
+def quantile(image, q, nonzero=True):
+    """
+    Get the quantile values from an ANTsImage
+    
+    Examples
+    --------
+    >>> img = ants.image_read(ants.get_data('r16'))
+    >>> ants.quantile(img, 0.5)
+    >>> ants.quantile(img, (0.5, 0.75))
+    """
+    img_arr = image.numpy()
+    if isinstance(q, (list,tuple)):
+        q = [qq*100. if qq <= 1. else qq for qq in q]
+        if nonzero:
+            img_arr = img_arr[img_arr>0]
+        vals = [np.percentile(img_arr, qq) for qq in q]
+        return tuple(vals)
+    elif isinstance(q, (float,int)):
+        if q <= 1.:
+            q = q*100.
+        if nonzero:
+            img_arr = img_arr[img_arr>0]
+        return np.percentile(img_arr[img_arr>0], q)
+    else:
+        raise ValueError('q argument must be list/tuple or float/int')
+
+
+def regress_poly(degree, data, remove_mean=True, axis=-1):
+    """
+    Returns data with degree polynomial regressed out.
+    :param bool remove_mean: whether or not demean data (i.e. degree 0),
+    :param int axis: numpy array axes along which regression is performed
+    """
+    timepoints = data.shape[0]
+    # Generate design matrix
+    X = np.ones((timepoints, 1))  # quick way to calc degree 0
+    for i in range(degree):
+        polynomial_func = Legendre.basis(i + 1)
+        value_array = np.linspace(-1, 1, timepoints)
+        X = np.hstack((X, polynomial_func(value_array)[:, np.newaxis]))
+    non_constant_regressors = X[:, :-1] if X.shape[1] > 1 else np.array([])
+    betas = np.linalg.pinv(X).dot(data)
+    if remove_mean:
+        datahat = X.dot(betas)
+    else:  # disregard the first layer of X, which is degree 0
+        datahat = X[:, 1:].dot(betas[1:, ...])
+    regressed_data = data - datahat
+    return regressed_data, non_constant_regressors
+
+def regress_components( data, components, remove_mean=True ):
+    """
+    Returns data with components regressed out.
+    :param bool remove_mean: whether or not demean data (i.e. degree 0),
+    :param int axis: numpy array axes along which regression is performed
+    """
+    timepoints = data.shape[0]
+    betas = np.linalg.pinv(components).dot(data)
+    if remove_mean:
+        datahat = components.dot(betas)
+    else:  # disregard the first layer of X, which is degree 0
+        datahat = components[:, 1:].dot(betas[1:, ...])
+    regressed_data = data - datahat
+    return regressed_data
+
+
+def get_average_of_timeseries( image, idx=None ):
+    """Average the timeseries into a dimension-1 image.
+    image: input time series image
+    idx:  indices over which to average
+    """
+    imagedim = image.dimension
+    if idx is None:
+        idx = range( image.shape[ imagedim - 1 ] )
+    i0 = ants.slice_image( image, axis=image.dimension-1, idx=idx[0] ) * 0
+    wt = 1.0 / len( idx )
+    for k in idx:
+        i0 = i0 + ants.slice_image( image, axis=image.dimension-1, idx=k ) * wt
+    return( i0 )
+
+def bandpass_filter_matrix( matrix,
+    tr=1, lowf=0.01, highf=0.1, order = 3):
+    """
+    Bandpass filter the input time series image
+
+    ANTsR function: `frequencyFilterfMRI`
+
+    Arguments
+    ---------
+
+    image: input time series image
+
+    tr:    sampling time interval (inverse of sampling rate)
+
+    lowf:  low frequency cutoff
+
+    highf: high frequency cutoff
+
+    order: order of the butterworth filter run using `filtfilt`
+
+    Returns
+    -------
+    filtered matrix
+
+    Example
+    -------
+
+    >>> import numpy as np
+    >>> import ants
+    >>> import matplotlib.pyplot as plt
+    >>> brainSignal = np.random.randn( 400, 1000 )
+    >>> tr = 1
+    >>> filtered = ants.bandpass_filter_matrix( brainSignal, tr = tr )
+    >>> nsamples = brainSignal.shape[0]
+    >>> t = np.linspace(0, tr*nsamples, nsamples, endpoint=False)
+    >>> k = 20
+    >>> plt.plot(t, brainSignal[:,k], label='Noisy signal')
+    >>> plt.plot(t, filtered[:,k], label='Filtered signal')
+    >>> plt.xlabel('time (seconds)')
+    >>> plt.grid(True)
+    >>> plt.axis('tight')
+    >>> plt.legend(loc='upper left')
+    >>> plt.show()
+    """
+    from scipy.signal import butter, filtfilt
+
+    def butter_bandpass(lowcut, highcut, fs, order ):
+        nyq = 0.5 * fs
+        low = lowcut / nyq
+        high = highcut / nyq
+        b, a = butter(order, [low, high], btype='band')
+        return b, a
+
+    def butter_bandpass_filter(data, lowcut, highcut, fs, order ):
+        b, a = butter_bandpass(lowcut, highcut, fs, order=order)
+        y = filtfilt(b, a, data)
+        return y
+
+    fs = 1/tr   # sampling rate based on tr
+    nsamples = matrix.shape[0]
+    ncolumns = matrix.shape[1]
+    matrixOut = matrix.copy()
+    for k in range( ncolumns ):
+        matrixOut[:,k] = butter_bandpass_filter(
+            matrix[:,k], lowf, highf, fs, order=order )
+    return matrixOut
+
+def clean_data(arr, standardize=True):
+    """
+    Remove columns from a NumPy array that have no variation or contain NA/Inf values.
+    Optionally standardize the remaining data.
+
+    :param arr: NumPy array to be cleaned.
+    :param standardize: Boolean, if True standardize the data.
+    :return: Cleaned (and optionally standardized) NumPy array.
+    """
+    valid_columns = []
+
+    for i in range(arr.shape[1]):
+        column = arr[:, i]
+        if np.any(column != column[0]) and not np.any(np.isnan(column)) and not np.any(np.isinf(column)):
+            valid_columns.append(i)
+
+    cleaned_data = arr[:, valid_columns]
+
+    if standardize:
+        mean = np.mean(cleaned_data, axis=0)
+        std_dev = np.std(cleaned_data, axis=0)
+        # Avoid division by zero in case of zero standard deviation
+        std_dev[std_dev == 0] = 1
+        cleaned_data = (cleaned_data - mean) / std_dev
+
+    return cleaned_data
+
+def compcor( boldImage, ncompcor=4, quantile=0.975, mask=None, filter_type=False, degree=2 ):
+    """
+    Compute noise components from the input image
+
+    ANTsR function: `compcor`
+
+    this is adapted from nipy code https://github.com/nipy/nipype/blob/e29ac95fc0fc00fedbcaa0adaf29d5878408ca7c/nipype/algorithms/confounds.py
+
+    Arguments
+    ---------
+
+    boldImage: input time series image
+
+    ncompcor:  number of noise components to return
+
+    quantile:  quantile defining high-variance
+
+    mask:      mask defining brain or specific tissues
+
+    filter_type: type off filter to apply to time series before computing
+                 noise components.
+
+        'polynomial' - Legendre polynomial basis
+        False - None (mean-removal only)
+
+    degree: order of polynomial used to remove trends from the timeseries
+
+    Returns
+    -------
+    dictionary containing:
+
+        components: a numpy array
+
+        basis: a numpy array containing the (non-constant) filter regressors
+
+    Example
+    -------
+    >>> cc = ants.compcor( ants.image_read(ants.get_ants_data("ch2")) )
+
+    """
+
+    def compute_tSTD(M, quantile, x=0, axis=0):
+        stdM = np.std(M, axis=axis)
+        # set bad values to x
+        stdM[stdM == 0] = x
+        stdM[np.isnan(stdM)] = x
+        tt = round( quantile*100 )
+        threshold_std = np.percentile( stdM, tt )
+    #    threshold_std = quantile( stdM, quantile )
+        return { 'tSTD': stdM, 'threshold_std': threshold_std}
+    if mask is None:
+        temp = ants.slice_image( boldImage, axis=boldImage.dimension-1, idx=0 )
+        mask = ants.get_mask( temp )
+    imagematrix = ants.timeseries_to_matrix( boldImage, mask )
+    temp = compute_tSTD( imagematrix, quantile, 0 )
+    tsnrmask = ants.make_image( mask,  temp['tSTD'] )
+    tsnrmask = ants.threshold_image( tsnrmask, temp['threshold_std'], temp['tSTD'].max() )
+    M = ants.timeseries_to_matrix( boldImage, tsnrmask )
+    components = None
+    basis = np.array([])
+    if filter_type in ('polynomial', False):
+        M, basis = regress_poly(degree, M)
+#    M = M / compute_tSTD(M, 1.)['tSTD']
+    # "The covariance matrix C = MMT was constructed and decomposed into its
+    # principal components using a singular value decomposition."
+    M = clean_data( M, standardize=True )
+    u, _, _ = linalg.svd(M, full_matrices=False)
+    if components is None:
+        components = u[:, :ncompcor]
+    else:
+        components = np.hstack((components, u[:, :ncompcor]))
+    if components is None and ncompcor > 0:
+        raise ValueError('No components found')
+    return { 'components': components, 'basis': basis }

MindEyeV2/antspy/ants/registration/__init__.py

@@ -0,0 +1,15 @@
+from .affine_initializer import affine_initializer
+from .apply_transforms import apply_transforms, apply_transforms_to_points
+from .average_transform import average_affine_transform, average_affine_transform_no_rigid
+from .build_template import build_template
+from .compose_displacement_fields import compose_displacement_fields
+from .create_jacobian_determinant_image import create_jacobian_determinant_image, deformation_gradient
+from .create_warped_grid import create_warped_grid
+from .fit_bspline_displacement_field import fit_bspline_displacement_field
+from .fit_bspline_object_to_scattered_data import fit_bspline_object_to_scattered_data
+from .fit_thin_plate_spline_displacement_field import fit_thin_plate_spline_displacement_field
+from .integrate_velocity_field import integrate_velocity_field
+from .invert_displacement_field import invert_displacement_field
+from .landmark_transforms import fit_transform_to_paired_points, fit_time_varying_transform_to_point_sets
+from .registration import registration, motion_correction, label_image_registration
+from .simulate_displacement_field import simulate_displacement_field

MindEyeV2/antspy/ants/registration/affine_initializer.py

@@ -0,0 +1,70 @@
+
+__all__ = ['affine_initializer']
+
+import warnings
+from tempfile import mktemp
+
+from ants.internal import get_lib_fn, process_arguments
+
+
+def affine_initializer(fixed_image, moving_image, search_factor=20,
+                        radian_fraction=0.1, use_principal_axis=False,
+                        local_search_iterations=10, mask=None, txfn=None ):
+    """
+    A multi-start optimizer for affine registration
+    Searches over the sphere to find a good initialization for further
+    registration refinement, if needed.  This is a wrapper for the ANTs
+    function antsAffineInitializer.
+
+    ANTsR function: `affineInitializer`
+
+    Arguments
+    ---------
+    fixed_image : ANTsImage
+        the fixed reference image
+    moving_image : ANTsImage
+        the moving image to be mapped to the fixed space
+    search_factor : scalar
+        degree of increments on the sphere to search
+    radian_fraction : scalar
+        between zero and one, defines the arc to search over
+    use_principal_axis : boolean
+        boolean to initialize by principal axis
+    local_search_iterations : scalar
+        gradient descent iterations
+    mask : ANTsImage (optional)
+        optional mask to restrict registration
+    txfn : string (optional)
+        filename for the transformation
+
+    Returns
+    -------
+    ndarray
+        transformation matrix
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read(ants.get_ants_data('r16'))
+    >>> mi = ants.image_read(ants.get_ants_data('r27'))
+    >>> txfile = ants.affine_initializer( fi, mi )
+    >>> tx = ants.read_transform(txfile, dimension=2)
+    """
+
+    if txfn is None:
+        txfn = mktemp(suffix='.mat')
+
+    veccer = [fixed_image.dimension, fixed_image, moving_image, txfn,
+                search_factor, radian_fraction, int(use_principal_axis),
+                local_search_iterations]
+    if mask is not None:
+        veccer.append(mask)
+
+    xxx = process_arguments(veccer)
+    libfn = get_lib_fn('antsAffineInitializer')
+    retval = libfn(xxx)
+
+    if retval != 0:
+        warnings.warn('ERROR: Non-zero exit status!')
+
+    return txfn

MindEyeV2/antspy/ants/registration/apply_transforms.py

@@ -0,0 +1,316 @@
+
+
+__all__ = ['apply_transforms',
+           'apply_transforms_to_points']
+
+import os
+
+import ants
+from ants.internal import get_lib_fn, process_arguments
+
+
+def apply_transforms(fixed, moving, transformlist,
+                     interpolator='linear', imagetype=0,
+                     whichtoinvert=None, compose=None,
+                     defaultvalue=0, singleprecision=False, verbose=False, **kwargs):
+    """
+    Apply a transform list to map an image from one domain to another.
+    In image registration, one computes mappings between (usually) pairs
+    of images. These transforms are often a sequence of increasingly
+    complex maps, e.g. from translation, to rigid, to affine to deformation.
+    The list of such transforms is passed to this function to interpolate one
+    image domain into the next image domain, as below. The order matters
+    strongly and the user is advised to familiarize with the standards
+    established in examples.
+
+    ANTsR function: `antsApplyTransforms`
+
+    Arguments
+    ---------
+    fixed : ANTsImage
+        fixed image defining domain into which the moving image is transformed. The output will
+        have the same pixel type as this image.
+
+    moving : AntsImage
+        moving image to be mapped to fixed space.
+
+    transformlist : list of strings
+        list of transforms generated by ants.registration where each transform is a filename.
+
+    interpolator : string
+        Choice of interpolator. Supports partial matching.
+            linear
+            nearestNeighbor
+            multiLabel for label images (deprecated, prefer genericLabel)
+            gaussian
+            bSpline
+            cosineWindowedSinc
+            welchWindowedSinc
+            hammingWindowedSinc
+            lanczosWindowedSinc
+            genericLabel use this for label images
+
+    imagetype : integer
+        choose 0/1/2/3 mapping to scalar/vector/tensor/time-series
+
+    whichtoinvert : list of booleans (optional)
+        Must be same length as transformlist.
+        whichtoinvert[i] is True if transformlist[i] is a matrix,
+        and the matrix should be inverted. If transformlist[i] is a
+        warp field, whichtoinvert[i] must be False.
+        If the transform list is a matrix followed by a warp field,
+        whichtoinvert defaults to (True,False). Otherwise it defaults
+        to [False]*len(transformlist)).
+
+    compose : string (optional)
+        if it is a string pointing to a valid file location,
+        this will force the function to return a composite transformation filename.
+
+    defaultvalue : scalar
+        Default voxel value for mappings outside the image domain.
+
+    singleprecision : boolean
+        if True, use float32 for computations. This is useful for reducing memory
+        usage for large datasets, at the cost of precision.
+
+    verbose : boolean
+        print command and run verbose application of transform.
+
+    kwargs : keyword arguments
+        extra parameters
+
+    Returns
+    -------
+    ANTsImage or string (transformation filename)
+
+    Example
+    -------
+    >>> import ants
+    >>> fixed = ants.image_read( ants.get_ants_data('r16') )
+    >>> moving = ants.image_read( ants.get_ants_data('r64') )
+    >>> fixed = ants.resample_image(fixed, (64,64), 1, 0)
+    >>> moving = ants.resample_image(moving, (64,64), 1, 0)
+    >>> mytx = ants.registration(fixed=fixed , moving=moving ,
+                                 type_of_transform = 'SyN' )
+    >>> mywarpedimage = ants.apply_transforms( fixed=fixed, moving=moving,
+                                               transformlist=mytx['fwdtransforms'] )
+    """
+
+    if not isinstance(transformlist, (tuple, list)) and (transformlist is not None):
+        transformlist = [transformlist]
+
+    accepted_interpolators = {"linear", "nearestNeighbor", "multiLabel", "gaussian",
+                        "bSpline", "cosineWindowedSinc", "welchWindowedSinc",
+                        "hammingWindowedSinc", "lanczosWindowedSinc", "genericLabel"}
+
+    if interpolator not in accepted_interpolators:
+        raise ValueError('interpolator not supported - see %s' % accepted_interpolators)
+
+    args = [fixed, moving, transformlist, interpolator]
+
+    output_pixel_type = 'float' if singleprecision else 'double'
+
+    if not isinstance(fixed, str):
+        if ants.is_image(fixed) and ants.is_image(moving):
+            for tl_path in transformlist:
+                if not os.path.exists(tl_path):
+                    raise Exception('Transform %s does not exist' % tl_path)
+
+            inpixeltype = fixed.pixeltype
+            fixed = fixed.clone(output_pixel_type)
+            moving = moving.clone(output_pixel_type)
+            warpedmovout = moving.clone(output_pixel_type)
+            f = fixed
+            m = moving
+            if (moving.dimension == 4) and (fixed.dimension == 3) and (imagetype == 0):
+                raise Exception('Set imagetype 3 to transform time series images.')
+
+            wmo = warpedmovout
+            mytx = []
+            if whichtoinvert is None or (isinstance(whichtoinvert, (tuple,list)) and (sum([w is not None for w in whichtoinvert])==0)):
+                if (len(transformlist) == 2) and ('.mat' in transformlist[0]) and ('.mat' not in transformlist[1]):
+                    whichtoinvert = (True, False)
+                else:
+                    whichtoinvert = tuple([False]*len(transformlist))
+
+            if len(whichtoinvert) != len(transformlist):
+                raise ValueError('Transform list and inversion list must be the same length')
+
+            for i in range(len(transformlist)):
+                ismat = False
+                if '.mat' in transformlist[i]:
+                    ismat = True
+                if whichtoinvert[i] and (not ismat):
+                    raise ValueError('Cannot invert transform %i (%s) because it is not a matrix' % (i, transformlist[i]))
+                if whichtoinvert[i]:
+                    mytx = mytx + ['-t', '[%s,1]' % (transformlist[i])]
+                else:
+                    mytx = mytx + ['-t', transformlist[i]]
+
+            if compose is None:
+                args = ['-d', fixed.dimension,
+                        '-i', m,
+                        '-o', wmo,
+                        '-r', f,
+                        '-n', interpolator]
+                args = args + mytx
+            if compose:
+                tfn = '%scomptx.nii.gz' % compose if not compose.endswith('.h5') else compose
+            else:
+                tfn = 'NA'
+            if compose is not None:
+                mycompo = '[%s,1]' % tfn
+                args = ['-d', fixed.dimension,
+                        '-i', m,
+                        '-o', mycompo,
+                        '-r', f,
+                        '-n', interpolator]
+                args = args + mytx
+
+            myargs = process_arguments(args)
+
+            myverb = int(verbose)
+            if verbose:
+                print(myargs)
+
+            processed_args = myargs + ['-z', str(1), '-v', str(myverb), '--float', str(int(singleprecision)), '-e', str(imagetype), '-f', str(defaultvalue)]
+            libfn = get_lib_fn('antsApplyTransforms')
+            libfn(processed_args)
+
+            if compose is None:
+                return warpedmovout.clone(inpixeltype)
+            else:
+                if os.path.exists(tfn):
+                    return tfn
+                else:
+                    return None
+
+        else:
+            return 1
+    else:
+        args = args + ['-z', str(1), '--float', str(int(singleprecision)), '-e', imagetype, '-f', defaultvalue]
+        processed_args = process_arguments(args)
+        libfn = get_lib_fn('antsApplyTransforms')
+        libfn(processed_args)
+
+
+
+
+
+
+def apply_transforms_to_points( dim, points, transformlist,
+                     whichtoinvert=None, verbose=False ):
+    """
+     Apply a transform list to map a pointset from one domain to
+     another. In registration, one computes mappings between pairs of
+     domains. These transforms are often a sequence of increasingly
+     complex maps, e.g. from translation, to rigid, to affine to
+     deformation.  The list of such transforms is passed to this
+     function to interpolate one image domain into the next image
+     domain, as below.  The order matters strongly and the user is
+     advised to familiarize with the standards established in examples.
+     Importantly, point mapping goes the opposite direction of image
+     mapping, for both reasons of convention and engineering.
+
+    ANTsR function: `antsApplyTransformsToPoints`
+
+    Arguments
+    ---------
+    dim: integer
+         dimensionality of the transformation.
+
+    points: data frame
+          moving point set with n-points in rows of at least dim
+          columns - we maintain extra information in additional
+          columns. this should be a data frame with columns names x, y, z, t.
+
+    transformlist : list of strings
+        list of transforms generated by ants.registration where each transform is a filename.
+
+    whichtoinvert : list of booleans (optional)
+        Must be same length as transformlist.
+        whichtoinvert[i] is True if transformlist[i] is a matrix,
+        and the matrix should be inverted. If transformlist[i] is a
+        warp field, whichtoinvert[i] must be False.
+        If the transform list is a matrix followed by a warp field,
+        whichtoinvert defaults to (True,False). Otherwise it defaults
+        to [False]*len(transformlist)).
+
+    verbose : boolean
+
+    Returns
+    -------
+    data frame of transformed points
+
+    Example
+    -------
+    >>> import ants
+    >>> fixed = ants.image_read( ants.get_ants_data('r16') )
+    >>> moving = ants.image_read( ants.get_ants_data('r27') )
+    >>> reg = ants.registration( fixed, moving, 'Affine' )
+    >>> d = {'x': [128, 127], 'y': [101, 111]}
+    >>> pts = pd.DataFrame(data=d)
+    >>> ptsw = ants.apply_transforms_to_points( 2, pts, reg['fwdtransforms'])
+    """
+
+    if not isinstance(transformlist, (tuple, list)) and (transformlist is not None):
+        transformlist = [transformlist]
+
+    args = [dim, points, transformlist, whichtoinvert]
+
+    for tl_path in transformlist:
+        if not os.path.exists(tl_path):
+            raise Exception('Transform %s does not exist' % tl_path)
+
+    mytx = []
+
+    if whichtoinvert is None or (isinstance(whichtoinvert, (tuple,list)) and (sum([w is not None for w in whichtoinvert])==0)):
+        if (len(transformlist) == 2) and ('.mat' in transformlist[0]) and ('.mat' not in transformlist[1]):
+            whichtoinvert = (True, False)
+        else:
+            whichtoinvert = tuple([False]*len(transformlist))
+
+    if len(whichtoinvert) != len(transformlist):
+        raise ValueError('Transform list and inversion list must be the same length')
+
+    for i in range(len(transformlist)):
+        ismat = False
+        if '.mat' in transformlist[i]:
+            ismat = True
+        if whichtoinvert[i] and (not ismat):
+            raise ValueError('Cannot invert transform %i (%s) because it is not a matrix' % (i, transformlist[i]))
+        if whichtoinvert[i]:
+            mytx = mytx + ['-t', '[%s,1]' % (transformlist[i])]
+        else:
+            mytx = mytx + ['-t', transformlist[i]]
+    if dim == 2:
+        pointsSub = points[['x','y']]
+    if dim == 3:
+        pointsSub = points[['x','y','z']]
+    if dim == 4:
+        pointsSub = points[['x','y','z','t']]
+    pointImage = ants.make_image( pointsSub.shape, pointsSub.values.flatten())
+    pointsOut = pointImage.clone()
+    args = ['-d', dim,
+            '-i', pointImage,
+            '-o', pointsOut ]
+    args = args + mytx
+    myargs = process_arguments(args)
+
+    myverb = int(verbose)
+    if verbose:
+        print(myargs)
+
+    processed_args = myargs + [ '-f', str(1), '--precision', str(0)]
+    libfn = get_lib_fn('antsApplyTransformsToPoints')
+    libfn(processed_args)
+    mynp = pointsOut.numpy()
+    pointsOutDF = points.copy()
+    pointsOutDF['x'] = mynp[:,0]
+    if dim >= 2:
+        pointsOutDF['y'] = mynp[:,1]
+    if dim >= 3:
+        pointsOutDF['z'] = mynp[:,2]
+    if dim >= 4:
+        pointsOutDF['t'] = mynp[:,3]
+    return pointsOutDF

MindEyeV2/antspy/ants/registration/average_transform.py

@@ -0,0 +1,48 @@
+
+from tempfile import mktemp
+import os
+
+import ants
+from ants.internal import get_lib_fn, process_arguments
+
+__all__ = ['average_affine_transform', 
+           'average_affine_transform_no_rigid']
+
+
+def _average_affine_transform_driver(transformlist, referencetransform=None, funcname="AverageAffineTransform"):
+    """
+    takes a list of transforms (files at the moment)
+    and returns the average
+    """
+
+    # AverageAffineTransform deals with transform files,
+    # so this function will need to deal with already
+    # loaded files. Doesn't look like the magic
+    # available for images has been added for transforms.
+    res_temp_file = mktemp(suffix='.mat')
+
+    # could do some stuff here to cope with transform lists that
+    # aren't files
+    
+    # load one of the transforms to figure out the dimension
+    tf = ants.read_transform(transformlist[0])
+    if referencetransform is None:
+        args = [tf.dimension, res_temp_file] + transformlist
+    else:
+        args = [tf.dimension, res_temp_file] + ['-R',  referencetransform] + transformlist
+    pargs = process_arguments(args)
+    print(pargs)
+    libfun = get_lib_fn(funcname)
+    status = libfun(pargs)
+
+    res = ants.read_transform(res_temp_file)
+    os.remove(res_temp_file)
+    return res
+
+def average_affine_transform(transformlist, referencetransform=None):
+    return _average_affine_transform_driver(transformlist, referencetransform, "AverageAffineTransform")
+
+
+def average_affine_transform_no_rigid(transformlist, referencetransform=None):
+    return _average_affine_transform_driver(transformlist, referencetransform, "AverageAffineTransformNoRigid")
+    

MindEyeV2/antspy/ants/registration/build_template.py

@@ -0,0 +1,137 @@
+__all__ = ["build_template"]
+
+import numpy as np
+import os
+import shutil
+from tempfile import mktemp
+
+import ants
+
+def build_template(
+    initial_template=None,
+    image_list=None,
+    iterations=3,
+    gradient_step=0.2,
+    blending_weight=0.75,
+    weights=None,
+    useNoRigid=True,
+    output_dir=None,
+    **kwargs
+):
+    """
+    Estimate an optimal template from an input image_list
+
+    ANTsR function: N/A
+
+    Arguments
+    ---------
+    initial_template : ANTsImage
+        initialization for the template building
+
+    image_list : ANTsImages
+        images from which to estimate template
+
+    iterations : integer
+        number of template building iterations
+
+    gradient_step : scalar
+        for shape update gradient
+
+    blending_weight : scalar
+        weight for image blending
+
+    weights : vector
+        weight for each input image
+
+    useNoRigid : boolean
+        equivalent of -y in the script. Template update
+        step will not use the rigid component if this is True.
+
+    output_dir : path
+        directory name where intermediate transforms are written
+
+    kwargs : keyword args
+        extra arguments passed to ants registration
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> image = ants.image_read( ants.get_ants_data('r16') )
+    >>> image2 = ants.image_read( ants.get_ants_data('r27') )
+    >>> image3 = ants.image_read( ants.get_ants_data('r85') )
+    >>> timage = ants.build_template( image_list = ( image, image2, image3 ) ).resample_image( (45,45))
+    >>> timagew = ants.build_template( image_list = ( image, image2, image3 ), weights = (5,1,1) )
+    """
+    work_dir = mktemp() if output_dir is None else output_dir
+
+    def make_outprefix(k: int):
+        os.makedirs(os.path.join(work_dir, f"img{k:04d}"), exist_ok=True)
+        return os.path.join(work_dir, f"img{k:04d}", "out")
+
+    if "type_of_transform" not in kwargs:
+        type_of_transform = "SyN"
+    else:
+        type_of_transform = kwargs.pop("type_of_transform")
+
+    if weights is None:
+        weights = np.repeat(1.0 / len(image_list), len(image_list))
+    weights = [x / sum(weights) for x in weights]
+    if initial_template is None:
+        initial_template = image_list[0] * 0
+        for i in range(len(image_list)):
+            temp = image_list[i] * weights[i]
+            temp = ants.resample_image_to_target(temp, initial_template)
+            initial_template = initial_template + temp
+
+    xavg = initial_template.clone()
+    for i in range(iterations):
+        affinelist = []
+        for k in range(len(image_list)):
+            w1 = ants.registration(
+                xavg, image_list[k], type_of_transform=type_of_transform, outprefix=make_outprefix(k), **kwargs
+            )
+            L = len(w1["fwdtransforms"])
+            # affine is the last one
+            affinelist.append(w1["fwdtransforms"][L-1])
+
+            if k == 0:
+                if L == 2:
+                    wavg = ants.image_read(w1["fwdtransforms"][0]) * weights[k]
+                xavgNew = w1["warpedmovout"] * weights[k]
+            else:
+                if L == 2:
+                    wavg = wavg + ants.image_read(w1["fwdtransforms"][0]) * weights[k]
+                xavgNew = xavgNew + w1["warpedmovout"] * weights[k]
+
+        if useNoRigid:
+            avgaffine = ants.average_affine_transform_no_rigid(affinelist)
+        else:
+            avgaffine = ants.average_affine_transform(affinelist)
+        afffn = os.path.join(work_dir, "avgAffine.mat")
+        ants.write_transform(avgaffine, afffn)
+
+        if L == 2:
+            print(wavg.abs().mean())
+            wscl = (-1.0) * gradient_step
+            wavg = wavg * wscl
+            # apply affine to the nonlinear?
+            # need to save the average
+            wavgA = ants.apply_transforms(fixed=xavgNew, moving=wavg, imagetype=1, transformlist=afffn, whichtoinvert=[1])
+            wavgfn = os.path.join(work_dir, "avgWarp.nii.gz")
+            ants.image_write(wavgA, wavgfn)
+            xavg = ants.apply_transforms(fixed=xavgNew, moving=xavgNew, transformlist=[wavgfn, afffn], whichtoinvert=[0, 1])
+        else:
+            xavg = ants.apply_transforms(fixed=xavgNew, moving=xavgNew, transformlist=[afffn], whichtoinvert=[1])
+            
+        if blending_weight is not None:
+            xavg = xavg * blending_weight + ants.iMath(xavg, "Sharpen") * (
+                1.0 - blending_weight
+            )
+
+    if output_dir is None:
+        shutil.rmtree(work_dir)
+    return xavg

MindEyeV2/antspy/ants/registration/compose_displacement_fields.py

@@ -0,0 +1,33 @@
+
+__all__ = ['compose_displacement_fields']
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def compose_displacement_fields(displacement_field, 
+                                warping_field):
+    """
+    Compose displacement fields.
+
+    Arguments
+    ---------
+    displacement_field : ANTsImage displacement field
+        displacement field
+
+    warping_field : ANTsImage displacement field
+        warping field
+
+
+    Example
+    -------
+    >>> import ants
+    """
+
+    libfn = get_lib_fn('composeDisplacementFieldsD%i' % displacement_field.dimension)
+    comp_field = libfn(displacement_field.pointer, warping_field.pointer)
+
+    new_image = ants.from_pointer(comp_field).clone('float')
+    return new_image
+
+

MindEyeV2/antspy/ants/registration/create_jacobian_determinant_image.py

@@ -0,0 +1,175 @@
+
+ 
+
+__all__ = ['create_jacobian_determinant_image',
+           'deformation_gradient']
+
+from tempfile import mktemp
+
+import ants
+from ants.internal import get_lib_fn, process_arguments
+
+
+def deformation_gradient( warp_image, to_rotation=False, py_based=False ):
+    """
+    Compute the deformation gradient from an image containing a warp (deformation)
+   
+    ANTsR function: `NA`
+
+    Arguments
+    ---------
+    warp_image : ANTsImage (or filename if not py_based)
+        image that defines the deformation field (vector pixels)
+
+    to_rotation : boolean maps deformation gradient to a rotation matrix
+
+    py_based: boolean uses pure python implementation (maybe slow)
+
+    Returns
+    -------
+    ANTsImage with dimension*dimension components indexed in order U_xyz, V_xyz, W_xyz 
+        where U is the x-component of deformation and xyz are spatial.
+
+    Note
+    -------
+    the to_rotation option is still experimental. use with caution.
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read( ants.get_ants_data('r16'))
+    >>> mi = ants.image_read( ants.get_ants_data('r64'))
+    >>> fi = ants.resample_image(fi,(128,128),1,0)
+    >>> mi = ants.resample_image(mi,(128,128),1,0)
+    >>> mytx = ants.registration(fixed=fi , moving=mi, type_of_transform = ('SyN') )
+    >>> dg = ants.deformation_gradient( ants.image_read( mytx['fwdtransforms'][0] ) )
+    """
+    import numpy as np
+    def polar_decomposition(X):
+         U, d, V = np.linalg.svd(X, full_matrices=False)
+         P = np.matmul(U, np.matmul(np.diag(d), np.transpose(U)))
+         Z = np.matmul(U, V)
+         if np.linalg.det(Z) < 0:
+             n = X.shape[0]
+             reflection_matrix = np.identity(n)
+             reflection_matrix[0,0] = -1.0
+             Z = np.matmul(Z, reflection_matrix)
+         return({"P" : P, "Z" : Z, "Xtilde" : np.matmul(P, Z)})
+    if not py_based:
+        if ants.is_image(warp_image):
+            txuse = mktemp(suffix='.nii.gz')
+            ants.image_write(warp_image, txuse)
+        else:
+            txuse = warp_image
+            warp_image=ants.image_read(txuse)
+        if not ants.is_image(warp_image):
+            raise RuntimeError("antsimage is required")
+        writtenimage = mktemp(suffix='.nrrd')
+        dimage = warp_image.split_channels()[0].clone('double')
+        dim = dimage.dimension
+        tshp = dimage.shape
+        args2 = [dim, txuse, writtenimage, int(0), int(0), int(1)]
+        processed_args = process_arguments(args2)
+        libfn = get_lib_fn('CreateJacobianDeterminantImage')
+        libfn(processed_args)
+        dg = ants.image_read(writtenimage) 
+        if to_rotation:
+            newshape = tshp + (dim,dim)
+            dg = np.reshape( dg.numpy(), newshape )
+            it=np.ndindex(tshp)
+            for i in it:
+                dg[i]=polar_decomposition( dg[i] )['Z']
+            newshape = tshp + (dim*dim,)
+            dg = np.reshape( dg, newshape )
+            dg = ants.from_numpy( dg, has_components=True )
+            dg = ants.copy_image_info( dimage, dg )
+        import os
+        os.remove( writtenimage )
+        return dg
+    if py_based:
+        if not ants.is_image(warp_image):
+            raise RuntimeError("antsimage is required")
+        dim = warp_image.dimension
+        warpnp=warp_image.numpy()
+        tshp=warp_image.shape
+        tdir=warp_image.direction
+        spc = warp_image.spacing
+        it=np.ndindex(tshp)
+        # print("first we need to rotate the warp by the direction cosines")
+        for i in it:
+            warpnp[i]=np.dot( tdir,warpnp[i])
+        # print("second get deformation gradient")
+        dg = []
+        for k in range(dim):
+            if dim == 2:
+                temp=np.stack( np.gradient( warpnp[...,k], spc[0], spc[1], axis=range(dim) ), axis=dim)
+            if dim == 3:
+                temp=np.stack( np.gradient( warpnp[...,k], spc[0], spc[1], spc[2], axis=range(dim) ), axis=dim)
+            dg.append(temp)
+        dg = np.stack(dg,axis=dim+1)
+        it=np.ndindex(tshp)
+        ident = np.eye( dim )
+        for i in it:
+            dg[i]=dg[i]+ident
+        if to_rotation:
+            it=np.ndindex(tshp)
+            for i in it:
+                dg[i]=polar_decomposition( dg[i] )['Z']
+        newshape = tshp + (dim*dim,)
+        dg = np.reshape( dg, newshape )
+        dg = ants.from_numpy( dg, has_components=True )
+        dg = ants.copy_image_info( warp_image, dg )
+    return dg
+
+
+
+def create_jacobian_determinant_image(domain_image, tx, do_log=False, geom=False):
+    """
+    Compute the jacobian determinant from a transformation file
+   
+    ANTsR function: `createJacobianDeterminantImage`
+
+    Arguments
+    ---------
+    domain_image : ANTsImage
+        image that defines transformation domain
+    
+    tx : string
+        deformation transformation file name
+    
+    do_log : boolean
+        return the log jacobian
+    
+    geom : bolean
+        use the geometric jacobian calculation (boolean)
+    
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read( ants.get_ants_data('r16'))
+    >>> mi = ants.image_read( ants.get_ants_data('r64'))
+    >>> fi = ants.resample_image(fi,(128,128),1,0)
+    >>> mi = ants.resample_image(mi,(128,128),1,0)
+    >>> mytx = ants.registration(fixed=fi , moving=mi, type_of_transform = ('SyN') )
+    >>> jac = ants.create_jacobian_determinant_image(fi,mytx['fwdtransforms'][0],1)
+    """
+    dim = domain_image.dimension
+    if ants.is_image(tx):
+        txuse = mktemp(suffix='.nii.gz')
+        ants.image_write(tx, txuse)
+    else:
+        txuse = tx
+    #args = [dim, txuse, do_log]
+    dimage = domain_image.clone('double')
+    args2 = [dim, txuse, dimage, int(do_log), int(geom)]
+    processed_args = process_arguments(args2)
+    libfn = get_lib_fn('CreateJacobianDeterminantImage')
+    libfn(processed_args)
+    jimage = args2[2].clone('float')
+    
+    return jimage
+

MindEyeV2/antspy/ants/registration/create_warped_grid.py

@@ -0,0 +1,105 @@
+
+
+__all__ = ['create_warped_grid']
+
+import numpy as np
+
+import ants
+
+
+def create_warped_grid(image, grid_step=10, grid_width=2, grid_directions=(True, True),
+                       fixed_reference_image=None, transform=None, foreground=1, background=0):
+    """
+    Deforming a grid is a helpful way to visualize a deformation field. 
+    This function enables a user to define the grid parameters 
+    and apply a deformable map to that grid.
+
+    ANTsR function: `createWarpedGrid`
+    
+    Arguments
+    ---------
+    image : ANTsImage
+        input image
+    
+    grid_step : scalar   
+        width of grid blocks
+    
+    grid_width : scalar
+        width of grid lines
+    
+    grid_directions : tuple of booleans 
+        directions in which to draw grid lines, boolean vector
+    
+    fixed_reference_image : ANTsImage (optional)
+        reference image space
+    
+    transform : list/tuple of strings (optional)
+        vector of transforms
+    
+    foreground : scalar
+        intensity value for grid blocks
+    
+    background : scalar
+        intensity value for grid lines
+
+    Returns
+    -------
+    ANTsImage
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read( ants.get_ants_data( 'r16' ) )
+    >>> mi = ants.image_read( ants.get_ants_data( 'r64' ) )
+    >>> mygr = ants.create_warped_grid( mi )
+    >>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = ('SyN') )
+    >>> mywarpedgrid = ants.create_warped_grid( mygr, grid_directions=(False,True),
+                            transform=mytx['fwdtransforms'], fixed_reference_image=fi )
+    """
+    if ants.is_image(image):
+        if len(grid_directions) != image.dimension:
+            grid_directions = [True]*image.dimension
+        garr = image.numpy() * 0 + foreground
+    else:
+        if not isinstance(image, (list, tuple)):
+            raise ValueError('image arg must be ANTsImage or list or tuple')
+        if len(grid_directions) != len(image):
+            grid_directions = [True]*len(image)
+        garr = np.zeros(image) + foreground
+        image = ants.from_numpy(garr)
+
+    idim = garr.ndim
+    gridw = grid_width
+
+    for d in range(idim):
+        togrid = np.arange(-1, garr.shape[d]-1, step=grid_step)
+        for i in range(len(togrid)):
+            if (d == 0) & (idim == 3) & (grid_directions[d]):
+                garr[togrid[i]:(togrid[i]+gridw),...] = background
+                garr[0,...] = background
+                garr[-1,...] = background
+            if (d == 1) & (idim == 3) & (grid_directions[d]):
+                garr[:,togrid[i]:(togrid[i]+gridw),:] = background
+                garr[:,0,:] = background
+                garr[:,-1,:] = background
+            if (d == 2) & (idim == 3) & (grid_directions[d]):
+                garr[...,togrid[i]:(togrid[i]+gridw)] = background
+                garr[...,0] = background
+                garr[...,-1] = background
+            if (d == 0) & (idim == 2) & (grid_directions[d]):
+                garr[togrid[i]:(togrid[i]+gridw),:] = background
+                garr[0,:] = background
+                garr[-1,:] = background
+            if (d == 1) & (idim == 2) & (grid_directions[d]):
+                garr[:,togrid[i]:(togrid[i]+gridw)] = background
+                garr[:,0] = background
+                garr[:,-1] = background
+
+
+    gimage = image.new_image_like(garr)
+
+    if (transform is not None) and (fixed_reference_image is not None):
+        return ants.apply_transforms( fixed=fixed_reference_image, moving=gimage,
+                               transformlist=transform ) 
+    else:
+        return gimage

MindEyeV2/antspy/ants/registration/fit_bspline_displacement_field.py

@@ -0,0 +1,202 @@
+__all__ = ["fit_bspline_displacement_field"]
+
+import numpy as np
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def fit_bspline_displacement_field(displacement_field=None,
+                                   displacement_weight_image=None,
+                                   displacement_origins=None,
+                                   displacements=None,
+                                   displacement_weights=None,
+                                   origin=None,
+                                   spacing=None,
+                                   size=None,
+                                   direction=None,
+                                   number_of_fitting_levels=4,
+                                   mesh_size=1,
+                                   spline_order=3,
+                                   enforce_stationary_boundary=True,
+                                   estimate_inverse=False,
+                                   rasterize_points=False):
+
+    """
+    Fit a b-spline object to a dense displacement field image and/or a set of points
+    with associated displacements and smooths them using B-splines.  The inverse
+    can also be estimated..  This is basically a wrapper for the ITK filter
+
+    https://itk.org/Doxygen/html/classitk_1_1DisplacementFieldToBSplineImageFilter.html}
+
+    which, in turn is a wrapper for the ITK filter used for the function
+    fit_bspline_object_to_scattered_data.
+
+    ANTsR function: `fitBsplineToDisplacementField`
+
+    Arguments
+    ---------
+    displacement_field : ANTs image
+        Input displacement field.  Either this and/or the points must be specified.
+
+    displacement_weight_image : ANTs image
+        Input image defining weighting of the voxelwise displacements in the displacement_field.  I
+        If None, defaults to identity weighting for each displacement.  Default = None.
+
+    displacement_origins : 2-D numpy array
+        Matrix (number_of_points x dimension) defining the origins of the input
+        displacement points.  Default = None.
+
+    displacements : 2-D numpy array
+        Matrix (number_of_points x dimension) defining the displacements of the input
+        displacement points.  Default = None.
+
+    displacement_weights : 1-D numpy array
+        Array defining the individual weighting of the corresponding scattered data value.
+        Default = None meaning all values are weighted the same.
+
+    origin : n-D tuple
+        Defines the physical origin of the B-spline object.
+
+    spacing : n-D tuple
+        Defines the physical spacing of the B-spline object.
+
+    size : n-D tuple
+       Defines the size (length) of the B-spline object.  Note that the length of the
+       B-spline object in dimension d is defined as
+       spacing[d] * size[d]-1.
+
+    direction : 2-D numpy array
+       Booleans defining whether or not the corresponding parametric dimension is
+       closed (e.g., closed loop).  Default = None.
+
+    number_of_fitting_levels : integer
+       Specifies the number of fitting levels.
+
+    mesh_size : n-D tuple
+       Defines the mesh size at the initial fitting level.
+
+    spline_order : integer
+       Spline order of the B-spline object.  Default = 3.
+
+    enforce_stationary_boundary : boolean
+       Ensure no displacements on the image boundary.  Default = True.
+
+    estimate_inverse : boolean
+       Estimate the inverse displacement field.  Default = False.
+
+    rasterize_points : boolean
+       Use nearest neighbor rasterization of points for estimating the
+       field (potential speed-up).  Default = False.
+
+    Returns
+    -------
+    Returns an ANTsImage.
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    >>> points = np.array([[-50, -50]])
+    >>> deltas = np.array([[10, 10]])
+    >>> bspline_field = ants.fit_bspline_displacement_field(
+    >>>   displacement_origins=points, displacements=deltas,
+    >>>   origin=[0.0, 0.0], spacing=[1.0, 1.0], size=[100, 100],
+    >>>   direction=np.array([[-1, 0], [0, -1]]),
+    >>>   number_of_fitting_levels=4, mesh_size=(1, 1))
+    """
+
+    if displacement_field is None and (displacement_origins is None or displacements is None):
+        raise ValueError("Missing input.  Either a displacement field or input point set (origins + displacements) needs to be specified.")
+
+    if displacement_field is None:
+        if origin is None or spacing is None or size is None or direction is None:
+            raise ValueError("If the displacement field is not specified, one must fully specify the input physical domain.")
+
+    if displacement_field is not None and displacement_weight_image is None:
+        displacement_weight_image = ants.make_image(displacement_field.shape, voxval=1,
+            spacing=displacement_field.spacing, origin=displacement_field.origin,
+            direction=displacement_field.direction, has_components=False, pixeltype='float')
+
+    if displacement_field is not None:
+        if origin is None:
+            origin = displacement_field.origin
+        if spacing is None:
+            spacing = displacement_field.spacing
+        if direction is None:
+            direction = displacement_field.direction
+        if size is None:
+            size = displacement_field.shape
+
+    dimensionality = None
+    if displacement_field is not None:
+        dimensionality = displacement_field.dimension
+    else:
+        dimensionality = displacement_origins.shape[1]
+        if displacements.shape[1] != dimensionality:
+            raise ValueError("Dimensionality between origins and displacements does not match.")
+
+    if displacement_origins is not None:
+        if displacement_weights is not None and (len(displacement_weights) != displacement_origins.shape[0]):
+            raise ValueError("Length of displacement weights must match the number of displacement points.")
+        else:
+            displacement_weights = np.ones(displacement_origins.shape[0])
+
+    if isinstance(mesh_size, int) == False and len(mesh_size) != dimensionality:
+        raise ValueError("Incorrect specification for mesh_size.")
+
+    if origin is not None and len(origin) != dimensionality:
+        raise ValueError("Origin is not of length dimensionality.")
+
+    if spacing is not None and len(spacing) != dimensionality:
+        raise ValueError("Spacing is not of length dimensionality.")
+
+    if size is not None and len(size) != dimensionality:
+        raise ValueError("Size is not of length dimensionality.")
+
+    if direction is not None and (direction.shape[0] != dimensionality and direction.shape[1] != dimensionality):
+        raise ValueError("Direction is not of shape dimensionality x dimensionality.")
+
+    # It would seem that pybind11 doesn't really play nicely when the
+    # arguments are 'None'
+
+    if origin is None:
+        origin = np.empty(0)
+
+    if spacing is None:
+        spacing = np.empty(0)
+
+    if size is None:
+        size = np.empty(0)
+
+    if direction is None:
+        direction = np.empty((0, 0))
+
+    if displacement_origins is None:
+        displacement_origins = np.empty((0, 0))
+        displacement_weights = np.empty(0)
+    else:
+        if displacement_weights is None:
+            displacement_weights = np.repeat(1.0, displacement_origins.shape[0])
+
+    number_of_control_points = list(np.array(mesh_size) + np.repeat(spline_order, dimensionality))
+
+    bspline_field = None
+    if displacement_field is not None:
+        libfn = get_lib_fn("fitBsplineDisplacementFieldD%i" % (dimensionality))
+        bspline_field = libfn(displacement_field.pointer, displacement_weight_image.pointer,
+                              displacement_origins, displacements, displacement_weights,
+                              origin, spacing, size, direction,
+                              number_of_fitting_levels, number_of_control_points, spline_order,
+                              enforce_stationary_boundary, estimate_inverse)
+    elif displacement_field is None and displacements is not None:
+        libfn = get_lib_fn("fitBsplineDisplacementFieldToScatteredDataD%i" % (dimensionality))
+        bspline_field = libfn(displacement_origins, displacements, displacement_weights,
+                              origin, spacing, size, direction,
+                              number_of_fitting_levels, number_of_control_points, spline_order,
+                              enforce_stationary_boundary, estimate_inverse, rasterize_points)
+
+
+    bspline_displacement_field = ants.from_pointer(bspline_field).clone('float')
+    return bspline_displacement_field
+

MindEyeV2/antspy/ants/registration/fit_bspline_object_to_scattered_data.py

@@ -0,0 +1,191 @@
+__all__ = ["fit_bspline_object_to_scattered_data"]
+
+import numpy as np
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def fit_bspline_object_to_scattered_data(scattered_data,
+                                         parametric_data,
+                                         parametric_domain_origin,
+                                         parametric_domain_spacing,
+                                         parametric_domain_size,
+                                         is_parametric_dimension_closed=None,
+                                         data_weights=None,
+                                         number_of_fitting_levels=4,
+                                         mesh_size=1,
+                                         spline_order=3):
+
+    """
+    Fit a b-spline object to scattered data.  This is basically a wrapper
+    for the ITK filter
+
+    https://itk.org/Doxygen/html/classitk_1_1BSplineScatteredDataPointSetToImageFilter.html
+
+    This filter is flexible in the possible objects that can be approximated.
+    Possibilities include:
+
+        * 1/2/3/4-D curve
+        * 2-D surface in 3-D space (not available/templated)
+        * 2/3/4-D scalar field
+        * 2/3-D displacement field
+        * 2/3-D time-varying velocity field
+
+    In order to understand the input parameters, it is important to understand
+    the difference between the parametric and data dimensions.  A curve as one
+    parametric dimension but the data dimension can be 1-D, 2-D, 3-D, or 4-D.
+    In contrast, a 3-D displacement field has a parametric and data dimension
+    of 3.  The scattered data is what's approximated by the B-spline object and
+    the parametric point is the location of scattered data within the domain of
+    the B-spline object.
+
+    ANTsR function: `fitBsplineObjectToScatteredData`
+
+    Arguments
+    ---------
+    scattered_data : 2-D numpy array
+        Defines the scattered data input to be approximated. Data is organized
+        by row --> data v, column ---> data dimension.
+
+    parametric_data : 2-D numpy array
+        Defines the parametric location of the scattered data.  Data is organized
+        by row --> parametric point, column --> parametric dimension.  Note that
+        each row corresponds to the same row in the scatteredData.
+
+    data_weights : 1-D numpy array
+        Defines the individual weighting of the corresponding scattered data value.
+        Default = None meaning all values are weighted the same.
+
+    parametric_domain_origin : n-D tuple
+        Defines the parametric origin of the B-spline object.
+
+    parametric_domain_spacing : n-D tuple
+        Defines the parametric spacing of the B-spline object.  Defines the sampling
+        rate in the parametric domain.
+
+    parametric_domain_size : n-D tuple
+       Defines the size (length) of the B-spline object.  Note that the length of the
+       B-spline object in dimension d is defined as
+       parametric_domain_spacing[d] * parametric_domain_size[d]-1.
+
+    is_parametric_dimension_closed : n-D tuple
+       Booleans defining whether or not the corresponding parametric dimension is
+       closed (e.g., closed loop).  Default = None.
+
+    number_of_fitting_levels : integer
+       Specifies the number of fitting levels.
+
+    mesh_size : n-D tuple
+       Defines the mesh size at the initial fitting level.
+
+    spline_order : integer
+       Spline order of the B-spline object.  Default = 3.
+
+    Returns
+    -------
+    returns numpy array for B-spline curve (parametric dimension = 1).  Otherwise,
+    returns an ANTsImage.
+
+    Example
+    -------
+    >>> # Perform 2-D curve example
+    >>>
+    >>> import ants, numpy
+    >>> import matplotlib.pyplot as plt
+    >>> x = numpy.linspace(-4, 4, num=100)
+    >>> y = numpy.exp(-numpy.multiply(x, x)) + numpy.random.uniform(-0.1, 0.1, len(x))
+    >>> u = numpy.linspace(0, 1.0, num=len(x))
+    >>> scattered_data = numpy.column_stack((x, y))
+    >>> parametric_data = numpy.expand_dims(u, axis=-1)
+    >>> spacing = 1/(len(x)-1) * 1.0;
+    >>> bspline_curve = ants.fit_bspline_object_to_scattered_data(scattered_data, 
+    >>>    parametric_data,
+    >>>   parametric_domain_origin=[0.0], parametric_domain_spacing=[spacing],
+    >>>   parametric_domain_size=[len(x)], is_parametric_dimension_closed=None,
+    >>>   number_of_fitting_levels=5, mesh_size=1)
+    >>> plt.plot(x, y, label='Noisy points')
+    >>> plt.plot(bspline_curve[:,0], bspline_curve[:,1], label='B-spline curve')
+    >>> plt.grid(True)
+    >>> plt.axis('tight')
+    >>> plt.legend(loc='upper left')
+    >>> plt.show()
+    >>>
+    >>> ###########################################################################
+    >>>
+    >>> # Perform 2-D scalar field (i.e., image) example
+    >>>
+    >>> import ants, numpy
+    >>> number_of_random_points = 10000
+    >>> img = ants.image_read( ants.get_ants_data("r16"))
+    >>> img_array = img.numpy()
+    >>> row_indices = numpy.random.choice(range(2, img_array.shape[0]), number_of_random_points)
+    >>> col_indices = numpy.random.choice(range(2, img_array.shape[1]), number_of_random_points)
+    >>> scattered_data = numpy.zeros((number_of_random_points, 1))
+    >>> parametric_data = numpy.zeros((number_of_random_points, 2))
+    >>> for i in range(number_of_random_points):
+    >>>     scattered_data[i,0] = img_array[row_indices[i], col_indices[i]]
+    >>>     parametric_data[i,0] = row_indices[i]
+    >>>     parametric_data[i,1] = col_indices[i]
+    >>> bspline_img = ants.fit_bspline_object_to_scattered_data(
+    >>>     scattered_data, parametric_data,
+    >>>     parametric_domain_origin=[0.0, 0.0],
+    >>>     parametric_domain_spacing=[1.0, 1.0],
+    >>>     parametric_domain_size = img.shape,
+    >>>     number_of_fitting_levels=7, mesh_size=1)
+    >>>
+    >>> ants.plot(img, title="Original")
+    >>> ants.plot(bspline_img, title="B-spline approximation")
+    """
+
+    parametric_dimension = parametric_data.shape[1]
+    data_dimension = scattered_data.shape[1]
+
+    if is_parametric_dimension_closed is None:
+        is_parametric_dimension_closed = np.repeat(False, parametric_dimension)
+
+    if isinstance(mesh_size, int) == False and len(mesh_size) != parametric_dimension:
+        raise ValueError("Incorrect specification for mesh_size.")
+
+    if len(parametric_domain_origin) != parametric_dimension:
+        raise ValueError("Origin is not of length parametric_dimension.")
+
+    if len(parametric_domain_spacing) != parametric_dimension:
+        raise ValueError("Spacing is not of length parametric_dimension.")
+
+    if len(parametric_domain_size) != parametric_dimension:
+        raise ValueError("Size is not of length parametric_dimension.")
+
+    if len(is_parametric_dimension_closed) != parametric_dimension:
+        raise ValueError("Closed is not of length parametric_dimension.")
+
+    number_of_control_points = mesh_size + spline_order
+
+    if isinstance(number_of_control_points, int) == True:
+        number_of_control_points = np.repeat(number_of_control_points, parametric_dimension)
+
+    if parametric_data.shape[0] != scattered_data.shape[0]:
+        raise ValueError("The number of points is not equal to the number of scattered data values.")
+
+    if data_weights is None:
+        data_weights = np.repeat(1.0, parametric_data.shape[0])
+    
+    if data_weights.ndim == 2:
+        data_weights = np.squeeze(data_weights)
+
+    if len(data_weights) != parametric_data.shape[0]:
+        raise ValueError("The number of weights is not the same as the number of points.")
+
+    libfn = get_lib_fn("fitBsplineObjectToScatteredDataP%iD%i" % (parametric_dimension, data_dimension))
+    bspline_object = libfn(scattered_data.tolist(), parametric_data.tolist(), data_weights.tolist(),
+                           parametric_domain_origin, parametric_domain_spacing,
+                           parametric_domain_size, is_parametric_dimension_closed.tolist(),
+                           number_of_fitting_levels, number_of_control_points.tolist(),
+                           spline_order)
+
+    if parametric_dimension == 1:
+        return np.array(bspline_object)
+    else:
+        bspline_image = ants.from_pointer(bspline_object).clone('float')
+        return bspline_image
+

MindEyeV2/antspy/ants/registration/fit_thin_plate_spline_displacement_field.py

@@ -0,0 +1,105 @@
+__all__ = ["fit_thin_plate_spline_displacement_field"]
+
+import numpy as np
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def fit_thin_plate_spline_displacement_field(displacement_origins=None,
+                                             displacements=None,
+                                             origin=None,
+                                             spacing=None,
+                                             size=None,
+                                             direction=None):
+
+    """
+    Fit a thin-plate spline object to a a set of points with associated displacements.  
+    This is basically a wrapper for the ITK filter
+
+    https://itk.org/Doxygen/html/itkThinPlateSplineKernelTransform_8h.html
+
+    ANTsR function: `fitThinPlateSplineToDisplacementField`
+
+    Arguments
+    ---------
+
+    displacement_origins : 2-D numpy array
+        Matrix (number_of_points x dimension) defining the origins of the input
+        displacement points.  Default = None.
+
+    displacements : 2-D numpy array
+        Matrix (number_of_points x dimension) defining the displacements of the input
+        displacement points.  Default = None.
+
+    origin : n-D tuple
+        Defines the physical origin of the B-spline object.
+
+    spacing : n-D tuple
+        Defines the physical spacing of the B-spline object.
+
+    size : n-D tuple
+       Defines the size (length) of the spline object.  Note that the length of the
+       spline object in dimension d is defined as spacing[d] * size[d]-1.
+
+    direction : 2-D numpy array
+       Booleans defining whether or not the corresponding parametric dimension is
+       closed (e.g., closed loop).  Default = None.
+
+    Returns
+    -------
+    Returns an ANTsImage.
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    >>> points = np.array([[-50, -50]])
+    >>> deltas = np.array([[10, 10]])
+    >>> tps_field = ants.fit_thin_plate_spline_displacement_field(
+    >>>   displacement_origins=points, displacements=deltas,
+    >>>   origin=[0.0, 0.0], spacing=[1.0, 1.0], size=[100, 100],
+    >>>   direction=np.array([[-1, 0], [0, -1]]))
+    """
+
+    dimensionality = displacement_origins.shape[1]
+    if displacements.shape[1] != dimensionality:
+        raise ValueError("Dimensionality between origins and displacements does not match.")
+
+    if displacement_origins is None or displacement_origins is None:
+        raise ValueError("Missing input.  Input point set (origins + displacements) needs to be specified." )
+
+    if origin is not None and len(origin) != dimensionality:
+        raise ValueError("Origin is not of length dimensionality.")
+
+    if spacing is not None and len(spacing) != dimensionality:
+        raise ValueError("Spacing is not of length dimensionality.")
+
+    if size is not None and len(size) != dimensionality:
+        raise ValueError("Size is not of length dimensionality.")
+
+    if direction is not None and (direction.shape[0] != dimensionality and direction.shape[1] != dimensionality):
+        raise ValueError("Direction is not of shape dimensionality x dimensionality.")
+
+    # It would seem that pybind11 doesn't really play nicely when the
+    # arguments are 'None'
+
+    if origin is None:
+        origin = np.empty(0)
+
+    if spacing is None:
+        spacing = np.empty(0)
+
+    if size is None:
+        size = np.empty(0)
+
+    if direction is None:
+        direction = np.empty((0, 0))
+
+    tps_field = None
+    libfn = get_lib_fn("fitThinPlateSplineDisplacementFieldToScatteredDataD%i" % (dimensionality))
+    tps_field = libfn(displacement_origins, displacements, origin, spacing, size, direction)
+
+    tps_displacement_field = ants.from_pointer(tps_field).clone('float')
+    return tps_displacement_field
+

MindEyeV2/antspy/ants/registration/integrate_velocity_field.py

@@ -0,0 +1,48 @@
+
+__all__ = ['integrate_velocity_field']
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def integrate_velocity_field(velocity_field,
+                             lower_integration_bound=0.0,
+                             upper_integration_bound=1.0,
+                             number_of_integration_steps=10):
+    """
+    Integrate velocity field.
+
+    Arguments
+    ---------
+    velocity_field : ANTsImage velocity field
+        time-varying displacement field
+
+    lower_integration_bound: float
+        Lower time bound for integration in [0, 1]
+
+    upper_integration_bound: float
+        Upper time bound for integration in [0, 1]
+
+    number_of_integation_steps: integer
+        Number of integration steps used in the Runge-Kutta solution
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read( ants.get_data( "r16" ) )
+    >>> mi = ants.image_read( ants.get_data( "r27" ) )
+    >>> reg = ants.registration(fi, mi, "TV[2]")
+    >>> velocity_field = ants.image_read(reg['velocityfield'][0])
+    >>> field = ants.integrate_velocity_field(velocity_field, 0.0, 1.0, 10) 
+    >>> temp=ants.apply_ants_transform_to_image( 
+	    ants.transform_from_displacement_field( field ), mi, fi )
+    """
+
+    libfn = get_lib_fn('integrateVelocityFieldD%i' % (velocity_field.dimension-1))
+    integrated_field = libfn(velocity_field.pointer, lower_integration_bound,
+        upper_integration_bound, number_of_integration_steps)
+
+    new_image = ants.from_pointer(integrated_field).clone('float')
+    return new_image
+
+

MindEyeV2/antspy/ants/registration/invert_displacement_field.py

@@ -0,0 +1,51 @@
+
+__all__ = ['invert_displacement_field']
+
+import ants
+from ants.internal import get_lib_fn
+
+
+def invert_displacement_field(displacement_field, 
+                              inverse_field_initial_estimate, 
+                              maximum_number_of_iterations=20, 
+                              mean_error_tolerance_threshold=0.001, 
+                              max_error_tolerance_threshold=0.1,
+                              enforce_boundary_condition=True):
+    """
+    Invert displacement field.
+
+    Arguments
+    ---------
+    displacement_field : ANTsImage displacement field
+        displacement field
+
+    inverse_field_initial_estimate : ANTsImage displacement field
+        initial guess
+
+    maximum_number_of_iterations : integer
+        number of iterations
+
+    mean_error_tolerance_threshold : float
+        mean error tolerance threshold
+
+    max_error_tolerance_threshold : float
+        max error tolerance threshold
+
+    enforce_boundary_condition : bool
+        enforce stationary boundary condition
+        
+
+    Example
+    -------
+    >>> import ants
+    """
+
+    libfn = get_lib_fn('invertDisplacementFieldD%i' % displacement_field.dimension)
+    inverse_field = libfn(displacement_field.pointer, inverse_field_initial_estimate.pointer, 
+        maximum_number_of_iterations, mean_error_tolerance_threshold, 
+        max_error_tolerance_threshold, enforce_boundary_condition)
+
+    new_image = ants.from_pointer(inverse_field).clone('float')
+    return new_image
+
+

MindEyeV2/antspy/ants/registration/landmark_transforms.py

@@ -0,0 +1,843 @@
+__all__ = ["fit_transform_to_paired_points", 
+           "fit_time_varying_transform_to_point_sets"]
+
+import numpy as np
+import math
+import time
+
+import ants
+
+def convergence_monitoring(values, window_size=10):
+     if len(values) >= window_size:
+         u = np.linspace(0.0, 1.0, num=window_size)
+         scattered_data = np.expand_dims(values[-window_size:], axis=-1)
+         parametric_data = np.expand_dims(u, axis=-1)
+         spacing = 1 / (window_size-1)
+         bspline_line = ants.fit_bspline_object_to_scattered_data(scattered_data, parametric_data,
+             parametric_domain_origin=[0.0], parametric_domain_spacing=[spacing],
+             parametric_domain_size=[window_size], number_of_fitting_levels=1, mesh_size=1,
+             spline_order=1)
+         bspline_slope = -(bspline_line[1][0] - bspline_line[0][0]) / spacing
+         return(bspline_slope)
+     else:
+         return None
+
+
+def fit_transform_to_paired_points(moving_points,
+                                   fixed_points,
+                                   transform_type="affine",
+                                   regularization=1e-6,
+                                   domain_image=None,
+                                   number_of_fitting_levels=4,
+                                   mesh_size=1,
+                                   spline_order=3,
+                                   enforce_stationary_boundary=True,
+                                   displacement_weights=None,
+                                   number_of_compositions=10,
+                                   composition_step_size=0.5,
+                                   sigma=0.0,
+                                   convergence_threshold=1e-6,
+                                   number_of_time_steps=2,
+                                   number_of_integration_steps=100,
+                                   rasterize_points=False,
+                                   verbose=False
+                                  ):
+    """
+    Estimate a transform from corresponding fixed and moving landmarks.
+
+    ANTsR function: fitTransformToPairedPoints
+
+    Arguments
+    ---------
+    moving_points : array
+        Moving points specified in physical space as a n x d matrix where n is the number
+        of points and d is the dimensionality.
+
+    fixed_points : array
+        Fixed points specified in physical space as a n x d matrix where n is the number
+        of points and d is the dimensionality.
+
+    transform_type : character
+        'rigid', 'similarity', "affine', 'bspline', 'tps', 'diffeo', 'syn', or 'time-varying (tv)'.
+
+    regularization : scalar
+        Ridge penalty in [0,1] for linear transforms.
+
+    domain_image : ANTs image
+        Defines physical domain of the nonlinear transform.  Must be defined for nonlinear
+        transforms.
+
+    number_of_fitting_levels : integer
+        Integer specifying the number of fitting levels for the B-spline interpolation of the
+        displacement field.
+
+    mesh_size : integer or array
+        Defines the mesh size at the initial fitting level for the B-spline interpolation of the
+        displacement field.
+
+    spline_order : integer
+        Spline order of the B-spline displacement field.
+
+    enforce_stationary_boundary : boolean
+        Ensure no displacements on the image boundary (B-spline only).
+
+    displacement_weights : array
+        Defines the individual weighting of the corresponding scattered data value.  Default = NULL
+        meaning all displacements are weighted the same.
+
+    number_of_compositions : integer
+        Total number of compositions for the diffeomorphic transforms.
+
+    composition_step_size : scalar
+        Scalar multiplication factor of the weighting of the update field for the diffeomorphic transforms.
+
+    sigma : scalar
+        Gaussian smoothing standard deviation of the update field (in mm).
+
+    convergence_threshold : scalar
+        Composition-based convergence parameter for the diff. transforms using a
+        window size of 10 values.
+
+    number_of_time_steps : integer
+        Time-varying velocity field parameter.
+
+    number_of_integration_steps : scalar
+        Number of steps used for integrating the velocity field.
+
+    rasterize_points : boolean
+       Use nearest neighbor rasterization of points for estimating the update
+       field (potential speed-up).  Default = False.
+
+    verbose : bool
+        Print progress to the screen.
+
+    Returns
+    -------
+
+    ANTs transform
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    >>> fixed = np.array([[50.0,50.0],[200.0,50.0],[200.0,200.0]])
+    >>> moving = np.array([[50.0,50.0],[50.0,200.0],[200.0,200.0]])
+    >>> xfrm = ants.fit_transform_to_paired_points(moving, fixed, transform_type="affine")
+    >>> xfrm = ants.fit_transform_to_paired_points(moving, fixed, transform_type="rigid")
+    >>> xfrm = ants.fit_transform_to_paired_points(moving, fixed, transform_type="similarity")
+    >>> domain_image = ants.image_read(ants.get_ants_data("r16"))
+    >>> xfrm = ants.fit_transform_to_paired_points(moving, fixed, transform_type="bspline", domain_image=domain_image, number_of_fitting_levels=5)
+    >>> xfrm = ants.fit_transform_to_paired_points(moving, fixed, transform_type="diffeo", domain_image=domain_image, number_of_fitting_levels=6)
+    """
+
+    def polar_decomposition(X):
+         U, d, V = np.linalg.svd(X, full_matrices=False)
+         P = np.matmul(U, np.matmul(np.diag(d), np.transpose(U)))
+         Z = np.matmul(U, V)
+         if np.linalg.det(Z) < 0:
+             n = X.shape[0]
+             reflection_matrix = np.identity(n)
+             reflection_matrix[0,0] = -1.0
+             Z = np.matmul(Z, reflection_matrix)
+         return({"P" : P, "Z" : Z, "Xtilde" : np.matmul(P, Z)})
+
+    def create_zero_displacement_field(domain_image):
+         field_array = np.zeros((*domain_image.shape, domain_image.dimension))
+         field = ants.from_numpy(field_array, origin=domain_image.origin,
+                 spacing=domain_image.spacing, direction=domain_image.direction,
+                 has_components=True)
+         return(field)
+
+    def create_zero_velocity_field(domain_image, number_of_time_points=2):
+         field_array = np.zeros((*domain_image.shape, number_of_time_points, domain_image.dimension))
+         origin = (*domain_image.origin, 0.0)
+         spacing = (*domain_image.spacing, 1.0)
+         direction = np.eye(domain_image.dimension + 1)
+         direction[0:domain_image.dimension,0:domain_image.dimension] = domain_image.direction
+         field = ants.from_numpy(field_array, origin=origin, spacing=spacing, direction=direction,
+                 has_components=True)
+         return(field)
+
+    allowed_transforms = ['rigid', 'affine', 'similarity', 'bspline', 'tps', 'diffeo', 'syn', 'tv', 'time-varying']
+    if not transform_type.lower() in allowed_transforms:
+        raise ValueError(transform_type + " transform not supported.")
+
+    transform_type = transform_type.lower()
+
+    if domain_image is None and transform_type in ['bspline', 'tps', 'diffeo', 'syn', 'tv', 'time-varying']:
+        raise ValueError("Domain image needs to be specified.")
+
+    if not fixed_points.shape == moving_points.shape:
+        raise ValueError("Mismatch in the size of the point sets.")
+
+    if regularization > 1:
+        regularization = 1
+    elif regularization < 0:
+        regularization = 0
+
+    number_of_points = fixed_points.shape[0]
+    dimensionality = fixed_points.shape[1]
+
+    if transform_type in ['rigid', 'affine', 'similarity']:
+        center_fixed = fixed_points.mean(axis=0)
+        center_moving = moving_points.mean(axis=0)
+
+        x = fixed_points - center_fixed
+        y = moving_points - center_moving
+
+        y_prior = np.concatenate((y, np.ones((number_of_points, 1))), axis=1)
+
+        x11 = np.concatenate((x, np.ones((number_of_points, 1))), axis=1)
+        M = x11 * (1.0 - regularization) + regularization * y_prior
+        Minv = np.linalg.lstsq(M, y, rcond=None)[0]
+
+        p = polar_decomposition(Minv[0:dimensionality, 0:dimensionality].T)
+        A = p['Xtilde']
+        translation = Minv[dimensionality,:] + center_moving - center_fixed
+
+        if transform_type in ['rigid', 'similarity']:
+            # Kabsch algorithm
+            #    http://web.stanford.edu/class/cs273/refs/umeyama.pdf
+
+            C = np.dot(y.T, x)
+            x_svd = np.linalg.svd(C * (1.0 - regularization) + np.eye(dimensionality) * regularization)
+            x_det = np.linalg.det(np.dot(x_svd[0], x_svd[2]))
+
+            if x_det < 0:
+                x_svd[2][dimensionality-1, :] *= -1
+
+            A = np.dot(x_svd[0], x_svd[2])
+
+            if transform_type == 'similarity':
+                scaling = (math.sqrt((np.power(y, 2).sum(axis=1) / number_of_points).mean()) /
+                           math.sqrt((np.power(x, 2).sum(axis=1) / number_of_points).mean()))
+                A = np.dot(A, np.eye(dimensionality) * scaling)
+
+        xfrm = ants.create_ants_transform(matrix=A, translation=translation,
+              dimension=dimensionality, center=center_fixed)
+
+        return xfrm
+
+    elif transform_type == "bspline":
+
+        bspline_displacement_field = ants.fit_bspline_displacement_field(
+            displacement_origins=fixed_points,
+            displacements=moving_points - fixed_points,
+            displacement_weights=displacement_weights,
+            origin=domain_image.origin,
+            spacing=domain_image.spacing,
+            size=domain_image.shape,
+            direction=domain_image.direction,
+            number_of_fitting_levels=number_of_fitting_levels,
+            mesh_size=mesh_size,
+            spline_order=spline_order,
+            enforce_stationary_boundary=enforce_stationary_boundary,
+            rasterize_points=rasterize_points)
+
+        xfrm = ants.transform_from_displacement_field(bspline_displacement_field)
+
+        return xfrm
+
+    elif transform_type == "tps":
+
+        tps_displacement_field = ants.fit_thin_plate_spline_displacement_field(
+            displacement_origins=fixed_points,
+            displacements=moving_points - fixed_points,
+            origin=domain_image.origin,
+            spacing=domain_image.spacing,
+            size=domain_image.shape,
+            direction=domain_image.direction)
+
+        xfrm = ants.transform_from_displacement_field(tps_displacement_field)
+
+        return xfrm
+
+    elif transform_type == "diffeo":
+
+        if verbose:
+            start_total_time = time.time()
+
+        updated_fixed_points = np.empty_like(fixed_points)
+        updated_fixed_points[:] = fixed_points
+
+        total_field = create_zero_displacement_field(domain_image)
+        total_field_xfrm = None
+
+        error_values = []
+        for i in range(number_of_compositions):
+
+            if verbose:
+                start_time = time.time()
+
+            update_field = ants.fit_bspline_displacement_field(
+              displacement_origins=updated_fixed_points,
+              displacements=moving_points - updated_fixed_points,
+              displacement_weights=displacement_weights,
+              origin=domain_image.origin,
+              spacing=domain_image.spacing,
+              size=domain_image.shape,
+              direction=domain_image.direction,
+              number_of_fitting_levels=number_of_fitting_levels,
+              mesh_size=mesh_size,
+              spline_order=spline_order,
+              enforce_stationary_boundary=True,
+              rasterize_points=rasterize_points
+            )
+
+            update_field = update_field * composition_step_size
+            if sigma > 0:
+                update_field = ants.smooth_image(update_field, sigma)
+
+            total_field = ants.compose_displacement_fields(update_field, total_field)
+            total_field_xfrm = ants.transform_from_displacement_field(total_field)
+
+            if i < number_of_compositions - 1:
+                for j in range(updated_fixed_points.shape[0]):
+                    updated_fixed_points[j,:] = total_field_xfrm.apply_to_point(tuple(fixed_points[j,:]))
+
+            error_values.append(np.mean(np.sqrt(np.sum(np.square(updated_fixed_points - moving_points), axis=1, keepdims=True))))
+            convergence_value = convergence_monitoring(error_values)
+            if verbose:
+                end_time = time.time()
+                diff_time = end_time - start_time
+                print("Composition " + str(i) + ": error = " + str(error_values[-1]) +
+                      " (convergence = " + str(convergence_value) + ", elapsed time = " + str(diff_time) + ")")
+            if not convergence_value is None and convergence_value <= convergence_threshold:
+                break
+
+        if verbose:
+            end_total_time = time.time()
+            diff_total_time = end_total_time - start_total_time
+            print("Total elapsed time = " + str(diff_total_time) + ".")
+
+        return(total_field_xfrm)
+
+    elif transform_type == "syn":
+
+        if verbose:
+            start_total_time = time.time()
+
+        updated_fixed_points = np.empty_like(fixed_points)
+        updated_fixed_points[:] = fixed_points
+        updated_moving_points = np.empty_like(moving_points)
+        updated_moving_points[:] = moving_points
+
+        total_field_fixed_to_middle = create_zero_displacement_field(domain_image)
+        total_inverse_field_fixed_to_middle = create_zero_displacement_field(domain_image)
+
+        total_field_moving_to_middle = create_zero_displacement_field(domain_image)
+        total_inverse_field_moving_to_middle = create_zero_displacement_field(domain_image)
+
+        error_values = []
+        for i in range(number_of_compositions):
+
+            if verbose:
+                start_time = time.time()
+
+            update_field_fixed_to_middle = ants.fit_bspline_displacement_field(
+              displacement_origins=updated_fixed_points,
+              displacements=updated_moving_points - updated_fixed_points,
+              displacement_weights=displacement_weights,
+              origin=domain_image.origin,
+              spacing=domain_image.spacing,
+              size=domain_image.shape,
+              direction=domain_image.direction,
+              number_of_fitting_levels=number_of_fitting_levels,
+              mesh_size=mesh_size,
+              spline_order=spline_order,
+              enforce_stationary_boundary=True,
+              rasterize_points=rasterize_points
+            )
+
+            update_field_moving_to_middle = ants.fit_bspline_displacement_field(
+              displacement_origins=updated_moving_points,
+              displacements=updated_fixed_points - updated_moving_points,
+              displacement_weights=displacement_weights,
+              origin=domain_image.origin,
+              spacing=domain_image.spacing,
+              size=domain_image.shape,
+              direction=domain_image.direction,
+              number_of_fitting_levels=number_of_fitting_levels,
+              mesh_size=mesh_size,
+              spline_order=spline_order,
+              enforce_stationary_boundary=True,
+              rasterize_points=rasterize_points
+            )
+
+            update_field_fixed_to_middle = update_field_fixed_to_middle * composition_step_size
+            update_field_moving_to_middle = update_field_moving_to_middle * composition_step_size
+            if sigma > 0:
+                update_field_fixed_to_middle = ants.smooth_image(update_field_fixed_to_middle, sigma)
+                update_field_moving_to_middle = ants.smooth_image(update_field_moving_to_middle, sigma)
+
+            # Add the update field to both forward displacement fields.
+
+            total_field_fixed_to_middle = ants.compose_displacement_fields(update_field_fixed_to_middle, total_field_fixed_to_middle)
+            total_field_moving_to_middle = ants.compose_displacement_fields(update_field_moving_to_middle, total_field_moving_to_middle)
+
+            # Iteratively estimate the inverse fields.
+
+            total_inverse_field_fixed_to_middle = ants.invert_displacement_field(total_field_fixed_to_middle, total_inverse_field_fixed_to_middle)
+            total_inverse_field_moving_to_middle = ants.invert_displacement_field(total_field_moving_to_middle, total_inverse_field_moving_to_middle)
+
+            total_field_fixed_to_middle = ants.invert_displacement_field(total_inverse_field_fixed_to_middle, total_field_fixed_to_middle)
+            total_field_moving_to_middle = ants.invert_displacement_field(total_inverse_field_moving_to_middle, total_field_moving_to_middle)
+
+            total_field_fixed_to_middle_xfrm = ants.transform_from_displacement_field(total_field_fixed_to_middle)
+            total_field_moving_to_middle_xfrm = ants.transform_from_displacement_field(total_field_moving_to_middle)
+
+            total_inverse_field_fixed_to_middle_xfrm = ants.transform_from_displacement_field(total_inverse_field_fixed_to_middle)
+            total_inverse_field_moving_to_middle_xfrm = ants.transform_from_displacement_field(total_inverse_field_moving_to_middle)
+
+            if i < number_of_compositions - 1:
+                for j in range(updated_fixed_points.shape[0]):
+                    updated_fixed_points[j,:] = total_field_fixed_to_middle_xfrm.apply_to_point(tuple(fixed_points[j,:]))
+                    updated_moving_points[j,:] = total_field_moving_to_middle_xfrm.apply_to_point(tuple(moving_points[j,:]))
+
+            error_values.append(np.mean(np.sqrt(np.sum(np.square(updated_fixed_points - updated_moving_points), axis=1, keepdims=True))))
+            convergence_value = convergence_monitoring(error_values)
+            if verbose:
+                end_time = time.time()
+                diff_time = end_time - start_time
+                print("Composition " + str(i) + ": error = " + str(error_values[-1]) +
+                      " (convergence = " + str(convergence_value) + ", elapsed time = " + str(diff_time) + ")")
+            if not convergence_value is None and convergence_value <= convergence_threshold:
+                break
+
+        total_forward_field = ants.compose_displacement_fields(total_inverse_field_moving_to_middle, total_field_fixed_to_middle)
+        total_forward_xfrm = ants.transform_from_displacement_field(total_forward_field)
+        total_inverse_field = ants.compose_displacement_fields(total_inverse_field_fixed_to_middle, total_field_moving_to_middle)
+        total_inverse_xfrm = ants.transform_from_displacement_field(total_inverse_field)
+
+        if verbose:
+            end_total_time = time.time()
+            diff_total_time = end_total_time - start_total_time
+            print("Total elapsed time = " + str(diff_total_time) + ".")
+
+        return_dict = {'forward_transform' : total_forward_xfrm,
+                       'inverse_transform' : total_inverse_xfrm,
+                       'fixed_to_middle_transform' : total_field_fixed_to_middle_xfrm,
+                       'middle_to_fixed_transform' : total_inverse_field_fixed_to_middle_xfrm,
+                       'moving_to_middle_transform' : total_field_moving_to_middle_xfrm,
+                       'middle_to_moving_transform' : total_inverse_field_moving_to_middle_xfrm
+                       }
+        return(return_dict)
+
+    elif transform_type == "tv" or transform_type == "time-varying":
+
+        if verbose:
+            start_total_time = time.time()
+
+        updated_fixed_points = np.empty_like(fixed_points)
+        updated_fixed_points[:] = fixed_points
+        updated_moving_points = np.empty_like(moving_points)
+        updated_moving_points[:] = moving_points
+
+        velocity_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+        velocity_field_array = velocity_field.numpy()
+
+        last_update_derivative_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+        last_update_derivative_field_array = last_update_derivative_field.numpy()
+
+        error_values = []
+        for i in range(number_of_compositions):
+
+            if verbose:
+                start_time = time.time()
+
+            update_derivative_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+            update_derivative_field_array = update_derivative_field.numpy()
+
+            average_error = 0.0
+            for n in range(number_of_time_steps):
+
+                t = n / (number_of_time_steps - 1.0)
+
+                if n > 0:
+                    integrated_forward_field = ants.integrate_velocity_field(velocity_field, 0.0, t, number_of_integration_steps)
+                    integrated_forward_field_xfrm = ants.transform_from_displacement_field(integrated_forward_field)
+                    for j in range(updated_fixed_points.shape[0]):
+                        updated_fixed_points[j,:] = integrated_forward_field_xfrm.apply_to_point(tuple(fixed_points[j,:]))
+                else:
+                    updated_fixed_points[:] = fixed_points
+
+                if n < number_of_time_steps - 1:
+                    integrated_inverse_field = ants.integrate_velocity_field(velocity_field, 1.0, t, number_of_integration_steps)
+                    integrated_inverse_field_xfrm = ants.transform_from_displacement_field(integrated_inverse_field)
+                    for j in range(updated_moving_points.shape[0]):
+                        updated_moving_points[j,:] = integrated_inverse_field_xfrm.apply_to_point(tuple(moving_points[j,:]))
+                else:
+                    updated_moving_points[:] = moving_points
+
+                update_derivative_field_at_timepoint = ants.fit_bspline_displacement_field(
+                  displacement_origins=updated_fixed_points,
+                  displacements=updated_moving_points - updated_fixed_points,
+                  displacement_weights=displacement_weights,
+                  origin=domain_image.origin,
+                  spacing=domain_image.spacing,
+                  size=domain_image.shape,
+                  direction=domain_image.direction,
+                  number_of_fitting_levels=number_of_fitting_levels,
+                  mesh_size=mesh_size,
+                  spline_order=spline_order,
+                  enforce_stationary_boundary=True,
+                  rasterize_points=rasterize_points
+                  )
+
+                if sigma > 0:
+                    update_derivative_field_at_timepoint = ants.smooth_image(update_derivative_field_at_timepoint, sigma)
+
+                update_derivative_field_at_timepoint_array = update_derivative_field_at_timepoint.numpy()
+                grad_norms = np.sqrt(np.sum(np.square(update_derivative_field_at_timepoint_array), axis=-1, keepdims=False))
+                max_norm = np.amax(grad_norms)
+                median_norm = np.median(grad_norms)
+                if verbose:
+                    print("  integration point " + str(t) + ": max_norm = " + str(max_norm) + ", median_norm = " + str(median_norm))
+                update_derivative_field_at_timepoint_array /= max_norm
+                if domain_image.dimension == 2:
+                    update_derivative_field_array[:,:,n,:] = update_derivative_field_at_timepoint_array
+                elif domain_image.dimension == 3:
+                    update_derivative_field_array[:,:,:,n,:] = update_derivative_field_at_timepoint_array
+
+                rmse = np.mean(np.sqrt(np.sum(np.square(updated_moving_points - updated_fixed_points), axis=1, keepdims=True)))
+                average_error = (average_error * n + rmse) / (n + 1)
+
+            update_derivative_field_array = (update_derivative_field_array + last_update_derivative_field_array) * 0.5
+            last_update_derivative_field_array = np.empty_like(update_derivative_field_array)
+            last_update_derivative_field_array[:] = update_derivative_field_array
+
+            velocity_field_array = velocity_field_array + update_derivative_field_array * composition_step_size
+            velocity_field = ants.from_numpy(velocity_field_array, origin=velocity_field.origin,
+                                             spacing=velocity_field.spacing, direction=velocity_field.direction,
+                                             has_components=True)
+
+            error_values.append(average_error)
+            convergence_value = convergence_monitoring(error_values)
+            if verbose:
+                end_time = time.time()
+                diff_time = end_time - start_time
+                print("Composition " + str(i) + ": error = " + str(error_values[-1]) +
+                      " (convergence = " + str(convergence_value) + ", elapsed time = " + str(diff_time) + ")")
+            if not convergence_value is None and convergence_value <= convergence_threshold:
+                break
+
+        forward_xfrm = ants.transform_from_displacement_field(ants.integrate_velocity_field(velocity_field, 0.0, 1.0, number_of_integration_steps))
+        inverse_xfrm = ants.transform_from_displacement_field(ants.integrate_velocity_field(velocity_field, 1.0, 0.0, number_of_integration_steps))
+
+        if verbose:
+            end_total_time = time.time()
+            diff_total_time = end_total_time - start_total_time
+            print("Total elapsed time = " + str(diff_total_time) + ".")
+
+        return_dict = {'forward_transform': forward_xfrm,
+                       'inverse_transform': inverse_xfrm,
+                       'velocity_field': velocity_field}
+        return(return_dict)
+
+    else:
+        raise ValueError("Unrecognized transform_type.")
+
+
+def fit_time_varying_transform_to_point_sets(point_sets,
+                                             time_points=None,
+                                             initial_velocity_field=None,
+                                             number_of_time_steps=None,
+                                             domain_image=None,
+                                             number_of_fitting_levels=4,
+                                             mesh_size=1,
+                                             spline_order=3,
+                                             displacement_weights=None,
+                                             number_of_compositions=10,
+                                             composition_step_size=0.5,
+                                             number_of_integration_steps=100,
+                                             sigma=0.0,
+                                             convergence_threshold=1e-6,
+                                             rasterize_points=False,
+                                             verbose=False
+                                            ):
+    """
+
+    Estimate a time-varying transform from corresponding point sets (> 2).
+
+    ANTsR function: fitTimeVaryingTransformToPointSets
+
+    Arguments
+    ---------
+    point_sets : list of arrays
+        Corresponding points across sets specified in physical space as a n x d matrix where n
+        is the number of points and d is the dimensionality.
+
+    time_points : array of ordered scalars between 0 and 1
+        Set of scalar values, one for each point-set, designating its time position in the velocity
+        flow.  If not set, it defaults to equal spacing between 0 and 1.
+
+    initial_velocity_field : initial ANTs velocity field
+        Optional velocity field for initializing optimization.  Overrides the number of integration
+        points.
+
+    number_of_time_steps : integer
+        Time-varying velocity field parameter.  Needs to be equal to or greater than the number of
+        point sets.  If not specified, it defaults to the number of point sets.
+
+    domain_image : ANTs image
+        Defines physical domain of the nonlinear transform.  Must be defined.
+
+    number_of_fitting_levels : integer
+        Integer specifying the number of fitting levels for the B-spline interpolation of the
+        displacement field.
+
+    mesh_size : integer or array
+        Defines the mesh size at the initial fitting level for the B-spline interpolation of the
+        displacement field..
+
+    spline_order : integer
+        Spline order of the B-spline displacement field.
+
+    displacement_weights : array
+        Defines the individual weighting of the corresponding scattered data value.  Default = NULL
+        meaning all displacements are weighted the same.
+
+    number_of_compositions : integer
+        Total number of compositions.
+
+    composition_step_size : scalar
+        Scalar multiplication factor of the weighting of the update field.
+
+    number_of_integration_steps : scalar
+        Number of steps used for integrating the velocity field.
+
+    sigma : scalar
+        Gaussian smoothing standard deviation of the update field (in mm).
+
+    convergence_threshold : scalar
+        Composition-based convergence parameter using a window size of 10 values.
+
+    rasterize_points : boolean
+        Use nearest neighbor rasterization of points for estimating the update field (potential
+        speed-up).  Default = False.
+
+    verbose : bool
+        Print progress to the screen.
+
+    Returns
+    -------
+
+    ANTs transform
+
+    Example
+    -------
+    >>> import ants
+    >>> import numpy as np
+    """
+
+    def create_zero_velocity_field(domain_image, number_of_time_points=2):
+         field_array = np.zeros((*domain_image.shape, number_of_time_points, domain_image.dimension))
+         origin = (*domain_image.origin, 0.0)
+         spacing = (*domain_image.spacing, 1.0)
+         direction = np.eye(domain_image.dimension + 1)
+         direction[0:domain_image.dimension,0:domain_image.dimension] = domain_image.direction
+         field = ants.from_numpy(field_array, origin=origin, spacing=spacing, direction=direction,
+                 has_components=True)
+         return(field)
+
+    if not isinstance(point_sets, list):
+        raise ValueError("point_sets should be a list of corresponding point sets.")
+
+    number_of_point_sets = len(point_sets)
+
+    if time_points is not None and len(time_points) != number_of_point_sets:
+        raise ValueError("The number of time points should be the same as the number of point sets.")
+
+    if time_points is None:
+        time_points = np.linspace(0.0, 1.0, number_of_point_sets)
+    time_points = np.array(time_points)
+
+    if np.any(time_points < 0.0) or np.any(time_points > 1.0):
+        raise ValueError("time point values should be between 0 and 1.")
+
+    if number_of_point_sets < 3:
+        raise ValueError("Expecting three or greater point sets.")
+
+    if domain_image is None:
+        raise ValueError("Domain image needs to be specified.")
+
+    number_of_points = point_sets[0].shape[0]
+    dimensionality = point_sets[0].shape[1]
+    for i in range(1, number_of_point_sets):
+        if point_sets[i].shape[0] != number_of_points:
+            raise ValueError("Point sets should match in terms of the number of points.")
+        if point_sets[i].shape[1] != dimensionality:
+            raise ValueError("Point sets should match in terms of dimensionality.")
+
+    if verbose:
+        start_total_time = time.time()
+
+    updated_fixed_points = np.zeros(point_sets[0].shape)
+    updated_moving_points = np.zeros(point_sets[0].shape)
+
+    velocity_field = None
+    if initial_velocity_field is None:
+        if number_of_time_steps is None:
+            number_of_time_steps = len(time_points)
+        if number_of_time_steps < number_of_point_sets:
+            raise ValueError("The number of integration points should be at least as great as the number of point sets.")
+        velocity_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+    else:
+        velocity_field = ants.image_clone(initial_velocity_field)
+        number_of_time_steps = initial_velocity_field.shape[-1]
+    velocity_field_array = velocity_field.numpy()
+
+    last_update_derivative_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+    last_update_derivative_field_array = last_update_derivative_field.numpy()
+
+    error_values = []
+    for i in range(number_of_compositions):
+
+        if verbose:
+            start_time = time.time()
+
+        update_derivative_field = create_zero_velocity_field(domain_image, number_of_time_steps)
+        update_derivative_field_array = update_derivative_field.numpy()
+
+        average_error = 0.0
+        for n in range(number_of_time_steps):
+
+            t = n / (number_of_time_steps - 1.0)
+
+            t_index = 0
+            for j in range(1, number_of_point_sets):
+                if time_points[j-1] <= t and time_points[j] >= t:
+                    t_index = j
+                    break
+
+            if n > 0 and n < number_of_time_steps - 1 and time_points[t_index-1] == t:
+                updated_fixed_points[:] = point_sets[t_index-1]
+                integrated_inverse_field = ants.integrate_velocity_field(velocity_field, time_points[t_index], t, number_of_integration_steps)
+                integrated_inverse_field_xfrm = ants.transform_from_displacement_field(integrated_inverse_field)
+                for j in range(updated_moving_points.shape[0]):
+                    updated_moving_points[j,:] = integrated_inverse_field_xfrm.apply_to_point(tuple(point_sets[t_index][j,:]))
+
+                update_derivative_field_at_timepoint_forward = ants.fit_bspline_displacement_field(
+                  displacement_origins=updated_fixed_points,
+                  displacements=updated_moving_points - updated_fixed_points,
+                  displacement_weights=displacement_weights,
+                  origin=domain_image.origin,
+                  spacing=domain_image.spacing,
+                  size=domain_image.shape,
+                  direction=domain_image.direction,
+                  number_of_fitting_levels=number_of_fitting_levels,
+                  mesh_size=mesh_size,
+                  spline_order=spline_order,
+                  enforce_stationary_boundary=True,
+                  rasterize_points=rasterize_points
+                  )
+
+                updated_moving_points[:] = point_sets[t_index-1]
+                integrated_forward_field = ants.integrate_velocity_field(velocity_field, time_points[t_index-2], t, number_of_integration_steps)
+                integrated_forward_field_xfrm = ants.transform_from_displacement_field(integrated_forward_field)
+                for j in range(updated_fixed_points.shape[0]):
+                    updated_fixed_points[j,:] = integrated_forward_field_xfrm.apply_to_point(tuple(point_sets[t_index-2][j,:]))
+
+                update_derivative_field_at_timepoint_back = ants.fit_bspline_displacement_field(
+                  displacement_origins=updated_fixed_points,
+                  displacements=updated_moving_points - updated_fixed_points,
+                  displacement_weights=displacement_weights,
+                  origin=domain_image.origin,
+                  spacing=domain_image.spacing,
+                  size=domain_image.shape,
+                  direction=domain_image.direction,
+                  number_of_fitting_levels=number_of_fitting_levels,
+                  mesh_size=mesh_size,
+                  spline_order=spline_order,
+                  enforce_stationary_boundary=True,
+                  rasterize_points=rasterize_points
+                  )
+
+                update_derivative_field_at_timepoint = (update_derivative_field_at_timepoint_forward +
+                                                        update_derivative_field_at_timepoint_back) / 2.0
+
+            else:
+                if t == 0.0 and time_points[t_index-1] == 0.0:
+                    updated_fixed_points[:] = point_sets[0]
+                else:
+                    integrated_forward_field = ants.integrate_velocity_field(velocity_field, time_points[t_index-1], t, number_of_integration_steps)
+                    integrated_forward_field_xfrm = ants.transform_from_displacement_field(integrated_forward_field)
+                    for j in range(updated_fixed_points.shape[0]):
+                        updated_fixed_points[j,:] = integrated_forward_field_xfrm.apply_to_point(tuple(point_sets[t_index-1][j,:]))
+
+                if t == 1.0 and time_points[t_index] == 1.0:
+                    updated_moving_points[:] = point_sets[-1]
+                else:
+                    integrated_inverse_field = ants.integrate_velocity_field(velocity_field, time_points[t_index], t, number_of_integration_steps)
+                    integrated_inverse_field_xfrm = ants.transform_from_displacement_field(integrated_inverse_field)
+                    for j in range(updated_moving_points.shape[0]):
+                        updated_moving_points[j,:] = integrated_inverse_field_xfrm.apply_to_point(tuple(point_sets[t_index][j,:]))
+
+                update_derivative_field_at_timepoint = ants.fit_bspline_displacement_field(
+                  displacement_origins=updated_fixed_points,
+                  displacements=updated_moving_points - updated_fixed_points,
+                  displacement_weights=displacement_weights,
+                  origin=domain_image.origin,
+                  spacing=domain_image.spacing,
+                  size=domain_image.shape,
+                  direction=domain_image.direction,
+                  number_of_fitting_levels=number_of_fitting_levels,
+                  mesh_size=mesh_size,
+                  spline_order=spline_order,
+                  enforce_stationary_boundary=True,
+                  rasterize_points=rasterize_points
+                  )
+
+            if sigma > 0:
+                update_derivative_field_at_timepoint = ants.smooth_image(update_derivative_field_at_timepoint, sigma)
+
+            update_derivative_field_at_timepoint_array = update_derivative_field_at_timepoint.numpy()
+            grad_norms = np.sqrt(np.sum(np.square(update_derivative_field_at_timepoint_array), axis=-1, keepdims=False))
+            max_norm = np.amax(grad_norms)
+            median_norm = np.median(grad_norms)
+            if verbose:
+                print("  integration point " + str(t) + ": max_norm = " + str(max_norm) + ", median_norm = " + str(median_norm))
+            update_derivative_field_at_timepoint_array /= max_norm
+            if domain_image.dimension == 2:
+                update_derivative_field_array[:,:,n,:] = update_derivative_field_at_timepoint_array
+            elif domain_image.dimension == 3:
+                update_derivative_field_array[:,:,:,n,:] = update_derivative_field_at_timepoint_array
+
+            rmse = np.mean(np.sqrt(np.sum(np.square(updated_moving_points - updated_fixed_points), axis=1, keepdims=True)))
+            average_error = (average_error * n + rmse) / (n + 1)
+
+        update_derivative_field_array = (update_derivative_field_array + last_update_derivative_field_array) * 0.5
+        last_update_derivative_field_array = np.empty_like(update_derivative_field_array)
+        last_update_derivative_field_array[:] = update_derivative_field_array
+
+        velocity_field_array += (update_derivative_field_array * composition_step_size)
+        velocity_field = ants.from_numpy(velocity_field_array, origin=velocity_field.origin,
+                                         spacing=velocity_field.spacing, direction=velocity_field.direction,
+                                         has_components=True)
+
+        error_values.append(average_error)
+        convergence_value = convergence_monitoring(error_values)
+        if verbose:
+            end_time = time.time()
+            diff_time = end_time - start_time
+            print("Composition " + str(i) + ": error = " + str(error_values[-1]) +
+                  " (convergence = " + str(convergence_value) + ", elapsed time = " + str(diff_time) + ")")
+        if not convergence_value is None and convergence_value <= convergence_threshold:
+            break
+
+    forward_xfrm = ants.transform_from_displacement_field(ants.integrate_velocity_field(velocity_field, 0.0, 1.0, number_of_integration_steps))
+    inverse_xfrm = ants.transform_from_displacement_field(ants.integrate_velocity_field(velocity_field, 1.0, 0.0, number_of_integration_steps))
+
+    if verbose:
+        end_total_time = time.time()
+        diff_total_time = end_total_time - start_total_time
+        print("Total elapsed time = " + str(diff_total_time) + ".")
+
+    return_dict = {'forward_transform': forward_xfrm,
+                   'inverse_transform': inverse_xfrm,
+                   'velocity_field': velocity_field}
+    return(return_dict)
+
+
+
+

MindEyeV2/antspy/ants/registration/registration.py

@@ -0,0 +1,1953 @@
+"""
+ANTsPy Registration
+"""
+__all__ = ["registration", 
+           "motion_correction",
+           "label_image_registration"]
+
+import numpy as np
+from tempfile import mktemp
+import glob
+import re
+import pandas as pd
+import itertools
+
+import ants
+from ants.internal import get_lib_fn, get_pointer_string, process_arguments
+
+def registration(
+    fixed,
+    moving,
+    type_of_transform="SyN",
+    initial_transform=None,
+    outprefix="",
+    mask=None,
+    moving_mask=None,
+    mask_all_stages=False,
+    grad_step=0.2,
+    flow_sigma=3,
+    total_sigma=0,
+    aff_metric="mattes",
+    aff_sampling=32,
+    aff_random_sampling_rate=0.2,
+    syn_metric="mattes",
+    syn_sampling=32,
+    reg_iterations=(40, 20, 0),
+    aff_iterations=(2100, 1200, 1200, 10),
+    aff_shrink_factors=(6, 4, 2, 1),
+    aff_smoothing_sigmas=(3, 2, 1, 0),
+    write_composite_transform=False,
+    random_seed=None,
+    verbose=False,
+    multivariate_extras=None,
+    restrict_transformation=None,
+    smoothing_in_mm=False,
+    singleprecision=True,
+    **kwargs
+):
+    """
+    Register a pair of images either through the full or simplified
+    interface to the ANTs registration method.
+
+    ANTsR function: `antsRegistration`
+
+    Arguments
+    ---------
+    fixed : ANTsImage
+        fixed image to which we register the moving image.
+
+    moving : ANTsImage
+        moving image to be mapped to fixed space.
+
+    type_of_transform : string
+        A linear or non-linear registration type. Mutual information metric by default.
+        See Notes below for more.
+
+    initial_transform : list of strings (optional)
+        transforms to prepend. If None, a translation is computed to align the image centers of mass.
+        To use an identity transform, set this to 'Identity'.
+
+    outprefix : string
+        output will be named with this prefix.
+
+    mask : ANTsImage (optional)
+        Registration metric mask in the fixed image space.
+
+    moving_mask : ANTsImage (optional)
+        Registration metric mask in the moving image space.
+
+    mask_all_stages : boolean
+        If true, apply metric mask(s) to all registration stages, instead of just the final stage.
+
+    grad_step : scalar
+        gradient step size (not for all tx)
+
+    flow_sigma : scalar
+        smoothing for update field
+        At each iteration, the similarity metric and gradient is calculated. 
+        That gradient field is also called the update field and is smoothed 
+        before composing with the total field (i.e., the estimate of the total 
+        transform at that iteration). This total field can also be smoothed 
+        after each iteration.
+
+    total_sigma : scalar
+        smoothing for total field
+
+    aff_metric : string
+        the metric for the affine part (GC, mattes, meansquares)
+
+    aff_sampling : scalar
+        number of bins for the mutual information metric
+
+    aff_random_sampling_rate : scalar
+        the fraction of points used to estimate the metric. this can impact
+        speed but also reproducibility and/or accuracy.
+
+    syn_metric : string
+        the metric for the syn part (CC, mattes, meansquares, demons)
+
+    syn_sampling : scalar
+        the nbins or radius parameter for the syn metric
+
+    reg_iterations : list/tuple of integers
+        vector of iterations for syn. we will set the smoothing and multi-resolution parameters based on the length of this vector.
+
+    aff_iterations : list/tuple of integers
+        vector of iterations for low-dimensional (translation, rigid, affine) registration.
+
+    aff_shrink_factors : list/tuple of integers
+        vector of multi-resolution shrink factors for low-dimensional (translation, rigid, affine) registration.
+
+    aff_smoothing_sigmas : list/tuple of integers
+        vector of multi-resolution smoothing factors for low-dimensional (translation, rigid, affine) registration.
+
+    random_seed : integer
+        random seed to improve reproducibility. note that the number of ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS should be 1 if you want perfect reproducibility.
+
+    write_composite_transform : boolean
+        Boolean specifying whether or not the composite transform (and its inverse, if it exists) should be written to an hdf5 composite file. This is false by default so that only the transform for each stage is written to file.
+
+    verbose : boolean
+        request verbose output (useful for debugging)
+
+    multivariate_extras : additional metrics for multi-metric registration
+        list of additional images and metrics which will
+        trigger the use of multiple metrics in the registration
+        process in the deformable stage. Each multivariate metric needs 5
+        entries: name of metric, fixed, moving, weight,
+        samplingParam. the list of lists should be of the form ( (
+        "nameOfMetric2", img, img, weight, metricParam ) ). Another
+        example would be  ( ( "MeanSquares", f2, m2, 0.5, 0
+          ), ( "CC", f2, m2, 0.5, 2 ) ) .  This is only compatible
+        with the SyNOnly or antsRegistrationSyN* transformations.
+
+    restrict_transformation : This option allows the user to restrict the
+          optimization of the displacement field, translation, rigid or
+          affine transform on a per-component basis. For example, if
+          one wants to limit the deformation or rotation of 3-D volume
+          to the first two dimensions, this is possible by specifying a
+          weight vector of ‘(1,1,0)’ for a 3D deformation field or
+          ‘(1,1,0,1,1,0)’ for a rigid transformation. Restriction
+          currently only works if there are no preceding
+          transformations.
+
+    smoothing_in_mm : boolean ; currently only impacts low dimensional registration
+
+    singleprecision : boolean
+        if True, use float32 for computations. This is useful for reducing memory
+        usage for large datasets, at the cost of precision.    
+
+    kwargs : keyword args
+        extra arguments
+
+    Returns
+    -------
+    dict containing follow key/value pairs:
+        `warpedmovout`: Moving image warped to space of fixed image.
+        `warpedfixout`: Fixed image warped to space of moving image.
+        `fwdtransforms`: Transforms to move from moving to fixed image.
+        `invtransforms`: Transforms to move from fixed to moving image.
+
+    Notes
+    -----
+    type_of_transform can be one of:
+        - "Translation": Translation transformation.
+        - "Rigid": Rigid transformation: Only rotation and translation.
+        - "Similarity": Similarity transformation: scaling, rotation and translation.
+        - "QuickRigid": Rigid transformation: Only rotation and translation.
+                        May be useful for quick visualization fixes.'
+        - "DenseRigid": Rigid transformation: Only rotation and translation.
+                        Employs dense sampling during metric estimation.'
+        - "BOLDRigid": Rigid transformation: Parameters typical for BOLD to
+                        BOLD intrasubject registration'.'
+        - "Affine": Affine transformation: Rigid + scaling.
+        - "AffineFast": Fast version of Affine.
+        - "BOLDAffine": Affine transformation: Parameters typical for BOLD to
+                        BOLD intrasubject registration'.'
+        - "TRSAA": translation, rigid, similarity, affine (twice). please set
+                    regIterations if using this option. this would be used in
+                    cases where you want a really high quality affine mapping
+                    (perhaps with mask).
+        - "Elastic": Elastic deformation: Affine + deformable.
+        - "ElasticSyN": Symmetric normalization: Affine + deformable
+                        transformation, with mutual information as optimization
+                        metric and elastic regularization.
+        - "SyN": Symmetric normalization: Affine + deformable transformation,
+                    with mutual information as optimization metric.
+        - "SyNRA": Symmetric normalization: Rigid + Affine + deformable
+                    transformation, with mutual information as optimization metric.
+        - "SyNOnly": Symmetric normalization with no rigid or affine stages.
+                    Uses mutual information as optimization metric. Affine alignment is
+                    from the initial_transform arg, either provide the .mat from linear
+                    registration or use initial_transform='Identity' if the images are 
+                    already affinely aligned.
+                    Can be useful if you want to run an unmasked affine followed by
+                    masked deformable registration.
+        - "SyNCC": SyN, but with cross-correlation as the metric.
+        - "SyNabp": SyN optimized for abpBrainExtraction.
+        - "SyNBold": SyN, but optimized for registrations between BOLD and T1 images.
+        - "SyNBoldAff": SyN, but optimized for registrations between BOLD
+                        and T1 images, with additional affine step.
+        - "SyNAggro": SyN, but with more aggressive registration
+                        (fine-scale matching and more deformation).
+                        Takes more time than SyN.
+        - "TV[n]": time-varying diffeomorphism with where 'n' indicates number of
+            time points in velocity field discretization.  The initial transform
+            should be computed, if needed, in a separate call to ants.registration.
+        - "TVMSQ": time-varying diffeomorphism with mean square metric
+        - "TVMSQC": time-varying diffeomorphism with mean square metric for very large deformation
+        - "antsRegistrationSyN[x]": recreation of the antsRegistrationSyN.sh script in ANTs
+                                    where 'x' is one of the transforms available:
+                                         t: translation (1 stage)
+                                         r: rigid (1 stage)
+                                         a: rigid + affine (2 stages)
+                                         s: rigid + affine + deformable syn (3 stages)
+                                         sr: rigid + deformable syn (2 stages)
+                                         so: deformable syn only (1 stage)
+                                         b: rigid + affine + deformable b-spline syn (3 stages)
+                                         br: rigid + deformable b-spline syn (2 stages)
+                                         bo: deformable b-spline syn only (1 stage)
+        - "antsRegistrationSyNQuick[x]": recreation of the antsRegistrationSyNQuick.sh script in ANTs.
+                                         x options as above.
+        - "antsRegistrationSyNRepro[x]": reproducible registration.  x options as above.
+        - "antsRegistrationSyNQuickRepro[x]": quick reproducible registration.  x options as above.
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read(ants.get_ants_data('r16'))
+    >>> mi = ants.image_read(ants.get_ants_data('r64'))
+    >>> fi = ants.resample_image(fi, (60,60), 1, 0)
+    >>> mi = ants.resample_image(mi, (60,60), 1, 0)
+    >>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'SyN' )
+    >>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[t]' )
+    >>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[b]' )
+    >>> mytx = ants.registration(fixed=fi, moving=mi, type_of_transform = 'antsRegistrationSyN[s]' )
+    """
+    if isinstance(fixed, list) and (moving is None):
+        processed_args = process_arguments(fixed)
+        libfn = get_lib_fn("antsRegistration")
+        reg_exit = libfn(processed_args)
+        if (reg_exit != 0):
+            raise RuntimeError(f"Registration failed with error code {reg_exit}")
+        else:
+            return 0
+
+    if not (ants.is_image(fixed) and ants.is_image(moving)):
+        raise ValueError("Fixed and moving images must be ANTsImage objects")
+
+    if type_of_transform == "":
+        type_of_transform = "SyN"
+
+    if isinstance(type_of_transform, (tuple, list)) and (len(type_of_transform) == 1):
+        type_of_transform = type_of_transform[0]
+
+    if (outprefix == "") or len(outprefix) == 0:
+        outprefix = mktemp()
+
+    if np.sum(np.isnan(fixed.numpy())) > 0:
+        raise ValueError("fixed image has NaNs - replace these")
+    if np.sum(np.isnan(moving.numpy())) > 0:
+        raise ValueError("moving image has NaNs - replace these")
+
+    if fixed.dimension != moving.dimension:
+        raise ValueError("Fixed and moving image dimensions are not the same.")
+    # ----------------------------
+
+    myiterations = aff_iterations
+    args = [fixed, moving, type_of_transform, outprefix]
+    myf_aff = "6x4x2x1"  # old fixed params
+    mys_aff = "3x2x1x0"  # old fixed params
+    if (
+        type(aff_shrink_factors) is int
+        or type(aff_smoothing_sigmas) is int
+        or type(aff_iterations) is int
+    ):
+        if type(aff_smoothing_sigmas) is not int:
+            raise ValueError("aff_smoothing_sigmas should be a single integer.")
+        if type(aff_iterations) is not int:
+            raise ValueError("aff_iterations should be a single integer.")
+        if type(aff_shrink_factors) is not int:
+            raise ValueError("aff_shrink_factors should be a single integer.")
+        myf_aff = aff_shrink_factors
+        mys_aff = aff_smoothing_sigmas
+        myiterations = aff_iterations
+
+    if restrict_transformation is not None:
+        if type(restrict_transformation) is tuple:
+            restrict_transformationchar = "x".join([str(ri) for ri in restrict_transformation])
+
+    if type(aff_shrink_factors) is tuple:
+        myf_aff = "x".join([str(ri) for ri in aff_shrink_factors])
+        mys_aff = "x".join([str(ri) for ri in aff_smoothing_sigmas])
+        myiterations = "x".join([str(ri) for ri in aff_iterations])
+        if len(aff_iterations) != len(aff_smoothing_sigmas):
+            raise ValueError(
+                "aff_iterations length should equal aff_smoothing_sigmas length."
+            )
+        if len(aff_iterations) != len(aff_shrink_factors):
+            raise ValueError(
+                "aff_iterations length should equal aff_shrink_factors length."
+            )
+        if len(aff_shrink_factors) != len(aff_smoothing_sigmas):
+            raise ValueError(
+                "aff_shrink_factors length should equal aff_smoothing_sigmas length."
+            )
+
+    if type_of_transform == "AffineFast":
+        type_of_transform = "Affine"
+        myiterations = "2100x1200x0x0"
+    if type_of_transform == "BOLDAffine":
+        type_of_transform = "Affine"
+        myf_aff = "2x1"
+        mys_aff = "1x0"
+        myiterations = "100x20"
+    if type_of_transform == "QuickRigid":
+        type_of_transform = "Rigid"
+        myiterations = "20x20x0x0"
+    if type_of_transform == "DenseRigid":
+        type_of_transform = "Rigid"
+        aff_random_sampling_rate = 1.0
+    if type_of_transform == "BOLDRigid":
+        type_of_transform = "Rigid"
+        myf_aff = "2x1"
+        mys_aff = "1x0"
+        myiterations = "100x20"
+
+    if smoothing_in_mm:
+        mys_aff = mys_aff + 'mm'
+
+    mysyn = "SyN[%f,%f,%f]" % (grad_step, flow_sigma, total_sigma)
+    if type_of_transform == "Elastic":
+        mysyn = "GaussianDisplacementField[%f,%f,%f]" % (grad_step, flow_sigma, total_sigma)
+    itlen = len(reg_iterations)  # NEED TO CHECK THIS
+    if itlen == 0:
+        smoothingsigmas = 0
+        shrinkfactors = 1
+        synits = reg_iterations
+    else:
+        smoothingsigmas = np.arange(0, itlen)[::-1].astype(
+            "float32"
+        )  # NEED TO CHECK THIS
+        shrinkfactors = 2 ** smoothingsigmas
+        shrinkfactors = shrinkfactors.astype("int")
+        smoothingsigmas = "x".join([str(ss)[0] for ss in smoothingsigmas])
+        shrinkfactors = "x".join([str(ss) for ss in shrinkfactors])
+        synits = "x".join([str(ri) for ri in reg_iterations])
+
+    inpixeltype = fixed.pixeltype
+    output_pixel_type = 'float' if singleprecision else 'double'
+
+    tvTypes = [
+        "TV[1]",
+        "TV[2]",
+        "TV[3]",
+        "TV[4]",
+        "TV[5]",
+        "TV[6]",
+        "TV[7]",
+        "TV[8]",
+    ]
+    allowable_tx = {
+        "SyNBold",
+        "SyNBoldAff",
+        "ElasticSyN",
+        "Elastic",
+        "SyN",
+        "SyNRA",
+        "SyNOnly",
+        "SyNAggro",
+        "SyNCC",
+        "TRSAA",
+        "SyNabp",
+        "SyNLessAggro",
+        "TV[1]",
+        "TV[2]",
+        "TV[3]",
+        "TV[4]",
+        "TV[5]",
+        "TV[6]",
+        "TV[7]",
+        "TV[8]",
+        "TVMSQ",
+        "TVMSQC",
+        "Rigid",
+        "Similarity",
+        "Translation",
+        "Affine",
+        "AffineFast",
+        "BOLDAffine",
+        "QuickRigid",
+        "DenseRigid",
+        "BOLDRigid"
+    }
+    ttexists = type_of_transform in allowable_tx
+
+    # Perform checking of antsRegistrationSyN transforms later
+    if not "antsRegistrationSyN" in type_of_transform and not ttexists:
+        raise ValueError(f'{type_of_transform} does not exist')
+
+    initx = initial_transform
+    if isinstance(initx, str):
+        initx = [initx]
+    # if isinstance(initx, ANTsTransform):
+    # tempTXfilename = tempfile( fileext = '.mat' )
+    # initx = invertAntsrTransform( initialTransform )
+    # initx = invertAntsrTransform( initx )
+    # writeAntsrTransform( initx, tempTXfilename )
+    # initx = tempTXfilename
+    moving = moving.clone(output_pixel_type)
+    fixed = fixed.clone(output_pixel_type)
+    # NOTE: this may be better for general purpose applications: TBD
+#    moving = ants.iMath( moving.clone("float"), "Normalize" )
+#    fixed = ants.iMath( fixed.clone("float"), "Normalize" )
+    warpedfixout = moving.clone()
+    warpedmovout = fixed.clone()
+    f = get_pointer_string(fixed)
+    m = get_pointer_string(moving)
+    wfo = get_pointer_string(warpedfixout)
+    wmo = get_pointer_string(warpedmovout)
+    if mask is not None:
+        mask_binary = mask != 0
+        f_mask_str = get_pointer_string(mask_binary)
+    else:
+        f_mask_str = "NA"
+
+    if moving_mask is not None:
+        moving_mask_binary = moving_mask != 0
+        m_mask_str = get_pointer_string(moving_mask_binary)
+    else:
+        m_mask_str = "NA"
+
+    maskopt = "[%s,%s]" % (f_mask_str, m_mask_str)
+
+    if mask_all_stages:
+        earlymaskopt = maskopt;
+    else:
+        earlymaskopt = "[NA,NA]"
+
+    if initx is None:
+        initx = ["[%s,%s,1]" % (f, m)]
+    # ------------------------------------------------------------
+    if type_of_transform == "SyNBold":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Rigid[0.25]",
+            "-c",
+            "[1200x1200x100,1e-6,5]",
+            "-s",
+            "2x1x0",
+            "-f",
+            "4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNBoldAff":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Rigid[0.25]",
+            "-c",
+            "[1200x1200x100,1e-6,5]",
+            "-s",
+            "2x1x0",
+            "-f",
+            "4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "[200x20,1e-6,5]",
+            "-s",
+            "1x0",
+            "-f",
+            "2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % (synits),
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "ElasticSyN":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "2100x1200x200x0",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % (synits),
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyN" or type_of_transform == "Elastic":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "2100x1200x1200x0",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNRA":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Rigid[0.25]",
+            "-c",
+            "2100x1200x1200x0",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "2100x1200x1200x0",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNOnly":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+        ]
+        if multivariate_extras is not None:
+            metrics = []
+            for kk in range(len(multivariate_extras)):
+                metrics.append("-m")
+                metricname = multivariate_extras[kk][0]
+                metricfixed = get_pointer_string(
+                    multivariate_extras[kk][1]
+                )
+                metricmov = get_pointer_string(
+                    multivariate_extras[kk][2]
+                )
+                metricWeight = multivariate_extras[kk][3]
+                metricSampling = multivariate_extras[kk][4]
+                metricString = "%s[%s,%s,%s,%s]" % (
+                    metricname,
+                    metricfixed,
+                    metricmov,
+                    metricWeight,
+                    metricSampling,
+                )
+                metrics.append(metricString)
+            args = [
+                "-d",
+                str(fixed.dimension),
+                "-r"
+            ] + initx + [
+                "-m",
+                "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            ]
+            args1 = [
+                "-t",
+                mysyn,
+                "-c",
+                "[%s,1e-7,8]" % synits,
+                "-s",
+                smoothingsigmas,
+                "-f",
+                shrinkfactors,
+                "-u",
+                "1",
+                "-z",
+                "1",
+                "-o",
+                "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            ]
+            for kk in range(len(metrics)):
+                args.append(metrics[kk])
+            for kk in range(len(args1)):
+                args.append(args1[kk])
+        args.append("-x")
+        args.append(maskopt)
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNAggro":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "2100x1200x1200x100",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNCC":
+        syn_metric = "CC"
+        syn_sampling = 4
+        synits = "2100x1200x1200x20"
+        smoothingsigmas = "3x2x1x0"
+        shrinkfactors = "4x3x2x1"
+        mysyn = "SyN[0.15,3,0]"
+
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Rigid[1]",
+            "-c",
+            "2100x1200x1200x0",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[1]",
+            "-c",
+            "1200x1200x100",
+            "-s",
+            "2x1x0",
+            "-f",
+            "4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "TRSAA":
+        itlen = len(reg_iterations)
+        itlenlow = round(itlen / 2 + 0.0001)
+        dlen = itlen - itlenlow
+        _myconvlow = [2000] * itlenlow + [0] * dlen
+        myconvlow = "x".join([str(mc) for mc in _myconvlow])
+        myconvhi = "x".join([str(r) for r in reg_iterations])
+        myconvhi = "[%s,1.e-7,10]" % myconvhi
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Translation[1]",
+            "-c",
+            myconvlow,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Rigid[1]",
+            "-c",
+            myconvlow,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Similarity[1]",
+            "-c",
+            myconvlow,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[1]",
+            "-c",
+            myconvhi,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[1]",
+            "-c",
+            myconvhi,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------s
+    elif type_of_transform == "SyNabp":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "mattes[%s,%s,1,32,regular,0.25]" % (f, m),
+            "-t",
+            "Rigid[0.1]",
+            "-c",
+            "1000x500x250x100",
+            "-s",
+            "4x2x1x0",
+            "-f",
+            "8x4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "mattes[%s,%s,1,32,regular,0.25]" % (f, m),
+            "-t",
+            "Affine[0.1]",
+            "-c",
+            "1000x500x250x100",
+            "-s",
+            "4x2x1x0",
+            "-f",
+            "8x4x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "CC[%s,%s,0.5,4]" % (f, m),
+            "-t",
+            "SyN[0.1,3,0]",
+            "-c",
+            "50x10x0",
+            "-s",
+            "2x1x0",
+            "-f",
+            "4x2x1",
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "SyNLessAggro":
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "Affine[0.25]",
+            "-c",
+            "2100x1200x1200x100",
+            "-s",
+            "3x2x1x0",
+            "-f",
+            "4x2x2x1",
+            "-x",
+            earlymaskopt,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            mysyn,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform in tvTypes:
+        if grad_step is None:
+            grad_step = 1.0
+        nTimePoints = type_of_transform.split("[")[1].split("]")[0]
+        tvtx = (
+            "TimeVaryingVelocityField["
+            + str(grad_step)
+            + ","
+            + nTimePoints
+            + ","
+            + str(flow_sigma)
+            + ",0.0,"
+            + str(total_sigma)
+            + ",0]"
+        )
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            tvtx,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "0",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    elif type_of_transform == "TVMSQ":
+        if grad_step is None:
+            grad_step = 1.0
+
+        tvtx = "TimeVaryingVelocityField[%s, 4, 0.0,0.0, 0.5,0 ]" % str(
+            grad_step
+        )
+        args = [
+            "-d",
+            str(fixed.dimension),
+            # '-r', initx,
+            "-m",
+            "%s[%s,%s,1,%s]" % (syn_metric, f, m, syn_sampling),
+            "-t",
+            tvtx,
+            "-c",
+            "[%s,1e-7,8]" % synits,
+            "-s",
+            smoothingsigmas,
+            "-f",
+            shrinkfactors,
+            "-u",
+            "1",
+            "-z",
+            "0",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif type_of_transform == "TVMSQC":
+        if grad_step is None:
+            grad_step = 2.0
+
+        tvtx = "TimeVaryingVelocityField[%s, 8, 1.0,0.0, 0.05,0 ]" % str(
+            grad_step
+        )
+        args = [
+            "-d",
+            str(fixed.dimension),
+            # '-r', initx,
+            "-m",
+            "demons[%s,%s,0.5,0]" % (f, m),
+            "-m",
+            "meansquares[%s,%s,1,0]" % (f, m),
+            "-t",
+            tvtx,
+            "-c",
+            "[1200x1200x100x20x0,0,5]",
+            "-s",
+            "8x6x4x2x1vox",
+            "-f",
+            "8x6x4x2x1",
+            "-u",
+            "1",
+            "-z",
+            "0",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif (
+        (type_of_transform == "Rigid")
+        or (type_of_transform == "Similarity")
+        or (type_of_transform == "Translation")
+        or (type_of_transform == "Affine")
+    ):
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-m",
+            "%s[%s,%s,1,%s,regular,%s]"
+            % (aff_metric, f, m, aff_sampling, aff_random_sampling_rate),
+            "-t",
+            "%s[0.25]" % type_of_transform,
+            "-c",
+            myiterations,
+            "-s",
+            mys_aff,
+            "-f",
+            myf_aff,
+            "-u",
+            "1",
+            "-z",
+            "1",
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+            "-x",
+            maskopt
+        ]
+    # ------------------------------------------------------------
+    elif "antsRegistrationSyN" in type_of_transform:
+
+        do_quick = False
+        if "Quick" in type_of_transform:
+            do_quick = True
+
+        subtype_of_transform = "s"
+        spline_distance = 26
+        metric_parameter = 4
+        if do_quick:
+            metric_parameter = 32
+
+        if "[" in type_of_transform and "]" in type_of_transform:
+            subtype_of_transform = type_of_transform.split("[")[1].split(
+                "]"
+            )[0]
+            if "," in subtype_of_transform:
+                subtype_of_transform_args = subtype_of_transform.split(",")
+                subtype_of_transform = subtype_of_transform_args[0]
+                if not ( subtype_of_transform == "b"
+                         or subtype_of_transform == "br"
+                         or subtype_of_transform == "bo"
+                         or subtype_of_transform == "s"
+                         or subtype_of_transform == "sr"
+                         or subtype_of_transform == "so" ):
+                    raise ValueError("Extra parameters are only valid for 's' or 'b' SyN transforms.")
+                metric_parameter = subtype_of_transform_args[1]
+                if len(subtype_of_transform_args) > 2:
+                    spline_distance = subtype_of_transform_args[2]
+
+        do_repro = False
+        if "Repro" in type_of_transform:
+            do_repro = True
+
+        if do_quick == True:
+            rigid_convergence = "[1000x500x250x0,1e-6,10]"
+        else:
+            rigid_convergence = "[1000x500x250x100,1e-6,10]"
+        rigid_shrink_factors = "8x4x2x1"
+        rigid_smoothing_sigmas = "3x2x1x0vox"
+
+        if do_quick == True:
+            affine_convergence = "[1000x500x250x0,1e-6,10]"
+        else:
+            affine_convergence = "[1000x500x250x100,1e-6,10]"
+        affine_shrink_factors = "8x4x2x1"
+        affine_smoothing_sigmas = "3x2x1x0vox"
+
+        linear_metric="MI[%s,%s,1,32,Regular,0.25]"
+        if do_repro == True:
+            linear_metric="GC[%s,%s,1,1,Regular,0.25]"
+
+        if do_quick == True:
+            syn_convergence = "[100x70x50x0,1e-6,10]"
+            metric_parameter = 32
+            syn_metric = "MI[%s,%s,1,%s]" % (f, m, metric_parameter)
+        else:
+            metric_parameter = 2
+            syn_convergence = "[100x70x50x20,1e-6,10]"
+            syn_metric = "CC[%s,%s,1,%s]" % (f, m, metric_parameter)
+        syn_shrink_factors = "8x4x2x1"
+        syn_smoothing_sigmas = "3x2x1x0vox"
+
+        if do_quick == True and do_repro == True:
+            syn_convergence = "[100x70x50x0,1e-6,10]"
+            metric_parameter = 2
+            syn_metric = "CC[%s,%s,1,%s]" % (f, m, metric_parameter)
+
+        if random_seed is None and do_repro == True:
+            random_seed = str( 1 )
+
+        tx = "Rigid"
+        if subtype_of_transform == "t":
+            tx = "Translation"
+
+        rigid_stage = [
+            "--transform",
+            tx + "[0.1]",
+            "--metric",
+            linear_metric % (f, m),
+            "--convergence",
+            rigid_convergence,
+            "--shrink-factors",
+            rigid_shrink_factors,
+            "--smoothing-sigmas",
+            rigid_smoothing_sigmas,
+        ]
+
+        affine_stage = [
+            "--transform",
+            "Affine[0.1]",
+            "--metric",
+            linear_metric % (f, m),
+            "--convergence",
+            affine_convergence,
+            "--shrink-factors",
+            affine_shrink_factors,
+            "--smoothing-sigmas",
+            affine_smoothing_sigmas,
+        ]
+
+        if subtype_of_transform == "sr" or subtype_of_transform == "br":
+            if do_quick == True:
+                syn_convergence = "[50x0,1e-6,10]"
+            else:
+                syn_convergence = "[50x20,1e-6,10]"
+            syn_shrink_factors = "2x1"
+            syn_smoothing_sigmas = "1x0vox"
+
+        syn_stage = [
+            "--metric",
+            syn_metric,
+        ]
+
+        if multivariate_extras is not None:
+            for kk in range(len(multivariate_extras)):
+                syn_stage.append("--metric")
+                metricname = multivariate_extras[kk][0]
+                metricfixed = get_pointer_string(
+                    multivariate_extras[kk][1]
+                )
+                metricmov = get_pointer_string(
+                    multivariate_extras[kk][2]
+                )
+                metricWeight = multivariate_extras[kk][3]
+                metricSampling = multivariate_extras[kk][4]
+                metricString = "%s[%s,%s,%s,%s]" % (
+                    metricname,
+                    metricfixed,
+                    metricmov,
+                    metricWeight,
+                    metricSampling,
+                )
+                syn_stage.append(metricString)
+
+        syn_stage.append("--convergence")
+        syn_stage.append(syn_convergence)
+        syn_stage.append("--shrink-factors")
+        syn_stage.append(syn_shrink_factors)
+        syn_stage.append("--smoothing-sigmas")
+        syn_stage.append(syn_smoothing_sigmas)
+
+        if (
+            subtype_of_transform == "b"
+            or subtype_of_transform == "br"
+            or subtype_of_transform == "bo"
+        ):
+            syn_stage.insert(0, "BSplineSyN[0.1," + str(spline_distance) + ",0,3]")
+            syn_stage.insert(0, "--transform")
+
+        if (
+            subtype_of_transform == "s"
+            or subtype_of_transform == "sr"
+            or subtype_of_transform == "so"
+        ):
+            syn_stage.insert(0, "SyN[0.1,3,0]")
+            syn_stage.insert(0, "--transform")
+
+        args = [
+            "-d",
+            str(fixed.dimension),
+            "-r"
+        ] + initx + [
+            "-o",
+            "[%s,%s,%s]" % (outprefix, wmo, wfo),
+        ]
+
+        if subtype_of_transform == "r" or subtype_of_transform == "t":
+            args.append(rigid_stage)
+        if subtype_of_transform == "a":
+            args.append(rigid_stage)
+            args.append(affine_stage)
+        if subtype_of_transform == "b" or subtype_of_transform == "s":
+            args.append(rigid_stage)
+            args.append(affine_stage)
+            args.append(syn_stage)
+        if subtype_of_transform == "br" or subtype_of_transform == "sr":
+            args.append(rigid_stage)
+            args.append(syn_stage)
+        if subtype_of_transform == "bo" or subtype_of_transform == "so":
+            args.append(syn_stage)
+
+        args.append("-x")
+        args.append(maskopt)
+
+        args = list(
+            itertools.chain.from_iterable(
+                itertools.repeat(x, 1) if isinstance(x, str) else x
+                for x in args
+            )
+        )
+
+    # ------------------------------------------------------------
+
+    if random_seed is not None:
+        args.append("--random-seed")
+        args.append(random_seed)
+
+    if restrict_transformation is not None:
+        args.append("-g")
+        args.append(restrict_transformationchar)
+
+    args.append("--float")
+    args.append(str(int(singleprecision)))
+    args.append("--write-composite-transform")
+    args.append(write_composite_transform * 1)
+    if verbose:
+        args.append("-v")
+        args.append("1")
+
+    processed_args = process_arguments(args)
+    libfn = get_lib_fn("antsRegistration")
+    if verbose:
+        print("antsRegistration " + ' '.join(processed_args))
+    reg_exit = libfn(processed_args)
+    if (reg_exit != 0):
+        raise RuntimeError(f"Registration failed with error code {reg_exit}")
+    afffns = glob.glob(outprefix + "*" + "[0-9]GenericAffine.mat")
+    fwarpfns = glob.glob(outprefix + "*" + "[0-9]Warp.nii.gz")
+    iwarpfns = glob.glob(outprefix + "*" + "[0-9]InverseWarp.nii.gz")
+    vfieldfns = glob.glob(outprefix + "*" + "[0-9]VelocityField.nii.gz")
+    # print(afffns, fwarpfns, iwarpfns)
+    if len(afffns) == 0:
+        afffns = ""
+    if len(fwarpfns) == 0:
+        fwarpfns = ""
+    if len(iwarpfns) == 0:
+        iwarpfns = ""
+    if len(vfieldfns) == 0:
+        vfieldfns = ""
+
+    alltx = sorted(
+        set(glob.glob(outprefix + "*" + "[0-9]*"))
+        - set(glob.glob(outprefix + "*VelocityField*"))
+    )
+    findinv = np.where(
+        [re.search("[0-9]InverseWarp.nii.gz", ff) for ff in alltx]
+    )[0]
+    findfwd = np.where([re.search("[0-9]Warp.nii.gz", ff) for ff in alltx])[
+        0
+    ]
+    if len(findinv) > 0:
+        fwdtransforms = list(
+            reversed(
+                [ff for idx, ff in enumerate(alltx) if idx != findinv[0]]
+            )
+        )
+        invtransforms = [
+            ff for idx, ff in enumerate(alltx) if idx != findfwd[0]
+        ]
+    else:
+        fwdtransforms = list(reversed(alltx))
+        invtransforms = alltx
+
+    if write_composite_transform:
+        fwdtransforms = outprefix + "Composite.h5"
+        invtransforms = outprefix + "InverseComposite.h5"
+
+    if not vfieldfns:
+        return {
+            "warpedmovout": warpedmovout.clone(inpixeltype),
+            "warpedfixout": warpedfixout.clone(inpixeltype),
+            "fwdtransforms": fwdtransforms,
+            "invtransforms": invtransforms,
+        }
+    else:
+        return {
+            "warpedmovout": warpedmovout.clone(inpixeltype),
+            "warpedfixout": warpedfixout.clone(inpixeltype),
+            "fwdtransforms": fwdtransforms,
+            "invtransforms": invtransforms,
+            "velocityfield": vfieldfns,
+        }
+
+def motion_correction(
+    image,
+    fixed=None,
+    type_of_transform="BOLDRigid",
+    mask=None,
+    fdOffset=50,
+    outprefix="",
+    verbose=False,
+    **kwargs
+):
+    """
+    Correct time-series data for motion.
+
+    ANTsR function: `antsrMotionCalculation`
+
+    Arguments
+    ---------
+        image: antsImage, usually ND where D=4.
+
+        fixed: Fixed image to register all timepoints to.  If not provided,
+            mean image is used.
+
+        type_of_transform : string
+            A linear or non-linear registration type. Mutual information metric and rigid transformation by default.
+            See ants registration for details.
+
+        mask: mask for image (ND-1).  If not provided, estimated from data.
+            2023-02-05: a performance change - previously, we estimated a mask
+            when None is provided and would pass this to the registration.  this
+            impairs performance if the mask estimate is bad.  in such a case, we
+            prefer no mask at all.  As such, we no longer pass the mask to the
+            registration when None is provided.
+
+        fdOffset: offset value to use in framewise displacement calculation
+
+        outprefix : string
+            output will be named with this prefix plus a numeric extension.
+
+        verbose: boolean
+
+        kwargs: keyword args
+            extra arguments - these extra arguments will control the details of registration that is performed. see ants registration for more.
+
+    Returns
+    -------
+    dict containing follow key/value pairs:
+        `motion_corrected`: Moving image warped to space of fixed image.
+        `motion_parameters`: transforms for each image in the time series.
+        `FD`: Framewise displacement generalized for arbitrary transformations.
+
+    Notes
+    -----
+    Control extra arguments via kwargs. see ants.registration for details.
+
+    Example
+    -------
+    >>> import ants
+    >>> fi = ants.image_read(ants.get_ants_data('ch2'))
+    >>> mytx = ants.motion_correction( fi )
+    """
+    idim = image.dimension
+    ishape = image.shape
+    nTimePoints = ishape[idim - 1]
+    if fixed is None:
+        wt = 1.0 / nTimePoints
+        fixed = ants.slice_image(image, axis=idim - 1, idx=0) * 0
+        for k in range(nTimePoints):
+            temp = ants.slice_image(image, axis=idim - 1, idx=k)
+            fixed = fixed + ants.iMath(temp,"Normalize") * wt
+    if mask is None:
+        mask = ants.get_mask(fixed)
+        useMask=None
+    else:
+        useMask=mask
+    FD = np.zeros(nTimePoints)
+    motion_parameters = list()
+    motion_corrected = list()
+    centerOfMass = mask.get_center_of_mass()
+    npts = pow(2, idim - 1)
+    pointOffsets = np.zeros((npts, idim - 1))
+    myrad = np.ones(idim - 1).astype(int).tolist()
+    mask1vals = np.zeros(int(mask.sum()))
+    mask1vals[round(len(mask1vals) / 2)] = 1
+    mask1 = ants.make_image(mask, mask1vals)
+    myoffsets = ants.get_neighborhood_in_mask(
+        mask1, mask1, radius=myrad, spatial_info=True
+    )["offsets"]
+
+    mycols = list("xy")
+    if idim - 1 == 3:
+        mycols = list("xyz")
+    useinds = list()
+    for k in range(myoffsets.shape[0]):
+        if abs(myoffsets[k, :]).sum() == (idim - 2):
+            useinds.append(k)
+        myoffsets[k, :] = myoffsets[k, :] * fdOffset / 2.0 + centerOfMass
+    fdpts = pd.DataFrame(data=myoffsets[useinds, :], columns=mycols)
+    if verbose:
+        print("Progress:")
+    counter = 0
+    for k in range(nTimePoints):
+        mycount = round(k / nTimePoints * 100)
+        if verbose and mycount == counter:
+            counter = counter + 10
+            print(mycount, end="%.", flush=True)
+        temp = ants.slice_image(image, axis=idim - 1, idx=k)
+        temp = ants.iMath(temp, "Normalize")
+        if temp.numpy().var() > 0:
+            if outprefix != "":
+                outprefixloc = outprefix + "_" + str.zfill( str(k), 5 ) + "_"
+                myreg = registration(
+                    fixed, temp, type_of_transform=type_of_transform, mask=useMask,
+                    outprefix=outprefixloc, **kwargs
+                )
+            else:
+                myreg = registration(
+                    fixed, temp, type_of_transform=type_of_transform, mask=useMask, **kwargs
+                )
+            fdptsTxI = ants.apply_transforms_to_points(
+                idim - 1, fdpts, myreg["fwdtransforms"]
+            )
+            if k > 0 and motion_parameters[k - 1] != "NA":
+                fdptsTxIminus1 = ants.apply_transforms_to_points(
+                    idim - 1, fdpts, motion_parameters[k - 1]
+                )
+            else:
+                fdptsTxIminus1 = fdptsTxI
+            # take the absolute value, then the mean across columns, then the sum
+            FD[k] = (fdptsTxIminus1 - fdptsTxI).abs().mean().sum()
+            motion_parameters.append(myreg["fwdtransforms"])
+            mywarped = ants.apply_transforms( fixed,
+                ants.slice_image(image, axis=idim - 1, idx=k),
+                myreg["fwdtransforms"] )
+            motion_corrected.append(mywarped)
+        else:
+            motion_parameters.append("NA")
+            motion_corrected.append(temp)
+
+    if verbose:
+        print("Done")
+    return {
+        "motion_corrected": ants.list_to_ndimage(image, motion_corrected),
+        "motion_parameters": motion_parameters,
+        "FD": FD,
+    }
+
+def label_image_registration(fixed_label_images, 
+                             moving_label_images,
+                             fixed_intensity_images=None,
+                             moving_intensity_images=None,
+                             fixed_mask=None,
+                             moving_mask=None,
+                             type_of_linear_transform='affine',
+                             type_of_deformable_transform='antsRegistrationSyNQuick[so]',
+                             label_image_weighting=1.0,
+                             output_prefix='',
+                             random_seed=None,
+                             verbose=False):
+
+    """
+    Perform pairwise registration using fixed and moving sets of label 
+    images (and, optionally, sets of corresponding intensity images).  
+
+    Arguments
+    ---------
+    fixed_label_images : single or list of ANTsImage
+        A single (or set of) fixed label image(s).
+
+    moving_label_images : single or list of ANTsImage
+        A single (or set of) moving label image(s).
+
+    fixed_intensity_images : single or list of ANTsImage
+        Optional---a single (or set of) fixed intensity image(s).
+
+    moving_intensity_images : single or list of ANTsImage
+        Optional---a single (or set of) moving intensity image(s).
+
+    fixed_mask : ANTsImage
+        Defines region for similarity metric calculation in the space
+        of the fixed image.
+        
+    moving_mask : ANTsImage
+        Defines region for similarity metric calculation in the space
+        of the moving image.
+        
+    type_of_linear_transform : string
+        Use label images with the centers of mass to a calculate linear 
+        transform of type 'rigid', 'similarity', or 'affine'.
+
+    type_of_deformable_transform : string
+        Only works with deformable-only transforms, specifically the family
+        of antsRegistrationSyN*[so] or antsRegistrationSyN*[bo] transforms.  
+        See 'type_of_transform' in ants.registration.  Additionally, one can
+        use a list to pass a more tailored deformably-only transform 
+        optimization using SyN or BSplineSyN transforms.  The order of 
+        parameters in the list would be 1) transform specification, i.e.
+        "SyN" or "BSplineSyN", 2) gradient (real), 3) intensity metric (string), 
+        4) intensity metric parameter (real), 5) convergence iterations per level 
+        (tuple) 6) smoothing factors per level (tuple), 7) shrink factors per level 
+        (tuple).  An example would type_of_deformable_transform = ["SyN", 0.2, "CC", 
+        4, (100,50,10), (2,1,0), (4,2,1)].
+
+    label_image_weighting : float or list of floats
+        Relative weighting for the label images.
+                    
+    output_prefix : string
+        Define the output prefix for the filenames of the output transform
+        files.    
+
+    random_seed : integer
+        Definition for deformable registration.
+
+    verbose : boolean
+        Print progress to the screen.
+
+    Returns
+    -------
+    Set of transforms definining the mapping to/from the fixed image domain 
+    to the moving image domain.
+
+    Example
+    -------
+    >>> import ants
+    >>>
+    >>> r16 = ants.image_read(ants.get_ants_data('r16'))
+    >>> r16_seg1 = ants.threshold_image(r16, "Kmeans", 3) - 1
+    >>> r16_seg2 = ants.threshold_image(r16, "Kmeans", 5) - 1
+    >>> r64 = ants.image_read(ants.get_ants_data('r64'))
+    >>> r64_seg1 = ants.threshold_image(r64, "Kmeans", 3) - 1
+    >>> r64_seg2 = ants.threshold_image(r64, "Kmeans", 5) - 1
+    >>> reg = ants.label_image_registration([r16_seg1, r16_seg2],
+                                            [r64_seg1, r64_seg2],  
+                                            fixed_intensity_images=r16,
+                                            moving_intensity_images=r64,
+                                            type_of_linear_transform='affine',
+                                            type_of_deformable_transform='antsRegistrationSyNQuick[bo]',
+                                            label_image_weighting=[1.0, 2.0],
+                                            verbose=True)
+    """
+
+    # Perform validation check on the input
+
+    if isinstance(fixed_label_images, ants.ANTsImage):
+        fixed_label_images = [ants.image_clone(fixed_label_images)]
+    if isinstance(moving_label_images, ants.ANTsImage):
+        moving_label_images = [ants.image_clone(moving_label_images)]
+
+    if len(fixed_label_images) != len(moving_label_images):
+        raise ValueError("The number of fixed and moving label images do not match.")
+
+    if fixed_intensity_images is not None or moving_intensity_images is not None:
+        if isinstance(fixed_intensity_images, ants.ANTsImage):
+            fixed_intensity_images = [ants.image_clone(fixed_intensity_images)]
+        if isinstance(moving_intensity_images, ants.ANTsImage):
+            moving_intensity_images = [ants.image_clone(moving_intensity_images)]
+        if len(fixed_intensity_images) != len(moving_intensity_images):
+            raise ValueError("The number of fixed and moving intensity images do not match.")
+
+    label_image_weights = list()
+    if isinstance(label_image_weighting, (int, float)):
+        label_image_weights = [label_image_weighting] * len(fixed_label_images)
+    else:
+        label_image_weights = tuple(label_image_weighting)
+        if len(fixed_label_images) != len(label_image_weights):
+            raise ValueError("The length of label_image_weights must" + 
+                             "match the number of label image pairs.")
+
+    image_dimension = fixed_label_images[0].dimension
+
+    if output_prefix == "" or output_prefix is None or len(output_prefix) == 0:
+        output_prefix = mktemp()
+
+    allowable_linear_transforms = ['rigid', 'similarity', 'affine']  
+    if not type_of_linear_transform in allowable_linear_transforms:
+        raise ValueError("Unrecognized linear transform.") 
+        
+    do_deformable = True
+    if type_of_deformable_transform is None or len(type_of_deformable_transform) == 0:
+       do_deformable = False
+
+    common_label_ids = list()
+    total_number_of_labels = 0
+    for i in range(len(fixed_label_images)):
+        fixed_label_geoms = ants.label_geometry_measures(fixed_label_images[i])
+        fixed_label_ids = np.array(fixed_label_geoms['Label'])
+        moving_label_geoms = ants.label_geometry_measures(moving_label_images[i])
+        moving_label_ids = np.array(moving_label_geoms['Label'])
+        common_label_ids.append(np.intersect1d(moving_label_ids, fixed_label_ids))
+        total_number_of_labels += len(common_label_ids[i])
+        if verbose:
+            print("Common label ids for image pair ", str(i), ": ", common_label_ids[i])
+        if len(common_label_ids[i]) == 0:
+            raise ValueError("No common labels for image pair " + str(i))
+    
+    if verbose:
+        print("Total number of labels: " + str(total_number_of_labels))
+
+    ##############################
+    #
+    #    Linear transform
+    #
+    ##############################
+
+    linear_xfrm = None
+    if type_of_linear_transform is not None:
+
+        if verbose:
+            print("\n\nComputing linear transform.\n")
+
+        if total_number_of_labels < 3:
+            raise ValueError("  Number of labels must be >= 3.") 
+
+        fixed_centers_of_mass = np.zeros((total_number_of_labels, image_dimension))     
+        moving_centers_of_mass = np.zeros((total_number_of_labels, image_dimension))
+        deformable_multivariate_extras = list()
+        
+        count = 0
+        for i in range(len(common_label_ids)):
+            for j in range(len(common_label_ids[i])):
+                label = common_label_ids[i][j]
+                if verbose:
+                    print("  Finding centers of mass for image pair " + str(i) + ", label " + str(label))
+                fixed_single_label_image = ants.threshold_image(fixed_label_images[i], label, label, 1, 0)
+                fixed_centers_of_mass[count, :] = ants.get_center_of_mass(fixed_single_label_image)
+                moving_single_label_image = ants.threshold_image(moving_label_images[i], label, label, 1, 0)
+                moving_centers_of_mass[count, :] = ants.get_center_of_mass(moving_single_label_image)
+                count += 1
+                if do_deformable:
+                    deformable_multivariate_extras.append(["MSQ", fixed_single_label_image, 
+                                                           moving_single_label_image, 
+                                                           label_image_weights[i], 0])
+            
+        linear_xfrm = ants.fit_transform_to_paired_points(moving_centers_of_mass, 
+                                                          fixed_centers_of_mass, 
+                                                          transform_type=type_of_linear_transform,
+                                                          verbose=verbose)
+        
+        linear_xfrm_file = output_prefix + "0GenericAffine.mat"
+        ants.write_transform(linear_xfrm, linear_xfrm_file) 
+
+    ##############################
+    #
+    #    Deformable transform
+    #
+    ##############################
+
+    if do_deformable:
+
+        if verbose:
+            print("\n\nComputing deformable transform using images.\n")
+
+        intensity_metric = "CC"
+        intensity_metric_parameter = 2
+        syn_shrink_factors = "8x4x2x1"
+        syn_smoothing_sigmas = "3x2x1x0vox"
+        syn_convergence = "[100x70x50x20,1e-6,10]"
+        spline_distance = 26
+        gradient_step = 0.1
+        syn_transform = "SyN"
+
+        syn_stage = list() 
+
+        if isinstance(type_of_deformable_transform, list):
+
+            if (len(type_of_deformable_transform) != 7 or
+                not isinstance(type_of_deformable_transform[0], str) or
+                not isinstance(type_of_deformable_transform[1], float) or
+                not isinstance(type_of_deformable_transform[2], str) or
+                not isinstance(type_of_deformable_transform[3], int) or 
+                not isinstance(type_of_deformable_transform[4], tuple) or 
+                not isinstance(type_of_deformable_transform[5], tuple) or 
+                not isinstance(type_of_deformable_transform[6], tuple)):
+                raise ValueError("Incorrect specification for type_of_deformable_transform.  See help menu.")            
+
+            syn_transform = type_of_deformable_transform[0]
+            gradient_step = type_of_deformable_transform[1]
+            intensity_metric = type_of_deformable_transform[2]
+            intensity_metric_parameter = type_of_deformable_transform[3]
+           
+            t = type_of_deformable_transform[4]
+            tstr = ''.join(map(lambda x: str(x) + 'x', t[:len(t)-1])) + str(t[len(t)-1])
+            syn_convergence = "[" + tstr + ",1e-6,10]"
+
+            t = type_of_deformable_transform[5]
+            tstr = ''.join(map(lambda x: str(x) + 'x', t[:len(t)-1])) + str(t[len(t)-1])
+            syn_smoothing_sigmas = tstr + "vox"
+
+            t = type_of_deformable_transform[6]
+            syn_shrink_factors = ''.join(map(lambda x: str(x) + 'x', t[:len(t)-1])) + str(t[len(t)-1])
+            
+        else:    
+
+            do_quick = False
+            if "Quick" in type_of_deformable_transform:
+                do_quick = True
+            elif "Repro" in type_of_deformable_transform:
+                random_seed = str(1)
+
+            if "[" in type_of_deformable_transform and "]" in type_of_deformable_transform:
+                subtype_of_deformable_transform = type_of_deformable_transform.split("[")[1].split("]")[0]
+                if not ('bo' in subtype_of_deformable_transform or 'so' in subtype_of_deformable_transform):
+                    raise ValueError("Only 'so' or 'bo' transforms are available.")
+                else:
+                    if 'bo' in subtype_of_deformable_transform:
+                        syn_transform = "BSplineSyN"
+                if "," in subtype_of_deformable_transform:
+                    subtype_of_deformable_transform_args = subtype_of_deformable_transform.split(",")
+                    subtype_of_deformable_transform = subtype_of_deformable_transform_args[0]
+                    intensity_metric_parameter = subtype_of_deformable_transform_args[1]
+                    if len(subtype_of_deformable_transform_args) > 2:
+                        spline_distance = subtype_of_deformable_transform_args[2]
+
+            if do_quick:
+                intensity_metric = "MI" 
+                if intensity_metric_parameter is None:
+                    intensity_metric_parameter = 32
+                syn_convergence = "[100x70x50x0,1e-6,10]"    
+
+        if fixed_intensity_images is not None and len(fixed_intensity_images) > 0:
+            for i in range(len(fixed_intensity_images)):
+                syn_stage.append("--metric")
+                metric_string = "%s[%s,%s,%s,%s]" % (
+                    intensity_metric,
+                    get_pointer_string(fixed_intensity_images[i]),
+                    get_pointer_string(moving_intensity_images[i]),
+                    1.0, intensity_metric_parameter)
+                syn_stage.append(metric_string)
+            
+        for kk in range(len(deformable_multivariate_extras)):
+            syn_stage.append("--metric")
+            metricString = "%s[%s,%s,%s,%s]" % (
+                "MSQ",
+                get_pointer_string(deformable_multivariate_extras[kk][1]),
+                get_pointer_string(deformable_multivariate_extras[kk][2]),
+                deformable_multivariate_extras[kk][3], 0.0)
+            syn_stage.append(metricString)     
+
+        syn_stage.append("--convergence")
+        syn_stage.append(syn_convergence)
+        syn_stage.append("--shrink-factors")
+        syn_stage.append(syn_shrink_factors)
+        syn_stage.append("--smoothing-sigmas")
+        syn_stage.append(syn_smoothing_sigmas)
+
+        if syn_transform == "SyN":
+            syn_stage.insert(0, "SyN[" + str(gradient_step) + ",3,0]")
+        else:
+            syn_stage.insert(0, "BSplineSyN[" + str(gradient_step) + "," + str(spline_distance) + ",0,3]")
+        syn_stage.insert(0, "--transform")
+
+        args = None
+        if linear_xfrm is None:
+          args = ["-d", str(image_dimension),
+                  "-o", output_prefix]
+        else:
+          args = ["-d", str(image_dimension),
+                  "-r", linear_xfrm_file,
+                  "-o", output_prefix]
+        args.append(syn_stage)
+
+        fixed_mask_string = 'NA' 
+        if fixed_mask is not None:
+            fixed_mask_binary = fixed_mask != 0
+            fixed_mask_string = get_pointer_string(fixed_mask_binary)
+
+        moving_mask_string = 'NA' 
+        if moving_mask is not None:
+            moving_mask_binary = moving_mask != 0
+            moving_mask_string = get_pointer_string(moving_mask_binary)
+
+        mask_option = "[%s,%s]" % (fixed_mask_string, moving_mask_string)
+        
+        args.append("-x")
+        args.append(mask_option)
+
+        args = list(itertools.chain.from_iterable(
+                    itertools.repeat(x, 1) 
+                    if isinstance(x, str) 
+                    else x for x in args)) 
+
+        args.append("--float")
+        args.append("1")
+
+        if random_seed is not None:
+            args.append("--random-seed")
+            args.append(random_seed)
+
+        if verbose:
+            args.append("-v")
+            args.append("1")
+
+        processed_args = process_arguments(args)
+        if verbose:
+            print("antsRegistration " + ' '.join(processed_args))
+
+        libfn = get_lib_fn("antsRegistration")
+        deformable_registration_exit_error = libfn(processed_args)
+
+        if deformable_registration_exit_error != 0:
+            raise RuntimeError(f"Registration failed with error code {deformable_registration_exit_error}")
+
+    all_xfrms = sorted(set(glob.glob(output_prefix + "*" + "[0-9]*")))
+    
+    find_inverse_warps = np.where([re.search("[0-9]InverseWarp.nii.gz", ff) for ff in all_xfrms])[0]
+    find_forward_warps = np.where([re.search("[0-9]Warp.nii.gz", ff) for ff in all_xfrms])[0]
+
+    if len(find_inverse_warps) > 0:
+        fwdtransforms = [all_xfrms[find_forward_warps[0]], linear_xfrm_file]
+        invtransforms = [linear_xfrm_file, all_xfrms[find_inverse_warps[0]]]
+    else:
+        fwdtransforms = [linear_xfrm_file]
+        invtransforms = [linear_xfrm_file]
+
+    if verbose:
+        print("\n\nResulting transforms")
+        print("  fwdtransforms: ", fwdtransforms)        
+        print("  invtransforms: ", invtransforms)        
+
+    return {
+        "fwdtransforms": fwdtransforms,
+        "invtransforms": invtransforms,
+    }
+
+

MindEyeV2/antspy/ants/registration/simulate_displacement_field.py

@@ -0,0 +1,90 @@
+__all__ = ["simulate_displacement_field"]
+
+import numpy as np
+
+
+import ants
+from ants.internal import get_lib_fn
+
+
+
+def simulate_displacement_field(domain_image, 
+                                field_type="bspline", 
+                                number_of_random_points=1000, 
+                                sd_noise=10.0,
+                                enforce_stationary_boundary=True,
+                                number_of_fitting_levels=4,
+                                mesh_size=1,
+                                sd_smoothing=4.0):
+    """
+    simulate displacement field using either b-spline or exponential transform
+
+    ANTsR function: `simulateDisplacementField`
+
+    Arguments
+    ---------
+    domain_image : ANTsImage
+        Domain image
+
+    field_type : string
+        Either "bspline" or "exponential".
+
+    number_of_random_points : integer
+        Number of displacement points.
+
+    sd_noise : float
+        Standard deviation of the displacement field noise.
+
+    enforce_stationary_boundary : boolean
+        Determines fixed boundary conditions.
+
+    number_of_fitting_levels : integer
+        Number of fitting levels (b-spline only).
+
+    mesh_size : integer or n-D tuple
+        Determines fitting resolution at base level (b-spline only).
+
+    sd_smoothing : float
+        Standard deviation of the Gaussian smoothing in mm (exponential only).
+        
+    Returns
+    -------
+    ANTs vector image.
+
+    Example
+    -------
+    >>> import ants
+    >>> domain = ants.image_read( ants.get_ants_data('r16'))
+    >>> exp_field = ants.simulate_displacement_field(domain, field_type="exponential")
+    >>> bsp_field = ants.simulate_displacement_field(domain, field_type="bspline")
+    >>> bsp_xfrm = ants.transform_from_displacement_field(bsp_field * 3)
+    >>> domain_warped = ants.apply_ants_transform_to_image(bsp_xfrm, domain, domain)
+    """
+
+    image_dimension = domain_image.dimension
+
+    if field_type == 'bspline':
+        if isinstance(mesh_size, int) == False and len(mesh_size) != image_dimension:
+            raise ValueError("Incorrect specification for mesh_size.")
+
+        spline_order = 3
+        number_of_control_points = mesh_size + spline_order
+
+        if isinstance(number_of_control_points, int) == True:
+            number_of_control_points = np.repeat(number_of_control_points, image_dimension)
+
+        libfn = get_lib_fn("simulateBsplineDisplacementField%iD" % image_dimension)
+        field = libfn(domain_image.pointer, number_of_random_points, sd_noise, 
+                      enforce_stationary_boundary, number_of_fitting_levels, number_of_control_points)
+        bspline_field = ants.from_pointer(field).clone('float')
+        return bspline_field
+
+    elif field_type == 'exponential':
+        libfn = get_lib_fn("simulateExponentialDisplacementField%iD" % image_dimension)
+        field = libfn(domain_image.pointer, number_of_random_points, sd_noise, 
+                      enforce_stationary_boundary, sd_smoothing)
+        exp_field = ants.from_pointer(field).clone('float')
+        return exp_field
+
+    else:  
+        raise ValueError("Unrecognized field type.")

MindEyeV2/src/slurms/458689.out

@@ -0,0 +1,4 @@
+MASTER_ADDR=ip-10-0-158-103
+MASTER_PORT=11437
+WORLD_SIZE=1
+model_name=semantic_cluster_1.2_average_after_wd-2_no_prior_multi

MindEyeV2/src/slurms/458711.out

@@ -0,0 +1,135 @@
+MASTER_ADDR=ip-10-0-128-54
+MASTER_PORT=13306
+WORLD_SIZE=1
+model_name=semantic_cluster_1.2_average_after_wd-2_no_prior_multi
+Top-1 Precision: 0.00%
+LOCAL RANK  0
+PID of this process = 1462175
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [2 3 4 5 6 7 8] num_sessions 40
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+batch_size = 3 num_iterations_per_epoch = 1428 num_samples_per_epoch = 30000
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/train/{0..39}.tar
+num_voxels for subj02: 14278
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj03/train/{0..31}.tar
+num_voxels for subj03: 15226
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj04/train/{0..29}.tar
+num_voxels for subj04: 13153
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj05/train/{0..39}.tar
+num_voxels for subj05: 13039
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj06/train/{0..31}.tar
+num_voxels for subj06: 17907
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj07/train/{0..39}.tar
+num_voxels for subj07: 12682
+Training with 40 sessions
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar
+num_voxels for subj08: 14386
+Loaded all subj train dls and betas!
+
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar
+Loaded test dl for subj2!
+
+Loaded all 73k possible NSD images to cpu! (73000, 3, 224, 224)
+param counts:
+103,094,272 total
+103,094,272 trainable
+param counts:
+103,094,272 total
+103,094,272 trainable
+torch.Size([2, 1, 14278]) torch.Size([2, 1, 1024])
+param counts:
+453,360,280 total
+453,360,280 trainable
+param counts:
+556,454,552 total
+556,454,552 trainable
+b.shape torch.Size([2, 1, 1024])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+816,319,768 total
+816,319,752 trainable
+semantic_cluster_onehot.shape torch.Size([73000, 41])
+num_seman_clusters 41
+25198
+4018
+43195
+71165
+46430
+param counts:
+17,465,385 total
+17,465,385 trainable
+param counts:
+833,785,153 total
+833,785,137 trainable
+total_steps 214200
+
+Done with model preparations!
+param counts:
+833,785,153 total
+833,785,137 trainable
+wandb mindeye_semantic_cluster_0.2 run semantic_cluster_1.2_average_after_wd-2_no_prior_multi
+wandb_config:
+ {'model_name': 'semantic_cluster_1.2_average_after_wd-2_no_prior_multi', 'global_batch_size': '21', 'batch_size': 3, 'num_epochs': 150, 'num_sessions': 40, 'num_params': 833785137, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': False, 'max_lr': 3e-05, 'mixup_pct': 0.33, 'num_samples_per_epoch': 30000, 'num_test': 3000, 'ckpt_interval': 999, 'ckpt_saving': True, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1, 'train_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj08/train/{0..29}.tar', 'test_url': '/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj02/new_test/0.tar'}
+wandb_id: semantic_cluster_1.2_average_after_wd-2_no_prior_multi
+semantic_cluster_1.2_average_after_wd-2_no_prior_multi starting with epoch 0 / 150
+loss_SM 4.119326591491699
+loss_SM 3.8062686920166016
+loss_SM 3.625744104385376
+loss_SM 3.795665979385376
+loss_SM 3.7455356121063232
+loss_SM 3.976097583770752
+loss_SM 3.781947612762451
+loss_SM 3.6605281829833984
+loss_SM 3.5571987628936768
+loss_SM 3.4420573711395264
+loss_SM 4.0613837242126465
+loss_SM 3.6241164207458496
+loss_SM 3.496047258377075
+loss_SM 3.7202847003936768
+loss_SM 3.770786762237549
+loss_SM 3.5442707538604736
+loss_SM 3.864955425262451
+loss_SM 3.5894718170166016
+loss_SM 3.7825520038604736
+loss_SM 4.742745399475098
+loss_SM 3.456333637237549
+loss_SM 3.6668992042541504
+loss_SM 4.704915523529053
+loss_SM 3.688209056854248
+loss_SM 4.23974609375
+loss_SM 4.481863975524902
+loss_SM 3.4336636066436768
+loss_SM 4.053106307983398
+loss_SM 4.140625
+loss_SM 5.718982696533203
+loss_SM 4.348353862762451
+loss_SM 3.981166362762451
+loss_SM 4.858863353729248
+loss_SM 4.771158695220947
+loss_SM 3.880603551864624
+loss_SM 4.3950018882751465
+loss_SM 6.392113208770752
+loss_SM 3.8019206523895264
+loss_SM 5.100527763366699
+loss_SM 4.1439032554626465
+loss_SM 6.9605889320373535
+loss_SM 5.183436870574951
+[2024-07-10 02:10:10,985] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)

MindEyeV2/src/slurms/466067.out

@@ -0,0 +1,54 @@
+MASTER_ADDR=ip-10-0-133-122
+MASTER_PORT=15846
+WORLD_SIZE=1
+model_name=augmented_image_one
+LOCAL RANK  0
+PID of this process = 2199630
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 14
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+batch_size = 21 num_iterations_per_epoch = 250 num_samples_per_epoch = 5254
+param counts:
+6,905,856 total
+6,905,856 trainable
+param counts:
+6,905,856 total
+6,905,856 trainable
+torch.Size([2, 1, 1685]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+1,894,767,256 total
+1,894,767,256 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,154,632,472 total
+2,154,632,456 trainable
+total_steps 20000
+
+Done with model preparations!
+param counts:
+2,154,632,472 total
+2,154,632,456 trainable
+wandb bold5000 run augmented_image_one
+wandb_config:
+ {'model_name': 'augmented_image_one', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 80, 'num_sessions': 14, 'num_params': 2154632456, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 5254, 'num_test': 370, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+wandb_id: augmented_image_one
+augmented_image_one starting with epoch 0 / 80
+
+===Finished!===
+

MindEyeV2/src/slurms/534014.out

@@ -0,0 +1,889 @@
+MASTER_ADDR=ip-10-0-139-113
+MASTER_PORT=11065
+final_subj01_pretrained_20sess_24bs
+device: cuda
+torch.Size([18, 1, 15724]) torch.Size([18, 3, 425, 425])
+torch.Size([18, 1, 15724])
+param counts:
+83,653,863 total
+0 trainable
+param counts:
+64,409,600 total
+64,409,600 trainable
+param counts:
+1,903,020,028 total
+1,903,020,028 trainable
+param counts:
+1,967,429,628 total
+1,967,429,628 trainable
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,227,294,844 total
+2,227,294,828 trainable
+
+---loading /weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_20sess_24bs/last.pth ckpt---
+
+[2024-11-07 03:38:28,497] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+Processing zero checkpoint '/weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_20sess_24bs/last'
+Detected checkpoint of type zero stage ZeroStageEnum.gradients, world_size: 8
+Parsing checkpoint created by deepspeed==0.12.2
+Reconstructed Frozen fp32 state dict with 1 params 16 elements
+Reconstructed fp32 state dict with 230 params 2227294828 elements
+ckpt loaded!
+Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False
+Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+vector_suffix torch.Size([1, 1024])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a lamp on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a motorcycle is parked on the side of the road.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a view']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a variety of items.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large display of items.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of people around it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a chair that you sit in.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a wooden bench with a large amount of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a car.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a fire hydrant is next to a sidewalk.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large room with a table and chairs.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white sign']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a motorcycle parked next to a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a woman standing in front of a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large display of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a cat sitting on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bathroom with a sink and a mirror.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of trees and a building.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a wooden fence with a white base.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a car and a motorcycle.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a piece of wood on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a kitchen with a counter and a refrigerator.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a large room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a cat sitting on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large white building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a fire hydrant is in the foreground.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing in a room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items in a room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a motorcycle.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a counter with a lot of items on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a woman sitting in a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden structure.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a cat sitting on a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white fire hydrant']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items in a room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing in front of a bed.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a very old looking room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of stuff on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a wooden bench with a large back.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a cat sitting on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a flower pot is on the table.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bench with a plant on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a vase and a plant on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white bus']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a stuffed animal.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large parking lot with a lot of parked cars.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large piece of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a woman sitting in a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a view of a large room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a fire hydrant is in the foreground.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large bed with a red cover.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a motorcycle.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a woman is standing in front of a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a cat sitting on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of stuff on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a fire hydrant in a garden.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed or beds in a room at the hotel']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a stuffed animal.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a chair that you sit in.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden structure.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large white building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plant with a flower in it.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bench with a plant in it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a chair that you sit in.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a picture of a room.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of various items.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of a stuffed animal.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a stuffed toy.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large group of luggage.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a mirror']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of stuff on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large white and red chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a planter with a plant']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a wooden bench with a plant on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large window with a view of a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing in front of a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of items for sale.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a motorcycle is parked on the side of the road.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a bed and a table']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a woman standing in front of a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large wooden bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large room with a lot of furniture.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plant with a flower in it.']
+torch.Size([18, 3, 256, 256])
+torch.Size([18, 10, 3, 256, 256])
+saved final_subj01_pretrained_20sess_24bs outputs!
+device: cuda
+final_subj01_pretrained_20sess_24bs
+torch.Size([18, 3, 425, 425]) torch.Size([18, 10, 3, 768, 768]) torch.Size([18, 10, 256, 1664]) torch.Size([18, 10, 3, 768, 768]) (18, 10)
+Initialized embedder #0: FrozenCLIPEmbedder with 123060480 params. Trainable: False
+Initialized embedder #1: FrozenOpenCLIPEmbedder2 with 694659841 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #3: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #4: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Restored from /weka/proj-medarc/shared/mindeyev2_dataset/zavychromaxl_v30.safetensors with 1 missing and 1 unexpected keys
+Missing Keys: ['denoiser.sigmas']
+Unexpected Keys: ['conditioner.embedders.0.transformer.text_model.embeddings.position_ids']
+crossattn torch.Size([1, 77, 2048])
+vector_suffix torch.Size([1, 1536])
+---
+crossattn_uc torch.Size([1, 77, 2048])
+vector_uc torch.Size([1, 2816])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+final_enhancedrecons torch.Size([18, 10, 3, 256, 256])
+saved evals/final_subj01_pretrained_20sess_24bs/final_subj01_pretrained_20sess_24bs_all_enhancedrecons_imagery.pt
+device: cuda
+torch.Size([18, 1, 15724]) torch.Size([18, 3, 425, 425])
+torch.Size([18, 1, 15724])
+param counts:
+83,653,863 total
+0 trainable
+param counts:
+64,409,600 total
+64,409,600 trainable
+param counts:
+1,903,020,028 total
+1,903,020,028 trainable
+param counts:
+1,967,429,628 total
+1,967,429,628 trainable
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,227,294,844 total
+2,227,294,828 trainable
+
+---loading /weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_20sess_24bs/last.pth ckpt---
+
+[2024-11-07 04:05:42,120] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+Processing zero checkpoint '/weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_20sess_24bs/last'
+Detected checkpoint of type zero stage ZeroStageEnum.gradients, world_size: 8
+Parsing checkpoint created by deepspeed==0.12.2
+Reconstructed Frozen fp32 state dict with 1 params 16 elements
+Reconstructed fp32 state dict with 230 params 2227294828 elements
+ckpt loaded!
+Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False
+Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+vector_suffix torch.Size([1, 1024])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed and a bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white building']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white building']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing next to a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer is riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a bunch of people on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people sitting down.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a person is standing in front of a car.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate of food on a table.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed and a bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing next to a car.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a traffic light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large white and black boat.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a bench next to a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer is riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a bunch of people on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large brown tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people standing around each other.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a beach next to a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of animals standing around.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man is sitting on a chair.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a plate of food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed and a bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man riding a bike on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white skateboard']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large display of animals.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing next to a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer is riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a lot of people on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people sitting down.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a person is sitting down.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large bed with a table cloth.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white car']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small building with a large window.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large water fountain.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a sidewalk next to a building.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer riding a wave on a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a bunch of people on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a couple of people standing around each other.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man is standing next to a motorcycle.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table filled with lots of food.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate of food on a table.']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed with a white sheet and a blue sheet and a white sheet and a brown blanket.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a motorcycle is parked on the side of the road.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small area with a lot of stuff on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large statue of a person.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer is riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a lot of people on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate of food on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a stuffed toy bear.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a beach next to a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of animals standing on top of a grass covered field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a motor bike is parked on the side of the road.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed and a bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white motorcycle']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street sign and a street sign']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white car']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large display of animals.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man sitting on a bench next to a bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a lot of people on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people sitting down.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white motorcycle']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a plate of food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed and a bed']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man riding a bike down a street.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a small building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree with a few leaves.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing next to a bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a bunch of people on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people standing around each other.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a room with a bed and a table']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white car']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street sign and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white sign']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large statue of a bird.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a couple of people standing on a bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer is riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a beach and a beach with a few people.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people sitting down.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a beach next to a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of animals standing around.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a piece of luggage sitting on a table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with a bunch of food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large white and red table.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white motorcycle']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street light and a street sign.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped sign']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large statue of a person.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing next to a bench.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a bunch of people on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a plate of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a display of stuffed animals.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a beach next to a body of water.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of animals standing around.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a bed with a blanket and a blanket.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a car is parked on the street.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a street sign and a pole.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a skateboard on a sidewalk']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large building with a lot of windows.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on a bench next to a tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a surfer riding a wave.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a beach with a lot of people on it.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a large tree.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a street with a lot of traffic.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of people standing around each other.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a man standing on top of a surfboard.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a zebra standing in a field.']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a group of trees']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a red and white striped chair']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a table with a bunch of food on it']
+torch.Size([1, 15724]) torch.Size([1, 15724])
+['a plate with food on it']
+torch.Size([18, 3, 256, 256])
+torch.Size([18, 10, 3, 256, 256])
+saved final_subj01_pretrained_20sess_24bs outputs!
+device: cuda
+final_subj01_pretrained_20sess_24bs
+torch.Size([18, 3, 425, 425]) torch.Size([18, 10, 3, 768, 768]) torch.Size([18, 10, 256, 1664]) torch.Size([18, 10, 3, 768, 768]) (18, 10)
+Initialized embedder #0: FrozenCLIPEmbedder with 123060480 params. Trainable: False
+Initialized embedder #1: FrozenOpenCLIPEmbedder2 with 694659841 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #3: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #4: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Restored from /weka/proj-medarc/shared/mindeyev2_dataset/zavychromaxl_v30.safetensors with 1 missing and 1 unexpected keys
+Missing Keys: ['denoiser.sigmas']
+Unexpected Keys: ['conditioner.embedders.0.transformer.text_model.embeddings.position_ids']
+crossattn torch.Size([1, 77, 2048])
+vector_suffix torch.Size([1, 1536])
+---
+crossattn_uc torch.Size([1, 77, 2048])
+vector_uc torch.Size([1, 2816])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+all_enhancedrecons torch.Size([10, 3, 256, 256])
+final_enhancedrecons torch.Size([18, 10, 3, 256, 256])
+saved evals/final_subj01_pretrained_20sess_24bs/final_subj01_pretrained_20sess_24bs_all_enhancedrecons_vision.pt

MindEyeV2/src/slurms/534074.err

@@ -0,0 +1,46 @@
+[NbConvertApp] Converting notebook enhanced_recon_inference_old.ipynb to python
+[NbConvertApp] Writing 13074 bytes to enhanced_recon_inference_old.py
+[NbConvertApp] Converting notebook recon_inference_old.ipynb to python
+[NbConvertApp] Writing 17064 bytes to recon_inference_old.py
+/admin/home-ckadirt/fmri/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.
+  warnings.warn(
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 10. Setting context_dim to [1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.
+WARNING:sgm.modules.attention:SpatialTransformer: Found context dims [1664] of depth 1, which does not match the specified 'depth' of 2. Setting context_dim to [1664, 1664] now.
+
  0%|          | 0/1000 [00:00<?, ?it/s]
+
+
+
+
+/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/utils/checkpoint.py:429: UserWarning: torch.utils.checkpoint: please pass in use_reentrant=True or use_reentrant=False explicitly. The default value of use_reentrant will be updated to be False in the future. To maintain current behavior, pass use_reentrant=True. It is recommended that you use use_reentrant=False. Refer to docs for more details on the differences between the two variants.
+  warnings.warn(
+/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/utils/checkpoint.py:61: UserWarning: None of the inputs have requires_grad=True. Gradients will be None
+  warnings.warn(
+
  0%|          | 0/1000 [00:08<?, ?it/s]
+Traceback (most recent call last):
+  File "/weka/proj-fmri/ckadirt/MindEyeV2/src/recon_inference_old.py", line 446, in <module>
+    if plotting:
+       ^^^^^^^^
+NameError: name 'plotting' is not defined
+Traceback (most recent call last):
+  File "/weka/proj-fmri/ckadirt/MindEyeV2/src/enhanced_recon_inference_old.py", line 100, in <module>
+    all_recons = torch.load(f"evals/{model_name}/{model_name}_all_recons.pt") # these are the unrefined MindEye2 recons!
+                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/serialization.py", line 986, in load
+    with _open_file_like(f, 'rb') as opened_file:
+         ^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/serialization.py", line 435, in _open_file_like
+    return _open_file(name_or_buffer, mode)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/serialization.py", line 416, in __init__
+    super().__init__(open(name, mode))
+                     ^^^^^^^^^^^^^^^^
+FileNotFoundError: [Errno 2] No such file or directory: 'evals/final_subj01_pretrained_3sess_24bs/final_subj01_pretrained_3sess_24bs_all_recons.pt'

MindEyeV2/src/slurms/534074.out

@@ -0,0 +1,44 @@
+MASTER_ADDR=ip-10-0-150-188
+MASTER_PORT=13997
+final_subj01_pretrained_3sess_24bs
+new_sessions
+device: cuda
+num_voxels for subj01: 15724
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar
+Loaded test dl for subj1!
+
+0 3000 3000 1000
+param counts:
+83,653,863 total
+0 trainable
+param counts:
+64,409,600 total
+64,409,600 trainable
+param counts:
+1,903,020,028 total
+1,903,020,028 trainable
+param counts:
+1,967,429,628 total
+1,967,429,628 trainable
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,227,294,844 total
+2,227,294,828 trainable
+
+---loading /weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last.pth ckpt---
+
+[2024-11-07 02:45:52,200] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+Processing zero checkpoint '/weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last'
+Detected checkpoint of type zero stage ZeroStageEnum.gradients, world_size: 8
+Parsing checkpoint created by deepspeed==0.12.2
+Reconstructed Frozen fp32 state dict with 1 params 16 elements
+Reconstructed fp32 state dict with 230 params 2227294828 elements
+ckpt loaded!
+Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False
+Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+vector_suffix torch.Size([1, 1024])
+['a group of people sitting around a table.']
+device: cuda

MindEyeV2/src/slurms/534079.out

@@ -0,0 +1,1062 @@
+MASTER_ADDR=ip-10-0-150-188
+MASTER_PORT=17419
+final_subj01_pretrained_3sess_24bs
+new_sessions
+device: cuda
+num_voxels for subj01: 15724
+/weka/proj-medarc/shared/mindeyev2_dataset/wds/subj01/new_test/0.tar
+Loaded test dl for subj1!
+
+0 3000 3000 1000
+param counts:
+83,653,863 total
+0 trainable
+param counts:
+64,409,600 total
+64,409,600 trainable
+param counts:
+1,903,020,028 total
+1,903,020,028 trainable
+param counts:
+1,967,429,628 total
+1,967,429,628 trainable
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,227,294,844 total
+2,227,294,828 trainable
+
+---loading /weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last.pth ckpt---
+
+[2024-11-07 02:53:00,068] [INFO] [real_accelerator.py:191:get_accelerator] Setting ds_accelerator to cuda (auto detect)
+Processing zero checkpoint '/weka/proj-fmri/ckadirt/MindEyeV2/train_logs/final_subj01_pretrained_3sess_24bs/last'
+Detected checkpoint of type zero stage ZeroStageEnum.gradients, world_size: 8
+Parsing checkpoint created by deepspeed==0.12.2
+Reconstructed Frozen fp32 state dict with 1 params 16 elements
+Reconstructed fp32 state dict with 230 params 2227294828 elements
+ckpt loaded!
+Initialized embedder #0: FrozenOpenCLIPImageEmbedder with 1909889025 params. Trainable: False
+Initialized embedder #1: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+vector_suffix torch.Size([1, 1024])
+['a group of people sitting around a table.']
+['a man standing in front of a counter.']
+['a surfer riding a wave.']
+['a giraffe standing in the grass.']
+['a city street with a lot of traffic.']
+['a plate of food']
+['a piece of paper sitting on a table.']
+['a man standing on top of a field.']
+['a cat sitting on top of a wooden bench.']
+['a surfer riding a wave.']
+['a plane is parked on the runway.']
+['a surfer on a surfboard in the ocean.']
+['a large grassy area.']
+['a woman sitting in a chair next to a couch.']
+['a large train on a steel track.']
+['a room with a lot of furniture.']
+['a man sitting down in a chair.']
+['a boat on a body of water.']
+['a young girl is playing with a frisbee.']
+['a bathroom with a toilet and sink.']
+['a child is holding a toy.']
+['a group of people standing around each other.']
+['a clock tower with a tower in the background.']
+['a man and a woman are walking together.']
+['a large grassy area.']
+['a man sitting in a chair next to a table.']
+['a plate of food with a spoon.']
+['a plane is parked on the runway.']
+['a couple of birds standing on top of a water.']
+['a man sitting on a bench next to a wall.']
+['a plate of food with a bowl of fruit on it.']
+['a kitchen with a table and chairs.']
+['a room with a lot of furniture.']
+['a white bathroom with a toilet and a sink.']
+['a plate of food with a fork on it.']
+['a train is driving through a city.']
+['a bus driving down a street.']
+['a plate of food']
+['a man standing on a sidewalk.']
+['a boat is parked on the water.']
+['a woman standing on a tennis court.']
+['a giraffe standing in a field.']
+['a truck parked next to a truck.']
+['a large herd of cattle.']
+['a vase with flowers on it.']
+['a kite is flying in the sky.']
+['a plate of food']
+['a truck is parked on the side of the road.']
+['a street with a car and a bus.']
+['a woman standing on a sidewalk.']
+['a tree with a lot of leaves.']
+['a man standing on a sidewalk.']
+['a large group of people standing around a building.']
+['a plane flying in the sky.']
+['a car is parked on the side of the road.']
+['a large building with a clock on it.']
+['a bicycle parked on the side of a road.']
+['a large body of water.']
+['a plate of food']
+['a baseball player is standing in front of a bat.']
+['a man standing on a sidewalk next to a building.']
+['a room with a lot of furniture.']
+['a man standing on a tennis court.']
+['a plate of food']
+['a man standing on a sidewalk.']
+['a table with food on it']
+['a surfer riding a wave.']
+['a man riding a skateboard.']
+['a group of people standing around each other.']
+['a zebra standing in the grass.']
+['a clock tower with a clock on it.']
+['a surfer riding a wave.']
+['a giraffe standing next to a tree.']
+['a plate of food with a fork.']
+['a large field with a lot of grass and a kite.']
+['a bus driving down a street.']
+['a kite flying in the sky over a field.']
+['a man sitting down next to a table.']
+['a table with a bunch of food on it']
+['a plate with food on it']
+['a small stuffed animal.']
+['a train is driving down the tracks.']
+['a giraffe standing next to a tree.']
+['a large open area with a lot of people walking around.']
+['a large field with a bunch of animals in it']
+['a surfer on a surfboard.']
+['a man standing on a tennis court.']
+['a large brown and white cat.']
+['a man standing on a sidewalk.']
+['a man standing on a skateboard.']
+['a herd of cattle grazing on a lush green field.']
+['a room with a lot of furniture.']
+['a street with a car and a car']
+['a table with a plate on it']
+['a clock on a building.']
+['a plate of food with a spoon.']
+['a surfer riding a wave.']
+['a bunch of different types of food.']
+['a cat laying on a bed next to a wall.']
+['a kitchen with a lot of counter space.']
+['a group of people sitting around a table.']
+['a building with a clock on it.']
+['a man riding a bike down a street.']
+['a dog is standing in the grass.']
+['a skateboarder is riding on a skateboard.']
+['a bathroom with a toilet and a sink.']
+['a bird is standing on a piece of wood.']
+['a large grassy field.']
+['a man riding a surfboard on top of a wave.']
+['a vintage car parked in front of a building.']
+['a large building with a clock on it.']
+['a skateboarder is standing on a sidewalk.']
+['a room with a view']
+['a surfer on a surfboard in the ocean.']
+['a plate of food']
+['a plane is parked on the runway.']
+['a man standing next to a woman.']
+['a man standing on top of a lush green field.']
+['a man standing on a sidewalk.']
+['a plate of food with a fork']
+['a large jetliner sitting on top of a runway.']
+['a group of people sitting on top of a building.']
+['a bathroom with a sink and a mirror.']
+['a bathroom with a toilet and a sink.']
+['a man on a skateboard in a park.']
+['a plate of food with a knife.']
+['a kitchen with a lot of furniture.']
+['a room with a table and chairs']
+['a woman standing on a sidewalk next to a building.']
+['a small kitchen with a lot of furniture.']
+['a tree in a field']
+['a man on a surfboard in the water.']
+['a table with a bunch of chairs']
+['a man standing on top of a beach.']
+['a herd of cattle grazing on a lush green field.']
+['a man wearing a suit and tie.']
+['a man and a woman on a sidewalk.']
+['a boat is parked on the water.']
+['a giraffe standing in a field.']
+['a kitchen with a sink and a counter.']
+['a plate of food.']
+['a group of animals standing on top of a grass covered field.']
+['a white and black picture of a room.']
+['a group of people sitting down.']
+['a bathroom with a toilet and sink.']
+['a large building with a clock on it.']
+['a table with a bunch of items on it']
+['a field with a few animals in it.']
+['a plane flying in the sky.']
+['a tree with a lot of leaves.']
+['a plane is flying in the air.']
+['a surfer riding a wave.']
+['a plate of food with a fork.']
+['a street with a fire hydrant and a building.']
+['a skier is skiing down a hill.']
+['a zebra standing in a field.']
+['a group of people standing around a field.']
+['a kitchen with a counter and a sink.']
+['a man is holding a cell phone.']
+['a large grassy area.']
+['a room with a view']
+['a young child is laying down on a bed.']
+['a man standing on a tennis court.']
+['a man riding a bike down a street.']
+['a bathroom with a toilet and sink.']
+['a bus driving down a street.']
+['a bus driving down a street.']
+['a table with a bunch of chairs']
+['a man standing on top of a beach next to a surfboard.']
+['a building with a clock on it.']
+['a young man playing a game of tennis.']
+['a street with a lot of cars parked on it.']
+['a clock on a wall']
+['a surfer riding a wave.']
+['a large body of water']
+['a plane is parked on the runway.']
+['a plate of food with a bowl of food on it.']
+['a man is sitting down and looking at the camera.']
+['a glass vase filled with flowers.']
+['a man standing on a field.']
+['a dog on a beach near a body of water.']
+['a train is parked on the tracks.']
+['a bathroom with a toilet and sink.']
+['a skier is skiing down a hill.']
+['a woman is sitting in a chair.']
+['a large building with a clock on it.']
+['a man on a beach with a surfboard.']
+['a group of animals standing around.']
+['a man standing next to a wall.']
+['a large elephant is standing in the grass.']
+['a bench with a bench']
+['a large tree.']
+['a large building with a clock on it.']
+['a motorcycle parked on the side of a road.']
+['a cat sitting on a bench.']
+['a group of people standing around each other.']
+['a bathroom with a toilet and a sink.']
+['a bus driving down a street.']
+['a zebra standing on a dirt field.']
+['a train is driving down the tracks.']
+['a group of people standing on top of a beach.']
+['a group of people standing on top of a field.']
+['a train is parked on the side of the road.']
+['a man on a snowboard in the snow.']
+['a large group of people on a field.']
+['a plate of food with a bowl of food on it.']
+['a train driving down a street next to a building.']
+['a clock tower with a clock on it.']
+['a clock on a building.']
+['a group of people standing around each other.']
+['a clock on a wall']
+['a train is driving down the tracks.']
+['a train is driving down the tracks.']
+['a kitchen with a sink and a counter.']
+['a room with a table and chairs']
+['a plane is flying in the sky.']
+['a bus driving down a street.']
+['a surfer riding a wave.']
+['a group of people sitting down.']
+['a plate of food.']
+['a man standing next to a woman.']
+['a clock tower on a building.']
+['a herd of cattle grazing on a field.']
+['a woman holding a cell phone.']
+['a large tree with a few leaves.']
+['a large body of water.']
+['a large blue sky.']
+['a motorcycle parked on the side of a road.']
+['a zebra standing in the grass.']
+['a plate of food with a fork.']
+['a train is driving down the tracks.']
+['a train is parked on the tracks.']
+['a small kitchen with a lot of stuff on the counter.']
+['a man standing next to a building.']
+['a truck parked on the side of a road.']
+['a child with a toy.']
+['a man standing on top of a lush green field.']
+['a large elephant standing in a field.']
+['a man standing on a bench.']
+['a kite is flying in the sky.']
+['a cat sitting on top of a table.']
+['a large body of water.']
+['a large field with a train and a large field with a lot of grass.']
+['a man riding a skateboard on top of a snow covered slope.']
+['a man riding a skateboard on top of a sidewalk.']
+['a plane is parked on the runway.']
+['a bus driving down a street.']
+['a plate of food with a fork.']
+['a tennis player is holding a racket.']
+['a skateboarder is standing on a sidewalk.']
+['a group of cows standing on top of a field.']
+['a small table with a vase on it.']
+['a man standing on a sidewalk.']
+['a skateboarder is riding down a hill.']
+['a dog is standing in front of a wall.']
+['a kitchen with a counter and a sink.']
+['a large body of water.']
+['a person sitting down in a chair.']
+['a beach with a lot of people and a building.']
+['a skateboarder is riding on a skateboard.']
+['a cat sitting on a bench.']
+['a plate of food is sitting on a table.']
+['a man riding a surfboard on top of a wave.']
+['a train is parked on the tracks.']
+['a man standing on a beach.']
+['a surfer on a surfboard in the ocean.']
+['a man standing next to a bus.']
+['a skateboarder is riding in a skate park.']
+['a giraffe standing in the grass.']
+['a vase with flowers and a vase with flowers.']
+['a man riding a skateboard down a snow covered slope.']
+['a large grassy area.']
+['a street sign and a street sign.']
+['a plate of food with a fork.']
+['a man standing on a bed.']
+['a small room with a lot of stuff on it.']
+['a man and a woman are sitting down.']
+['a man standing on a beach next to a boat.']
+['a cat laying on a bed next to a wall.']
+['a skateboarder is riding on a skateboard.']
+['a small herd of cattle grazing.']
+['a building with a clock on it.']
+['a large body of water.']
+['a clock tower with a clock on it.']
+['a giraffe standing next to a tree.']
+['a person standing on a sidewalk.']
+['a room with a view']
+['a man is wearing a suit and tie.']
+['a train is driving on the tracks.']
+['a room with a lot of furniture.']
+['a man standing on top of a tennis court.']
+['a bird is sitting on a branch.']
+['a man sitting down next to a table.']
+['a man sitting down next to a woman.']
+['a man standing in front of a wall.']
+['a baseball player standing on a field.']
+['a man standing on a tennis court.']
+['a clock on a building.']
+['a room with a view']
+['a group of people standing around each other.']
+['a beach with a dog and a fence.']
+['a small herd of cattle grazing.']
+['a man on a skateboard in a park.']
+['a train is parked on the tracks.']
+['a bus driving down a street.']
+['a man standing next to a woman.']
+['a cat is standing on a table.']
+['a large field with a fence and a field with a field and a fence.']
+['a dog sitting on a couch.']
+['a bathroom with a sink and a mirror.']
+['a plate of food']
+['a cat laying on a bed.']
+['a couple of animals standing on a grass covered field.']
+['a man standing in a room with a television.']
+['a large body of water.']
+['a street with a car and a street with a traffic sign.']
+['a man sitting on a couch next to a chair.']
+['a couple of elephants in the water.']
+['a surfer riding a wave.']
+['a bunch of different colored items.']
+['a giraffe standing in a field.']
+['a car is parked on the side of the road.']
+['a bathroom with a toilet and sink.']
+['a large grassy area.']
+['a cat sitting on a table.']
+['a group of people standing around a table.']
+['a man standing on a sidewalk.']
+['a bird is sitting on a branch.']
+['a surfer riding a wave.']
+['a man on a surfboard in the water.']
+['a large building with a lot of windows.']
+['a man riding a bike down a street.']
+['a man riding a horse on top of a field.']
+['a large bird flying over a large field.']
+['a large tree']
+['a plate of food with a bunch of food on it.']
+['a man standing on top of a building.']
+['a zebra standing on a dirt field.']
+['a bathroom with a toilet and sink.']
+['a man riding a skateboard on top of a sidewalk.']
+['a group of people sitting around a table.']
+['a large room with a lot of furniture.']
+['a man standing on a skateboard next to a skateboard.']
+['a man standing on a skateboard.']
+['a bathroom with a sink and mirror.']
+['a large body of water']
+['a tree with a lot of leaves.']
+['a tree in a field']
+['a kite is flying in the sky.']
+['a large tree with a few leaves.']
+['a herd of cattle grazing on a lush green field.']
+['a room with a lot of furniture.']
+['a large building with a lot of windows.']
+['a plane is parked on the runway.']
+['a street with a lot of buildings.']
+['a man standing on a beach.']
+['a giraffe standing next to a tree.']
+['a cat sitting on a table.']
+['a dog is standing in the grass.']
+['a street with a street sign and a street.']
+['a man and a woman are standing together.']
+['a cow standing on a grass covered field.']
+['a plate of food']
+['a kitchen with a sink and a counter.']
+['a man sitting down in a chair.']
+['a couple of elephants standing on top of a dirt field.']
+['a man standing in front of a wall.']
+['a plane is parked on the runway.']
+['a large elephant is standing in the grass.']
+['a plate of food']
+['a plate of food with a fork.']
+['a small pond with a small pond.']
+['a picture of a building with a clock on it.']
+['a man standing in a field.']
+['a man standing on top of a beach.']
+['a man riding a horse on a lush green field.']
+['a street with a fire hydrant.']
+['a man standing on a beach next to a surfboard.']
+['a man riding a snowboard on top of a snow covered slope.']
+['a building with a clock on it.']
+['a bus driving down a street next to a bus.']
+['a skateboarder is doing a trick.']
+['a street with a traffic light and a street with a traffic light.']
+['a large elephant is standing in the grass.']
+['a surfer is riding a wave.']
+['a plane is flying in the sky.']
+['a bathroom with a toilet and a sink.']
+['a man standing on a beach next to a woman.']
+['a small bird sitting on top of a table.']
+['a kitchen with a counter and a sink']
+['a man riding a bike on a beach.']
+['a small herd of cattle grazing.']
+['a bird standing on a branch.']
+['a room with a table and chairs']
+['a herd of cattle grazing on a lush green field.']
+['a truck parked next to a building.']
+['a bed and a bed']
+['a desk with a laptop on it']
+['a street with a car and a street with a traffic light.']
+['a small animal is standing on a rock.']
+['a train is parked in front of a building.']
+['a street sign and a street sign']
+['a bathroom with a toilet and a sink.']
+['a couple of animals that are laying down']
+['a man standing on a field.']
+['a clock on a building.']
+['a table with a bunch of food on it']
+['a truck parked next to a truck.']
+['a dog is standing on a sidewalk.']
+['a herd of cattle grazing on a field.']
+['a bus driving down a street.']
+['a large grassy area.']
+['a beach with a bunch of people on it']
+['a group of animals standing on top of a grass covered field.']
+['a group of trees with leaves.']
+['a man is wearing a suit and tie.']
+['a man holding a cell phone.']
+['a man sitting on a bench next to a building.']
+['a plate of food']
+['a man standing on top of a lush green field.']
+['a kitchen with a stove and a refrigerator.']
+['a kitchen with a table and chairs.']
+['a computer desk with a keyboard and a monitor.']
+['a plate of food with a knife.']
+['a skateboarder is standing on a skateboard.']
+['a man standing in front of a building.']
+['a surfer on a surfboard in the ocean.']
+['a skateboarder is standing on a skateboard.']
+['a bathroom with a toilet and a sink.']
+['a bathroom with a toilet and sink.']
+['a room with a lot of furniture.']
+['a group of animals standing around each other.']
+['a small bench with a large rock on it.']
+['a large kite flying in the sky.']
+['a group of people sitting around a table.']
+['a white wall and a black and white floor']
+['a group of animals standing on top of a grass covered field.']
+['a plate of food with a fork.']
+['a cat is standing on a tree.']
+['a plate of food with a fork.']
+['a baseball player is standing in front of a ball.']
+['a large building with a lot of windows.']
+['a kitchen with a sink and a counter.']
+['a group of people sitting around a table.']
+['a giraffe standing next to a tree.']
+['a man standing next to a motorcycle.']
+['a bathroom with a toilet and a sink.']
+['a bus driving down a street.']
+['a desk with a laptop on it.']
+['a clock tower with a clock on it.']
+['a room with a view']
+['a bunch of different types of animals.']
+['a man riding a surfboard on top of a wave.']
+['a group of people standing on top of a building.']
+['a large jetliner sitting on top of a cement.']
+['a herd of cattle grazing.']
+['a man on a snowboard in the snow.']
+['a bathroom with a toilet and a sink.']
+['a herd of zebra grazing on a field.']
+['a man standing next to a woman.']
+['a surfer riding a wave.']
+['a woman sitting on a couch next to a cell phone.']
+['a skateboarder is riding on a skateboard.']
+['a herd of cattle grazing.']
+['a building with a clock on it.']
+['a man wearing a suit and tie.']
+['a large body of water.']
+['a group of animals standing on top of a grass covered field.']
+['a tree in a field']
+['a large body of water.']
+['a kitchen with a table and chairs.']
+['a surfer on a surfboard in the ocean.']
+['a herd of cattle grazing on a lush green field.']
+['a dog is standing in a room.']
+['a man sitting in a chair.']
+['a large elephant standing in a field.']
+['a small building with a lot of windows.']
+['a man standing in front of a wall.']
+['a building with a clock on it.']
+['a surfer on a surfboard']
+['a bench with a plant in it.']
+['a cat sitting on a table.']
+['a man riding a bike on top of a dirt road.']
+['a man riding a surfboard on top of a body of water.']
+['a large brown and white animal.']
+['a group of people standing around each other.']
+['a large tree.']
+['a table with a plate and a plate on it']
+['a large building with a clock on it.']
+['a kitchen with a lot of furniture.']
+['a plate of food.']
+['a train is parked on the tracks.']
+['a man standing next to a woman.']
+['a man standing on a sidewalk.']
+['a building with a clock on it.']
+['a herd of cattle grazing on a lush green field.']
+['a large kite flying in the sky.']
+['a herd of cattle grazing on a lush green field.']
+['a man standing in front of a wall.']
+['a couple of elephants standing in a field.']
+['a couple of animals standing on top of a grass covered field.']
+['a skateboarder is standing on a sidewalk.']
+['a bus driving down a street.']
+['a close up of a bear']
+['a giraffe standing in the grass.']
+['a zebra standing in a field.']
+['a room with a view']
+['a man is holding a cell phone.']
+['a desk with a laptop on it.']
+['a surfer on a surfboard.']
+['a train is driving down the street.']
+['a train is driving down the tracks.']
+['a bus driving down a street.']
+['a kitchen with a lot of furniture.']
+['a man standing on a sidewalk next to a building.']
+['a table with a bunch of food on it']
+['a field with a few grass on it.']
+['a table with a variety of foods.']
+['a large area of grass.']
+['a cell phone sitting on top of a table.']
+['a plate of food']
+['a herd of cattle grazing on a field.']
+['a man standing next to a man.']
+['a group of people standing on top of a grass covered field.']
+['a woman standing on a sidewalk.']
+['a group of people standing on top of a lake.']
+['a surfer is riding a wave.']
+['a man wearing a hat and holding a cell phone.']
+['a snow covered hill with a ski slope.']
+['a man standing next to a child.']
+['a man on a surfboard in the water.']
+['a large group of people.']
+['a large body of water']
+['a giraffe standing next to a tree.']
+['a man standing on a sidewalk.']
+['a large elephant is standing in the grass.']
+['a plate of food']
+['a bus driving down a street.']
+['a desk with a laptop and a monitor.']
+['a man riding a surfboard on top of a body of water.']
+['a vase with a plant in it.']
+['a bird is standing on a branch.']
+['a baby sitting on a bed.']
+['a building with a clock on it.']
+['a large body of water.']
+['a room with a table and chairs']
+['a room with a table, chairs, and a lamp.']
+['a room with a bed and a desk.']
+["a close up of a person's head"]
+['a plane is parked on the runway.']
+['a man is holding a cell phone.']
+['a herd of cattle grazing on a lush green field.']
+['a large group of people.']
+['a cat sitting on a bench.']
+['a large building with a clock on it.']
+['a vintage motor cycle parked in a parking lot.']
+['a cat is sitting on a chair.']
+['a baseball player is standing on a field.']
+['a man standing in front of a kite.']
+['a dog is standing in front of a dog.']
+['a table with a bunch of food on it']
+['a man is sitting down.']
+['a large grassy area.']
+['a stuffed toy cat and a stuffed toy cat.']
+['a bus parked on the side of the road.']
+['a group of zebras standing around.']
+['a herd of cattle grazing on a field.']
+['a small herd of animals.']
+['a bathroom with a toilet and sink.']
+['a display of items in a room.']
+['a man standing next to a table.']
+['a table with a bunch of items on it']
+['a bathroom with a toilet and a sink.']
+['a tree in a field']
+['a woman standing on a sidewalk.']
+['a large body of water.']
+['a small dog is walking on the beach.']
+['a man standing on a field next to a horse.']
+['a man sitting on a bench next to a bench.']
+['a plate of food.']
+['a plane flying in the sky.']
+['a giraffe standing in a field.']
+['a person holding a piece of food.']
+['a man standing next to a building.']
+['a woman standing in a field.']
+['a large rock.']
+['a herd of elephants walking across a river.']
+['a dog is standing in front of a window.']
+['a man riding a bike on a sidewalk.']
+['a large grassy area.']
+['a kite is flying in the sky.']
+['a black and white photo of a cow.']
+['a group of people standing around a field.']
+['a man riding a bike on top of a sandy beach.']
+['a man standing on top of a skateboard.']
+['a couple of cats sitting on top of a table.']
+['a baby elephant standing next to a baby elephant.']
+['a child is holding a baby.']
+['a bunch of different types of food.']
+['a plate of food']
+['a bicycle is parked on the side of the road.']
+['a group of people standing around a fence.']
+['a large building with a clock on it.']
+['a man standing on a skateboard next to a skateboard.']
+['a truck parked on the side of a road.']
+['a train is parked on the tracks.']
+['a man is holding a cell phone.']
+['a giraffe standing next to a tree.']
+['a surfer on a beach with a surfboard.']
+['a man sitting on a bench.']
+['a large bus driving down a street.']
+['a kite flying over a large body of water.']
+['a man standing next to a building.']
+['a group of people standing around each other.']
+['a cat is sitting on a ledge.']
+['a man standing next to a woman.']
+['a small grassy area.']
+['a bathroom with a toilet and sink.']
+['a surfer on a surfboard in the ocean.']
+['a baseball player standing next to a batter.']
+['a large building with a clock on it.']
+['a man riding a skateboard down a snow covered slope.']
+['a street with a car and a car']
+['a giraffe standing in a field.']
+['a herd of cattle grazing on a lush green field.']
+['a field with a few animals']
+['a surfer is riding a wave.']
+['a man standing next to a water.']
+['a bird sitting on a branch.']
+['a man riding a bike down a street.']
+['a bed with a pillow and a blanket on it.']
+['a large group of people.']
+['a couple of birds sitting on top of a water.']
+['a large display of items.']
+['a surfer on a surfboard in the ocean.']
+['a room with a lot of furniture.']
+['a surfer is riding a wave.']
+['a dog on a beach near a beach.']
+['a dog is standing on a grass covered field.']
+['a plate of food']
+['a motorcycle parked on the side of a road.']
+['a cow standing on a field.']
+['a boat is parked on the shore of a lake.']
+['a bathroom with a toilet and a sink.']
+['a large building with a clock on it.']
+['a plate of food with a fork.']
+['a surfer is riding his board on the beach.']
+['a surfer is riding his surfboard.']
+['a large building with a lot of windows.']
+['a surfer riding a wave.']
+['a young girl is holding a cell phone.']
+['a man standing on top of a surfboard.']
+['a dog is sitting on a table.']
+['a man and a woman are standing on a beach.']
+['a train is parked in front of a building.']
+['a plate of food with a fork.']
+['a table with food on it']
+['a bathroom with a toilet and a sink.']
+['a train is parked on the tracks.']
+['a clock tower with a tower in the background.']
+['a kitchen with a counter and a sink.']
+['a man is holding a cell phone.']
+['a truck parked on the side of a road.']
+['a group of animals standing together.']
+['a surfer riding a wave on a surfboard.']
+['a large building with a lot of windows.']
+['a large field with a lot of grass and a lot of people on it.']
+['a picture of a table with a bunch of flowers on it.']
+['a tennis player is holding a racket.']
+['a desk with a laptop on it.']
+['a truck is driving down the street.']
+['a man riding a skateboard on top of a lake.']
+['a field with grazing animals.']
+['a small room with a lot of furniture.']
+['a bird standing on a rock.']
+['a group of people standing on top of a grass covered field.']
+['a desk with a computer and a laptop on it.']
+['a small dog is standing in the foreground.']
+['a young woman is holding a small dog.']
+['a man standing on a sidewalk.']
+['a cow standing on top of a grass covered field.']
+['a man walking on a sidewalk.']
+['a man standing on a beach next to a body of water.']
+['a man standing on a field.']
+['a man standing on a field.']
+['a large building with a lot of windows.']
+['a man standing on a tennis court.']
+['a group of people sitting on top of a building.']
+['a giraffe standing next to a tree.']
+['a skier is skiing down a hill.']
+['a desk with a laptop and a monitor']
+['a large boat on a lake.']
+['a train driving down a train track.']
+['a giraffe standing next to a tree.']
+['a small piece of a wall.']
+['a couple of animals that are standing in the grass.']
+['a bathroom with a toilet and sink.']
+['a building with a clock on it.']
+['a table with a bunch of items on it']
+['a table with a laptop on it']
+['a couple of people standing in front of a building.']
+['a picture of a tree.']
+['a white bed and a brown couch.']
+['a table with a variety of foods on it.']
+['a tree with a few leaves.']
+['a herd of sheep grazing on a lush green field.']
+['a pair of birds in a field.']
+['a man riding a snowboard down a snow covered slope.']
+['a man sitting down in a chair.']
+['a horse is walking in the grass.']
+['a surfer riding a wave.']
+['a man standing on top of a building.']
+['a piece of furniture with a piece of furniture.']
+['a woman standing on a sidewalk next to a skateboard.']
+['a zebra standing in a field.']
+['a plate of food with a fork.']
+['a young girl is holding a small piece of paper.']
+['a fruit bowl with a fruit inside.']
+['a cat is sitting on a car.']
+['a street with a traffic light and a street sign.']
+['a city street with a traffic light.']
+['a person standing on a sidewalk.']
+['a kitchen with a table and chairs.']
+['a beach with a bunch of people on it']
+['a bunch of different types of fruit']
+['a train is parked on the side of the road.']
+['a picture of a clock and some flowers']
+['a room with a table and chairs']
+['a bathroom with a toilet and a sink.']
+['a man walking down a street.']
+['a table with a chair']
+['a man riding a snowboard down a snow covered slope.']
+['a man standing on top of a beach.']
+['a plate of food']
+['a man standing on a beach next to a surfboard.']
+['a snowboarder is on a snowy hill.']
+['a bus driving down a street.']
+['a bunch of vegetables on a table']
+['a kitchen with a lot of furniture.']
+['a bathroom with a toilet and sink.']
+['a small animal is standing on a grass covered field.']
+['a street with a street light and a street sign.']
+['a bathroom with a toilet and a sink.']
+['a man standing next to a man.']
+['a cat sitting on a table.']
+['a clock tower with a tower in the background.']
+['a group of horses grazing.']
+['a bus driving down a street.']
+['a surfer is riding a wave.']
+['a surfer is riding a wave.']
+['a plate of food with a fork.']
+['a man standing next to a woman.']
+['a bathroom with a toilet and a sink.']
+['a plane is parked on the runway.']
+['a baseball player standing on a field.']
+['a train is parked on the tracks.']
+['a man is holding a cell phone.']
+['a bathroom with a toilet and a sink.']
+['a baseball player is standing on a field.']
+['a bus driving down a street.']
+['a plane is parked on the tarmac.']
+['a herd of cattle grazing on a lush green field.']
+['a group of people sitting around a table.']
+['a man on a surfboard in the water.']
+['a plate of food with a plate of food on it.']
+['a young child is sitting in a chair.']
+['a building with a clock on it.']
+['a truck is parked next to a truck.']
+['a small room with a lot of furniture.']
+['a giraffe standing in a field.']
+['a small grassy field.']
+['a skateboarder is riding his skateboard.']
+['a clock on a building.']
+['a group of animals standing on top of a grass covered field.']
+['a surfer is riding a wave.']
+['a couple of bears standing around.']
+['a baseball player is standing in front of a fence.']
+['a small grassy area.']
+['a plate of food with a fork']
+['a truck is parked on the street.']
+['a plate of food with a fork.']
+['a young woman is holding a baby.']
+['a kitchen with a counter and a microwave.']
+['a room with a table, chair, and a lamp.']
+['a vase with flowers and a vase with flowers.']
+['a man standing on a sidewalk.']
+['a skateboarder is riding down a hill.']
+['a surfer riding a wave.']
+['a bathroom with a sink and a mirror.']
+['a woman with her back turned.']
+['a kitchen with a sink and a counter.']
+['a clock tower with a clock on it.']
+['a man standing on a field.']
+['a building with a clock on it.']
+['a man on a surfboard in the ocean.']
+['a man on a beach with a surfboard.']
+['a small room with a lot of furniture.']
+['a man standing on a tennis court.']
+['a bathroom with a toilet and a sink.']
+['a table with plates of food on it']
+['a plate of food with a fork.']
+['a couple of cows standing on top of a grass covered field.']
+['a zebra standing in a field.']
+['a herd of cattle grazing on a field.']
+['a table with a bunch of food on it']
+['a street with a lot of cars parked in it.']
+['a man standing next to a child.']
+['a large passenger jet.']
+['a bus is parked in front of a building.']
+['a skateboarder is in the foreground.']
+['a couple of bears standing on top of a grass covered field.']
+['a giraffe standing on top of a dirt field.']
+['a train is parked in front of a building.']
+['a young woman standing next to a child.']
+['a truck parked on the side of a road.']
+['a tree with a lot of leaves.']
+['a man standing next to a woman.']
+['a man standing on a tennis court.']
+['a surfer on a surfboard.']
+['a kitchen with a table and a stove']
+['a man and a woman are standing together.']
+['a street scene with a large truck and a large truck.']
+['a group of people standing around each other.']
+['a group of trees']
+['a group of animals that are in the grass.']
+['a small room with a lot of furniture.']
+['a man standing on a beach next to a beach.']
+['a view of a room.']
+['a large truck is parked on the side of the road.']
+['a man standing on a skateboard.']
+['a plate of food on a table.']
+['a large body of water.']
+['a man riding a bike down a street next to a road.']
+['a street light with a street sign and a traffic light.']
+['a man standing on a sidewalk next to a building.']
+['a large elephant is standing in the grass.']
+['a bathroom with a sink and a mirror.']
+['a cat sitting on a chair.']
+['a small dog is sitting on a bench.']
+['a cat sitting on top of a table.']
+['a herd of cattle grazing on a lush green field.']
+['a large tree.']
+['a room with a view']
+['a surfer is riding a wave.']
+['a skateboarder is riding on a skateboard.']
+['a woman standing on a sidewalk.']
+['a table with a bunch of items on it']
+['a man standing in front of a building.']
+['a living room with a couch and a television.']
+['a man is holding a cell phone.']
+['a herd of sheep grazing on a lush green hillside.']
+['a plate of food with a fork.']
+['a clock tower with a clock on it.']
+['a plate of food with a bowl of food on it.']
+['a car parked on the side of a road.']
+['a room with a view']
+['a train is driving on the tracks.']
+['a large jetliner sitting on top of a lush green field.']
+['a plate of food']
+['a dog on a beach near a body of water.']
+['a man standing next to a fence.']
+['a table with a bunch of chairs']
+['a surfer on a surfboard in the ocean.']
+['a desk with a computer on it.']
+['a small white and blue fire hydrant.']
+['a surfer on a surfboard in the ocean.']
+['a plate of food with a fork on it.']
+['a clock on a building']
+['a desk with a computer on it']
+['a man riding a surfboard on top of a body of water.']
+['a man riding a skateboard on top of a lake.']
+['a flower arrangement with a vase.']
+['a tree in a field']
+['a truck is parked next to a truck.']
+['a small room with a lot of furniture.']
+['a small tree']
+['a man standing next to a fence.']
+['a man standing on a tennis court.']
+['a picture of a field.']
+['a large body of water.']
+['a group of animals standing on top of a grass covered field.']
+['a road with a car on it']
+['a man riding a bike on a sidewalk.']
+['a kitchen with a stove and a sink.']
+['a man standing on a field.']
+['a man standing on a field.']
+['a room with a lot of furniture.']
+['a man standing on a sidewalk next to a fence.']
+['a kitchen with a stove and a microwave.']
+['a plate of food with a bowl of food on it.']
+['a cat is standing in a room.']
+['a man standing next to a woman.']
+['a train is driving down the tracks.']
+['a large field with a lot of grass and trees.']
+['a desk with a laptop and a keyboard']
+['a large area of trees.']
+['a vase with flowers and a vase with flowers.']
+['a giraffe standing in a field.']
+['a cat sitting on a chair.']
+['a giraffe standing in the grass.']
+['a plane is flying in the air.']
+['a plane is parked on the runway.']
+['a kitchen with a counter and a refrigerator.']
+['a surfer riding a wave.']
+['a dining room with a table and chairs.']
+['a surfer riding a wave.']
+['a plate of food with a plate of food on it.']
+['a surfer on a wave']
+['a large building with a lot of windows.']
+['a small herd of sheep grazing.']
+['a group of elephants.']
+['a couple of elephants standing on top of a dirt field.']
+['a plane flying over a blue sky.']
+['a large grassy field.']
+['a display of various types of food.']
+['a group of people sitting around a table.']
+['a man standing on a field.']
+['a large field with a few animals in it.']
+['a kitchen with a counter top.']
+['a young man is sitting in a car.']
+['a room with a lot of furniture.']
+['a man standing in front of a tree.']
+['a boat on a body of water.']
+['a train is parked on the tracks.']
+['a large area with a lot of furniture.']
+['a bathroom with a sink and a mirror.']
+['a bus driving down a street next to a bus.']
+['a herd of zebra grazing on a lush green field.']
+['a small room with a lot of furniture.']
+['a plate of food with a fork.']
+['a man standing next to a building.']
+['a man standing on a tennis court.']
+['a truck parked on the side of a road.']
+['a young man is holding a camera.']
+['a surfer on a surfboard in the ocean.']
+['a man standing on a beach.']
+['a boat on a body of water.']
+['a tree in a field']
+['a table with a vase and a vase on it.']
+['a table with some food on it']
+['a bed with a pillow and a blanket']
+['a group of people standing around a table.']
+['a zebra standing on a dirt field.']
+['a large field with a lot of grass and trees.']
+['a bowl of fruit on a table.']
+['a bus driving down a street.']
+['a surfer on a surfboard in the ocean.']
+['a man standing on a skateboard next to a tree.']
+['a surfer is riding a wave.']
+['a large bird standing on top of a rock.']
+['a man riding a surfboard on top of a wave.']
+['a table with a bunch of food on it']
+['a large body of water.']
+['a room with a lot of furniture.']
+['a table with a bunch of food on it']
+['a man standing on a beach.']
+['a dog is standing in the grass.']
+['a herd of cattle grazing on a lush green hillside.']
+['a herd of cattle grazing.']
+['a surfer is riding a wave.']
+['a man standing in front of a wall.']
+['a large building with a lot of windows.']
+['a group of people standing around a building.']
+['a man standing on a sidewalk.']
+['a snowboarder is skiing down a hill.']
+['a child eating a meal.']
+['a man on a surfboard in the water.']
+['a man and a woman in a room.']
+['a man standing on a sidewalk next to a building.']
+['a giraffe standing next to a tree.']
+['a bathroom with a toilet and a sink.']
+['a large jetliner sitting on top of a lush green field.']
+['a baseball player is on the field.']
+['a woman is wearing a black and white dress.']
+['a small room with a lot of furniture.']
+['a zebra standing on a dirt field.']
+['a bus driving down a street.']
+['a large room with a table and chairs.']
+['a large body of water']
+['a man walking on a sidewalk.']
+['a large animal standing in a field.']
+['a plate of food with a plate of food on it.']
+['a plane is flying in the air.']
+['a man standing on top of a sidewalk.']
+['a kitchen with a lot of appliances']
+['a large number of windows.']
+['a group of people standing around each other.']
+['a bus driving down a street.']
+['a herd of cattle grazing.']
+['a skateboarder is standing in a skate park.']
+['a large boat on a lake.']
+['a group of people walking down a street.']
+['a man standing on a beach next to a tree.']
+['a woman holding a cell phone.']
+['a dog is standing on a beach.']
+['a man standing on top of a surfboard.']
+['a train is driving past a train.']
+['a giraffe standing in the grass.']
+['a bathroom with a toilet and a sink.']
+['a room with a bed and a table']
+torch.Size([1000, 3, 256, 256])
+saved final_subj01_pretrained_3sess_24bs outputs!
+device: cuda
+final_subj01_pretrained_3sess_24bs
+torch.Size([18, 3, 425, 425]) torch.Size([1000, 3, 768, 768]) torch.Size([1000, 256, 1664]) torch.Size([1000, 3, 768, 768]) (1000,)
+Initialized embedder #0: FrozenCLIPEmbedder with 123060480 params. Trainable: False
+Initialized embedder #1: FrozenOpenCLIPEmbedder2 with 694659841 params. Trainable: False
+Initialized embedder #2: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #3: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Initialized embedder #4: ConcatTimestepEmbedderND with 0 params. Trainable: False
+Restored from /weka/proj-medarc/shared/mindeyev2_dataset/zavychromaxl_v30.safetensors with 1 missing and 1 unexpected keys
+Missing Keys: ['denoiser.sigmas']
+Unexpected Keys: ['conditioner.embedders.0.transformer.text_model.embeddings.position_ids']
+crossattn torch.Size([1, 77, 2048])
+vector_suffix torch.Size([1, 1536])
+---
+crossattn_uc torch.Size([1, 77, 2048])
+vector_uc torch.Size([1, 2816])
+all_enhancedrecons torch.Size([1000, 3, 256, 256])
+saved evals/final_subj01_pretrained_3sess_24bs/final_subj01_pretrained_3sess_24bs_all_enhancedrecons.pt

MindEyeV2/src/slurms/544384.err

@@ -0,0 +1,6 @@
+[NbConvertApp] Converting notebook TrainB5k.ipynb to python
+[NbConvertApp] Writing 52126 bytes to TrainB5k.py
+  File "/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainB5k.py", line 1317
+    for i in train_dl
+                     ^
+SyntaxError: expected ':'

MindEyeV2/src/slurms/544384.out

@@ -0,0 +1,4 @@
+MASTER_ADDR=ip-10-0-146-13
+MASTER_PORT=11088
+WORLD_SIZE=1
+model_name=augmented_image_one

MindEyeV2/src/slurms/544386.err

@@ -0,0 +1,5 @@
+[NbConvertApp] Converting notebook TrainB5k.ipynb to python
+[NbConvertApp] Writing 52128 bytes to TrainB5k.py
+slurmstepd: error: *** REASON: burst_buffer/lua: Stage-out in progress ***
+slurmstepd: error: *** JOB 544386 ON ip-10-0-130-125 CANCELLED AT 2024-12-06T23:01:13 ***
+slurmstepd: error: *** REASON: burst_buffer/lua: Stage-out in progress ***

MindEyeV2/src/slurms/544386.out

@@ -0,0 +1,4 @@
+MASTER_ADDR=ip-10-0-130-125
+MASTER_PORT=17288
+WORLD_SIZE=1
+model_name=augmented_image_one

MindEyeV2/src/slurms/544387.err

@@ -0,0 +1,7 @@
+[NbConvertApp] Converting notebook TrainB5k.ipynb to python
+[NbConvertApp] Writing 52128 bytes to TrainB5k.py
+Traceback (most recent call last):
+  File "/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainB5k.py", line 819, in <module>
+    "train_url": train_url,
+                 ^^^^^^^^^
+NameError: name 'train_url' is not defined. Did you mean: 'train_dl'?

MindEyeV2/src/slurms/544387.out

@@ -0,0 +1,54 @@
+MASTER_ADDR=ip-10-0-130-125
+MASTER_PORT=15229
+WORLD_SIZE=1
+model_name=augmented_image_one
+LOCAL RANK  0
+PID of this process = 1825637
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+Training with 15 sessions
+Loaded all subj train dls and betas!
+
+Loaded all subj train dls and betas!
+
+Loaded test dl for subj1!
+
+batch_size = 21 num_iterations_per_epoch = 205 num_samples_per_epoch = 4323
+param counts:
+712,785,920 total
+712,785,920 trainable
+param counts:
+712,785,920 total
+712,785,920 trainable
+torch.Size([2, 1, 174019]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+2,600,647,320 total
+2,600,647,320 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,860,512,536 total
+2,860,512,520 trainable
+total_steps 16400
+
+Done with model preparations!
+param counts:
+2,860,512,536 total
+2,860,512,520 trainable
+wandb mindeye run augmented_image_one

MindEyeV2/src/slurms/544389.err

@@ -0,0 +1,26 @@
+[NbConvertApp] Converting notebook TrainB5k.ipynb to python
+[NbConvertApp] Writing 52131 bytes to TrainB5k.py
+wandb: Currently logged in as: ckadirt. Use `wandb login --relogin` to force relogin
+wandb: wandb version 0.19.0 is available!  To upgrade, please run:
+wandb:  $ pip install wandb --upgrade
+wandb: Tracking run with wandb version 0.17.1
+wandb: Run data is saved locally in /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241206_230633-augmented_image_one
+wandb: Run `wandb offline` to turn off syncing.
+wandb: Syncing run augmented_image_one
+wandb: ⭐️ View project at https://stability.wandb.io/ckadirt/mindeye
+wandb: 🚀 View run at https://stability.wandb.io/ckadirt/mindeye/runs/augmented_image_one
+
  0%|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0/80 [00:00<?, ?it/s]
  0%|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0/80 [00:07<?, ?it/s]
+Traceback (most recent call last):
+  File "/weka/proj-fmri/ckadirt/MindEyeV2/src/TrainB5k.py", line 1048, in <module>
+    accelerator.backward(loss)
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/accelerate/accelerator.py", line 1987, in backward
+    self.scaler.scale(loss).backward(**kwargs)
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/_tensor.py", line 492, in backward
+    torch.autograd.backward(
+  File "/admin/home-ckadirt/fmri/lib/python3.11/site-packages/torch/autograd/__init__.py", line 251, in backward
+    Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass
+torch.cuda.OutOfMemoryError: CUDA out of memory. Tried to allocate 6.50 GiB. GPU 0 has a total capacty of 79.11 GiB of which 1006.94 MiB is free. Including non-PyTorch memory, this process has 78.12 GiB memory in use. Of the allocated memory 61.43 GiB is allocated by PyTorch, and 15.89 GiB is reserved by PyTorch but unallocated. If reserved but unallocated memory is large try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF
+wandb: - 0.071 MB of 0.071 MB uploaded
+wandb: ⭐️ View project at: https://stability.wandb.io/ckadirt/mindeye
+wandb: Synced 5 W&B file(s), 0 media file(s), 3 artifact file(s) and 1 other file(s)
+wandb: Find logs at: ./wandb/run-20241206_230633-augmented_image_one/logs

MindEyeV2/src/slurms/544389.out

@@ -0,0 +1,59 @@
+MASTER_ADDR=ip-10-0-130-125
+MASTER_PORT=11619
+WORLD_SIZE=1
+model_name=augmented_image_one
+LOCAL RANK  0
+PID of this process = 1826787
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+Training with 15 sessions
+Loaded all subj train dls and betas!
+
+Loaded all subj train dls and betas!
+
+Loaded test dl for subj1!
+
+batch_size = 21 num_iterations_per_epoch = 205 num_samples_per_epoch = 4323
+param counts:
+712,785,920 total
+712,785,920 trainable
+param counts:
+712,785,920 total
+712,785,920 trainable
+torch.Size([2, 1, 174019]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+2,600,647,320 total
+2,600,647,320 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,860,512,536 total
+2,860,512,520 trainable
+total_steps 16400
+
+Done with model preparations!
+param counts:
+2,860,512,536 total
+2,860,512,520 trainable
+wandb mindeye run augmented_image_one
+wandb_config:
+ {'model_name': 'augmented_image_one', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 80, 'num_sessions': 15, 'num_params': 2860512520, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 4323, 'num_test': 480, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+wandb_id: augmented_image_one
+torch.Size([21, 174019]) torch.Size([21, 3, 224, 224]) torch.Size([21]) torch.Size([21])
+augmented_image_one starting with epoch 0 / 80

MindEyeV2/src/slurms/544492.out

@@ -0,0 +1,62 @@
+MASTER_ADDR=ip-10-0-172-177
+MASTER_PORT=12285
+WORLD_SIZE=1
+model_name=bold5k_v1
+LOCAL RANK  0
+PID of this process = 1733288
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+Training with 15 sessions
+Loaded all subj train dls and betas!
+
+Loaded all subj train dls and betas!
+
+Loaded test dl for subj1!
+
+batch_size = 21 num_iterations_per_epoch = 205 num_samples_per_epoch = 4323
+param counts:
+6,905,856 total
+6,905,856 trainable
+param counts:
+6,905,856 total
+6,905,856 trainable
+torch.Size([2, 1, 1685]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+1,894,767,256 total
+1,894,767,256 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,154,632,472 total
+2,154,632,456 trainable
+total_steps 16400
+
+Done with model preparations!
+param counts:
+2,154,632,472 total
+2,154,632,456 trainable
+wandb mindeye run bold5k_v1
+wandb_config:
+ {'model_name': 'bold5k_v1', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 80, 'num_sessions': 15, 'num_params': 2154632456, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 4323, 'num_test': 480, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+wandb_id: bold5k_v1
+torch.Size([21, 1685]) torch.Size([21, 3, 224, 224]) torch.Size([21]) torch.Size([21])
+bold5k_v1 starting with epoch 0 / 80
+
+===Finished!===
+

MindEyeV2/src/slurms/545089.out

@@ -0,0 +1,18 @@
+MASTER_ADDR=ip-10-0-133-32
+MASTER_PORT=12592
+WORLD_SIZE=1
+model_name=bold5k_nsdm1
+LOCAL RANK  0
+PID of this process = 840677
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...

MindEyeV2/src/slurms/545090.err

@@ -0,0 +1,14 @@
+[NbConvertApp] Converting notebook TrainB5k.ipynb to python
+[NbConvertApp] Writing 52203 bytes to TrainB5k.py
+wandb: Currently logged in as: ckadirt. Use `wandb login --relogin` to force relogin
+wandb: wandb version 0.19.0 is available!  To upgrade, please run:
+wandb:  $ pip install wandb --upgrade
+wandb: Tracking run with wandb version 0.17.1
+wandb: Run data is saved locally in /weka/proj-fmri/ckadirt/MindEyeV2/src/wandb/run-20241210_215527-bold5k_nsdm1
+wandb: Run `wandb offline` to turn off syncing.
+wandb: Syncing run bold5k_nsdm1
+wandb: ⭐️ View project at https://stability.wandb.io/ckadirt/mindeye
+wandb: 🚀 View run at https://stability.wandb.io/ckadirt/mindeye/runs/bold5k_nsdm1
+
  0%|                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 0/80 [00:00<?, ?it/s]slurmstepd: error: *** REASON: burst_buffer/lua: Stage-out in progress ***
+slurmstepd: error: *** JOB 545090 ON ip-10-0-133-32 CANCELLED AT 2024-12-10T21:56:08 ***
+slurmstepd: error: *** REASON: burst_buffer/lua: Stage-out in progress ***

MindEyeV2/src/slurms/545090.out

@@ -0,0 +1,59 @@
+MASTER_ADDR=ip-10-0-133-32
+MASTER_PORT=15871
+WORLD_SIZE=1
+model_name=bold5k_nsdm1
+LOCAL RANK  0
+PID of this process = 841814
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+Training with 15 sessions
+Loaded all subj train dls and betas!
+
+Loaded all subj train dls and betas!
+
+Loaded test dl for subj1!
+
+batch_size = 21 num_iterations_per_epoch = 205 num_samples_per_epoch = 4323
+param counts:
+91,324,416 total
+91,324,416 trainable
+param counts:
+91,324,416 total
+91,324,416 trainable
+torch.Size([2, 1, 22295]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+1,979,185,816 total
+1,979,185,816 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,239,051,032 total
+2,239,051,016 trainable
+total_steps 16400
+
+Done with model preparations!
+param counts:
+2,239,051,032 total
+2,239,051,016 trainable
+wandb mindeye run bold5k_nsdm1
+wandb_config:
+ {'model_name': 'bold5k_nsdm1', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 80, 'num_sessions': 15, 'num_params': 2239051016, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 4323, 'num_test': 480, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+wandb_id: bold5k_nsdm1
+torch.Size([21, 22295]) torch.Size([21, 3, 224, 224]) torch.Size([21]) torch.Size([21])
+bold5k_nsdm1 starting with epoch 0 / 80

MindEyeV2/src/slurms/545091.out

@@ -0,0 +1,62 @@
+MASTER_ADDR=ip-10-0-133-32
+MASTER_PORT=13257
+WORLD_SIZE=1
+model_name=bold5k_nsdm1
+LOCAL RANK  0
+PID of this process = 842903
+device: cuda
+Distributed environment: DistributedType.NO
+Num processes: 1
+Process index: 0
+Local process index: 0
+Device: cuda
+
+Mixed precision type: fp16
+
+distributed = False num_devices = 1 local rank = 0 world size = 1 data_type = torch.float16
+subj_list [1] num_sessions 15
+dividing batch size by subj_list, which will then be concatenated across subj during training...
+Training with 15 sessions
+Loaded all subj train dls and betas!
+
+Loaded all subj train dls and betas!
+
+Loaded test dl for subj1!
+
+batch_size = 21 num_iterations_per_epoch = 205 num_samples_per_epoch = 4323
+param counts:
+91,324,416 total
+91,324,416 trainable
+param counts:
+91,324,416 total
+91,324,416 trainable
+torch.Size([2, 1, 22295]) torch.Size([2, 1, 4096])
+param counts:
+1,887,861,400 total
+1,887,861,400 trainable
+param counts:
+1,979,185,816 total
+1,979,185,816 trainable
+b.shape torch.Size([2, 1, 4096])
+torch.Size([2, 256, 1664]) torch.Size([2, 256, 1664]) torch.Size([1]) torch.Size([1])
+param counts:
+259,865,216 total
+259,865,200 trainable
+param counts:
+2,239,051,032 total
+2,239,051,016 trainable
+total_steps 30750
+
+Done with model preparations!
+param counts:
+2,239,051,032 total
+2,239,051,016 trainable
+wandb mindeye run bold5k_nsdm1
+wandb_config:
+ {'model_name': 'bold5k_nsdm1', 'global_batch_size': '21', 'batch_size': 21, 'num_epochs': 150, 'num_sessions': 15, 'num_params': 2239051016, 'clip_scale': 1.0, 'prior_scale': 30.0, 'blur_scale': 0.5, 'use_image_aug': True, 'max_lr': 0.0003, 'mixup_pct': 0.33, 'num_samples_per_epoch': 4323, 'num_test': 480, 'ckpt_interval': 999, 'ckpt_saving': False, 'seed': 42, 'distributed': False, 'num_devices': 1, 'world_size': 1}
+wandb_id: bold5k_nsdm1
+torch.Size([21, 22295]) torch.Size([21, 3, 224, 224]) torch.Size([21]) torch.Size([21])
+bold5k_nsdm1 starting with epoch 0 / 150
+
+===Finished!===
+