diff --git a/brainlit/utils/__init__.py b/brainlit/utils/__init__.py
index 67986bac0..2358e878a 100644
--- a/brainlit/utils/__init__.py
+++ b/brainlit/utils/__init__.py
@@ -2,3 +2,6 @@
 from brainlit.utils.upload import *
 from brainlit.utils.Neuron_trace import *
 from brainlit.utils.benchmarking_params import *
+from brainlit.utils.make_masks import *
+
+import brainlit.utils.cnn_segmentation
diff --git a/brainlit/utils/cnn_segmentation/__init__.py b/brainlit/utils/cnn_segmentation/__init__.py
new file mode 100644
index 000000000..e14f78e9f
--- /dev/null
+++ b/brainlit/utils/cnn_segmentation/__init__.py
@@ -0,0 +1,4 @@
+import brainlit.utils.cnn_segmentation
+
+from brainlit.utils.cnn_segmentation.preprocess_cnn import *
+from brainlit.utils.cnn_segmentation.performance_cnn import *
diff --git a/brainlit/utils/cnn_segmentation/performance_cnn.py b/brainlit/utils/cnn_segmentation/performance_cnn.py
new file mode 100644
index 000000000..cfe3cb760
--- /dev/null
+++ b/brainlit/utils/cnn_segmentation/performance_cnn.py
@@ -0,0 +1,304 @@
+# functions for model training and performance evaluation
+
+import numpy as np
+from sklearn.metrics import roc_curve, auc, jaccard_score
+import torch
+from torch import nn
+import matplotlib.pyplot as plt
+from sklearn.metrics import (
+    accuracy_score,
+    precision_score,
+    recall_score,
+    precision_recall_curve,
+)
+
+
+def train_loop(dataloader, model, loss_fn, optimizer):
+    """Pytorch model training loop
+
+    Arguments:
+        train_dataloader: torch object from getting_torch_objects function in preprocess.py
+        model: pytorch model, defined locally
+        loss_fn: loss_fn class name, ex: BCELoss, Dice
+        optimizer: name of optimizer, ex. Adam, SGD, etc.
+    """
+    for batch, (X_all, y_all) in enumerate(dataloader):
+
+        loss_list = []
+
+        for image in range(X_all.shape[1]):
+            X = np.reshape(X_all[0][image], (1, 1, 66, 66, 20))
+            y = np.reshape(y_all[0][image], (1, 1, 66, 66, 20))
+
+            # Compute prediction and loss
+            optimizer.zero_grad()
+            pred = model(X)
+            pred = torch.squeeze(pred, 3).clone()
+            loss = loss_fn(pred, y)
+
+            # Backpropagation
+            loss.backward()
+            optimizer.step()
+            loss, current = loss.item(), batch * len(X)
+            loss_list.append(loss)
+
+
+def test_loop(dataloader, model, loss_fn):
+    """Pytorch model testing loop
+
+    Arguments:
+        test_dataloader: torch object from getting_torch_objects function in preprocess.py
+        model: pytorch model, defined locally
+        loss_fn: loss_fn class name, ex: BCELoss, Dice
+
+    Returns:
+        List, true images: x_list
+        Nested list, model predictions for each image at each epoch: y_pred
+        Nested list, true masks for each image at each epoch: y_list
+        List, average loss at each epoch: avg_loss
+    """
+    for batch, (X_all, y_all) in enumerate(dataloader):
+
+        loss_list = []
+        y_pred = []
+        y_list = []
+        x_list = []
+
+        with torch.no_grad():
+            for image in range(X_all.shape[1]):
+
+                X = np.reshape(X_all[0][image], (1, 1, 330, 330, 100))
+                y = np.reshape(y_all[0][image], (1, 1, 330, 330, 100))
+                pred = model(X)
+                pred = torch.squeeze(pred, 3)
+
+                x_list.append(X)
+                y_list.append(y)
+                y_pred.append(pred)
+
+                loss_list.append(loss_fn(pred, y).item())
+
+        avg_loss = np.average(loss_list)
+        print("Avg test loss:", avg_loss)
+
+    return x_list, y_pred, y_list, avg_loss
+
+
+# Dice loss class
+class DiceLoss(nn.Module):
+    def __init__(self, weight=None, size_average=True):
+        super(DiceLoss, self).__init__()
+
+    def forward(self, inputs, targets, smooth=1):
+        inputs = inputs.view(-1)
+        targets = targets.view(-1)
+
+        intersection = (inputs * targets).sum()
+        dice = (2.0 * intersection + smooth) / (inputs.sum() + targets.sum() + smooth)
+
+        return 1 - dice
+
+
+def get_metrics(pred_list, y_list):
+    """Getting accuracy, precision, and recall at each epoch
+
+    Arguments:
+        pred_list: list of predictions for every image at every epoch, output of testing loop
+        y_list: list of true y masks, output of testing loop
+
+    Returns:
+        List of average accuracy for each epoch: acc_list
+        List of average precision for each epoch: precision_list
+        List of average recall for each epoch: recall_list
+        List of percent of nonzero predictions at each epoch: percent_nonzero
+    """
+    acc_list = []
+    precision_list = []
+    recall_list = []
+    percent_nonzero = []
+
+    for i in range(len(pred_list)):
+        acc_list_t = []
+        precision_list_t = []
+        recall_list_t = []
+        percent_nonzero_t = []
+
+        for j in range(len(pred_list[0])):
+            pred = pred_list[i][j].clone().numpy()[:, 0].round().astype(int).flatten()
+            target = y_list[i][j][:, 0].clone().numpy().astype(int).flatten()
+
+            acc = accuracy_score(target, pred) * 100
+            acc_list_t.append(acc)
+
+            pr = precision_score(target, pred) * 100
+            precision_list_t.append(pr)
+
+            rc = recall_score(target, pred) * 100
+            recall_list_t.append(rc)
+
+            nz = (np.count_nonzero(pred) / len(target)) * 100
+            percent_nonzero_t.append(nz)
+
+        mean_acc = np.mean(acc_list_t)
+        mean_pr = np.mean(precision_list_t)
+        mean_rc = np.mean(recall_list_t)
+        mean_nz = np.mean(percent_nonzero_t)
+
+        acc_list.append(mean_acc)
+        precision_list.append(mean_pr)
+        recall_list.append(mean_rc)
+        percent_nonzero.append(mean_nz)
+
+    return acc_list, precision_list, recall_list, percent_nonzero
+
+
+def quick_stats(stat, epoch, acc_list, precision_list, recall_list, percent_nonzero):
+    """Printing quick test stats at specified epoch
+
+    Arguments:
+        stat: str, "all" if you want to print all metrics (accuracy, precision, reacll, % nonzero)
+        acc_list: list of average accuracy for each epoch, from get_metrics function
+        precision_list: list of average precision for each epoch, from get_metrics function
+        recall_list: list of average recall for each epoch, from get_metrics function
+        percent_nonzero: list of percent of nonzero predictions at each epoch, from get_metrics function
+
+    Returns:
+        Printed metrics for specified epoch
+    """
+    if stat == "accuracy":
+        print("Accuracy at epoch " + str(epoch) + " is " + str(acc_list[epoch - 1]))
+    if stat == "all":
+        print("Accuracy at epoch " + str(epoch) + " is " + str(acc_list[epoch - 1]))
+        print(
+            "Precision at epoch " + str(epoch) + " is " + str(precision_list[epoch - 1])
+        )
+        print("Recall at epoch " + str(epoch) + " is " + str(recall_list[epoch - 1]))
+        print(
+            "Percent nonzero at epoch "
+            + str(epoch)
+            + " is "
+            + str(percent_nonzero[epoch - 1])
+        )
+
+
+def plot_metrics_over_epoch(
+    loss_list, acc_list, precision_list, recall_list, percent_nonzero
+):
+    """Plotting all metrics over epoch
+
+    Arguments:
+        loss_list: list of test loss over epoch
+        acc_list: list of average accuracy for each epoch, from get_metrics function
+        precision_list: list of average precision for each epoch, from get_metrics function
+        recall_list: list of average recall for each epoch, from get_metrics function
+        percent_nonzero: list of percent of nonzero predictions at each epoch, from get_metrics function
+
+    Returns:
+        Plotted figures for accuracy, precision, recall, % nonzero, and loss over epoch
+    """
+    plt.figure()
+    plt.title("Test loss over epoch")
+    plt.xlabel("Epoch")
+    plt.ylabel("Test loss")
+    plt.plot(loss_list)
+
+    plt.figure()
+    plt.title("Accuracy over epoch")
+    plt.xlabel("Epoch")
+    plt.ylabel("Avg accuracy (%)")
+    plt.plot(acc_list)
+
+    plt.figure()
+    plt.title("Precision over epoch")
+    plt.xlabel("Epoch")
+    plt.ylabel("Avg precision (%)")
+    plt.plot(precision_list)
+
+    plt.figure()
+    plt.title("Recall over epoch")
+    plt.xlabel("Epoch")
+    plt.ylabel("Avg recall (%)")
+    plt.plot(recall_list)
+
+    plt.figure()
+    plt.title("Percent_nonzero over epoch")
+    plt.xlabel("Epoch")
+    plt.ylabel("Nonzeros (%)")
+    plt.plot(percent_nonzero)
+
+
+def plot_pr_histograms(pred_list, y_list):
+    """Plotting histograms for precision and recall at final epoch
+
+    Arguments:
+        pred_list: list of predictions for all images at last epoch
+        y_list: lost of true y masks for all images at last epoch
+
+    Returns:
+        Precision and recall plots for all images at last epoch
+    """
+    i = len(pred_list) - 1
+    precision_list_t = []
+    recall_list_t = []
+
+    for j in tqdm(range(len(pred_list[0]))):
+        pred = pred_list[i][j].clone().numpy()[:, 0].round().astype(int).flatten()
+        target = y_list[i][j][:, 0].clone().numpy().astype(int).flatten()
+
+        pr = precision_score(target, pred) * 100
+        precision_list_t.append(pr)
+
+        rc = recall_score(target, pred) * 100
+        recall_list_t.append(rc)
+
+    # Precision histogram on last epoch
+    plt.figure()
+    plt.title("Precision histogram for individual 11 images on last epoch")
+    plt.ylabel("Individual Precision")
+    plt.hist(precision_list_t, bins=20)
+
+    # Recall histogram on last epoch
+    plt.figure()
+    plt.title("Recall histogram for individual 11 images on last epoch")
+    plt.ylabel("Individual Recall")
+    plt.hist(recall_list_t, bins=20)
+
+
+def plot_with_napari(x_list, pred_list, y_list):
+    """Plotting all test images at an epoch in napari
+
+    Arguments:
+        x_list: list of all x images from testing loop
+        pred_list: list of all testing predictions at an epoch
+        y_list: list of true ground truth masks at that same epoch
+
+    Returns:
+        Visualizations of napari image, ground truth mask, and thresholded prediction mask
+    """
+    for i in range(len(y_list[len(y_list) - 1])):
+        x = x_list[i].clone()[:, 0].numpy()
+        pred = pred_list[len(pred_list) - 1][i].clone()[:, 0].numpy()
+        y = y_list[len(y_list) - 1][i].clone()[:, 0].numpy()
+
+        fpr, tpr, thresholds = roc_curve(y.flatten(), pred.flatten())
+        optimal_thresh = thresholds[np.argmax(tpr - fpr)]
+        # print("Optimal Threshold for image " + str(i) + ": ", optimal_thresh)
+
+        pred_thresh = pred
+
+        for i in range(1):
+            for a in range(330):
+                for b in range(330):
+                    for c in range(100):
+                        if pred[i][a][b][c] > optimal_thresh:
+                            pred_thresh[i][a][b][c] = 1
+                        else:
+                            pred_thresh[i][a][b][c] = 0
+
+        import napari
+
+        with napari.gui_qt():
+            viewer = napari.Viewer(ndisplay=3)
+            viewer.add_image(x[0])
+            viewer.add_labels(y[0].astype(int))
+            viewer.add_labels(pred_thresh[0].astype(int), num_colors=2)
diff --git a/brainlit/utils/cnn_segmentation/preprocess_cnn.py b/brainlit/utils/cnn_segmentation/preprocess_cnn.py
new file mode 100644
index 000000000..01645223f
--- /dev/null
+++ b/brainlit/utils/cnn_segmentation/preprocess_cnn.py
@@ -0,0 +1,178 @@
+# preprocessing data from tifs to tensors for evaluation
+
+from skimage import io
+import numpy as np
+from pathlib import Path
+import os
+from tqdm.notebook import tqdm
+import torch
+from torch.utils.data import DataLoader
+
+
+def get_img_and_mask(data_dir):
+    """Get lists of tif images and associated ground truth masks
+
+    Arguments:
+        data_dir: str, path to tif and mask files
+
+    Returns:
+        List of 3d np array images: X_img
+        List of 3d np array masks: y_img
+    """
+    im_dir = Path(os.path.join(data_dir, "sample-tif-location"))
+    gfp_files = list(im_dir.glob("**/*-gfp.tif"))
+    X_img = []
+    y_mask = []
+
+    for i, im_path in enumerate(tqdm(gfp_files)):
+
+        f = im_path.parts[-1][:-8].split("_")
+        image = f[0]
+        num = int(f[1])
+
+        if (image == "test" and num in [9, 10, 24]) or (
+            image == "validation" and num in [11]
+        ):
+            continue
+
+        # getting image
+        im = io.imread(im_path, plugin="tifffile")
+        im = (im - np.amin(im)) / (np.amax(im) - np.amin(im))
+        im = np.swapaxes(im, 0, 2)
+        im_padded = np.pad(im, ((4, 4), (4, 4), (3, 3)))
+
+        # getting ground truth mask
+        file_name = (
+            str(im_path)[
+                str(im_path).find("\\", 80) + 1 : (str(im_path).find("sample"))
+            ]
+            + "/mask-location/"
+        )
+        file_num = file_name[file_name.find("_") + 1 :]
+        if file_name[0] == "v":
+            file_num = str(int(file_num) + 25)
+        mask_path = Path(file_name + f[0] + "_" + f[1] + "_mask.npy")
+        mask = np.load(mask_path)
+
+        X_img.append(im)
+        y_mask.append(mask)
+
+    return X_img, y_mask
+
+
+def train_test_split(X_img, y_mask, test_percent=0.25):
+    """Get train/test/split of images and masks
+    Args:
+        X_img: list of 3d np array images
+        y_mask: list of 3d np array masks
+
+    Returns:
+        Lists of specifie training and testing size: X_train, y_train, X_test, y_test: l
+    """
+    num_images = len(X_img)
+    test_images = num_images * test_percent
+    train_images = int(num_images - test_images)
+
+    X_train = X_img[0:train_images]
+    y_train = y_mask[0:train_images]
+
+    X_test = X_img[train_images:num_images]
+    y_test = y_mask[train_images:num_images]
+
+    return X_train, y_train, X_test, y_test
+
+
+def get_subvolumes(X_train, y_train, x_dim, y_dim, z_dim):
+    """Get subvolumes of specified site for training dataset
+
+    Arguments:
+        X_train: list of imgs, from train_test_split function
+        y_train: list of masks, from train_test_split function
+        x_dim: int, x_dim of subvolume, must be divisible by image shape
+        y_dim: int, y_dim of subvolume, must be divisible by image shape
+        z_dim: int, z_dim of subvolume, must be divisible by image shape
+
+    Returns:
+        X_train_subvolume: List of image subvolumes, for training
+        y_train_subvolume: List of associated mask subvolumes, for training
+    """
+    X_train_subvolumes = []
+    y_train_subvolumes = []
+
+    # getting subvolumes
+    for image in X_train:
+        i = 0
+        while i < image.shape[0]:
+            j = 0
+            while j < image.shape[1]:
+                k = 0
+                while k < image.shape[2]:
+                    subvol = image[i : i + x_dim, j : j + y_dim, k : k + z_dim]
+                    X_train_subvolumes.append(subvol)
+                    k += z_dim
+                j += y_dim
+            i += x_dim
+
+    for mask in y_train:
+        i = 0
+        while i < mask.shape[0]:
+            j = 0
+            while j < mask.shape[1]:
+                k = 0
+                while k < mask.shape[2]:
+                    subvol = mask[i : i + x_dim, j : j + y_dim, k : k + z_dim]
+                    y_train_subvolumes.append(subvol)
+                    k += z_dim
+                j += y_dim
+            i += x_dim
+
+    return X_train_subvolumes, y_train_subvolumes
+
+
+def getting_torch_objects(X_train_subvolumes, y_train_subvolumes, X_test, y_test):
+    """Get training data in torch object format
+
+    Arguments:
+        X_train_subvolumes: list, training images (or subvolumes) from get_subvolumes function
+        y_train_subvolumes: list, trianing masks (or subvolumes) from get_subvolumes function
+        X_test: list, testing images from train_test_split function
+        y_test: list, testing masks from train_test_split function
+
+    Returns:
+        List of image subvolumes for training: X_train_subvolume
+        List of associated mask subvolumes for training: y_train_subvolumes
+    """
+    x_dim = X_train_subvolumes[0].shape[0]
+    y_dim = X_train_subvolumes[0].shape[1]
+    z_dim = X_train_subvolumes[0].shape[2]
+    length = len(X_train_subvolumes)
+
+    img_x_dim = X_test[0].shape[0]
+    img_y_dim = X_test[0].shape[1]
+    img_z_dim = X_test[0].shape[2]
+
+    X_torch_train = np.reshape(X_train_subvolumes, (1, length, x_dim, y_dim, z_dim))
+    y_torch_train = np.reshape(y_train_subvolumes, (1, length, x_dim, y_dim, z_dim))
+
+    X_torch_test = np.reshape(X_test, (1, len(X_test), img_x_dim, img_y_dim, img_z_dim))
+    y_torch_test = np.reshape(y_test, (1, len(y_test), img_x_dim, img_y_dim, img_z_dim))
+
+    training_data = torch.tensor([X_torch_train, y_torch_train]).float()
+    test_data = torch.tensor([X_torch_test, y_torch_test]).float()
+
+    batch_size = 2
+    # Create data loaders.
+    train_dataloader = DataLoader(training_data, batch_size=batch_size)
+    test_dataloader = DataLoader(test_data, batch_size=batch_size)
+
+    # printing dataloader dimensions
+    train_features, train_labels = next(iter(train_dataloader))
+    print(f"Training features shape: {train_features.size()}")
+    test_features, test_labels = next(iter(test_dataloader))
+    print(f"Testing features shape: {test_features.size()}")
+
+    # printing device torch is using (cuda or cpu)
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    print("Using {} device".format(device))
+
+    return train_dataloader, test_dataloader
diff --git a/brainlit/utils/cnn_segmentation/tests/test_performance_cnn.py b/brainlit/utils/cnn_segmentation/tests/test_performance_cnn.py
new file mode 100644
index 000000000..67d0543c5
--- /dev/null
+++ b/brainlit/utils/cnn_segmentation/tests/test_performance_cnn.py
@@ -0,0 +1,41 @@
+import pytest
+
+import numpy as np
+import torch
+
+from brainlit.utils.cnn_segmentation import performance_cnn
+from numpy.testing import (
+    assert_array_equal,
+)
+
+############################
+### functionality checks ###
+############################
+
+
+def test_get_metrics():
+    pred_list = [
+        torch.from_numpy(np.zeros(shape=(4, 4, 4))),
+        torch.from_numpy(np.ones(shape=(4, 4, 4))),
+    ]
+    y_list = [
+        torch.from_numpy(np.ones(shape=(4, 4, 4))),
+        torch.from_numpy(np.ones(shape=(4, 4, 4))),
+    ]
+
+    (
+        acc_list,
+        precision_list,
+        recall_list,
+        percent_nonzero,
+    ) = performance_cnn.get_metrics(pred_list, y_list)
+
+    acc_true = [0.0, 100.0]
+    precision_true = [0.0, 100.0]
+    recall_true = [0.0, 100.0]
+    percent_nonzero_true = [0.0, 100.0]
+
+    assert_array_equal(acc_list, acc_true)
+    assert_array_equal(precision_list, precision_true)
+    assert_array_equal(recall_list, recall_true)
+    assert_array_equal(percent_nonzero, percent_nonzero_true)
diff --git a/brainlit/utils/cnn_segmentation/tests/test_preprocess_cnn.py b/brainlit/utils/cnn_segmentation/tests/test_preprocess_cnn.py
new file mode 100644
index 000000000..115510c39
--- /dev/null
+++ b/brainlit/utils/cnn_segmentation/tests/test_preprocess_cnn.py
@@ -0,0 +1,83 @@
+import pytest
+
+import numpy as np
+from brainlit.utils.cnn_segmentation import preprocess_cnn
+from numpy.testing import (
+    assert_array_equal,
+)
+
+############################
+### functionality checks ###
+############################
+
+
+def test_train_test_split():
+    X_img = [0, 1, 2, 3]
+    y_mask = [0.0, 1.1, 2.2, 3.3]
+
+    X_train, y_train, X_test, y_test = preprocess_cnn.train_test_split(X_img, y_mask)
+
+    X_train_true = [0, 1, 2]
+    y_train_true = [0.0, 1.1, 2.2]
+    X_test_true = [3]
+    y_test_true = [3.3]
+
+    assert_array_equal(X_train, X_train_true)
+    assert_array_equal(y_train, y_train_true)
+    assert_array_equal(X_test, X_test_true)
+    assert_array_equal(y_test, y_test_true)
+
+
+def test_get_subvolumes():
+    X_train = [np.zeros(shape=(4, 4, 4))]
+    y_train = [np.ones(shape=(4, 4, 4))]
+
+    x_dim = 2
+    y_dim = 2
+    z_dim = 2
+
+    X_train_subvolumes, y_train_subvolumes = preprocess_cnn.get_subvolumes(
+        X_train, y_train, x_dim, y_dim, z_dim
+    )
+
+    X_train_subvolumes_true = [
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+        np.zeros(shape=(2, 2, 2)),
+    ]
+
+    y_train_subvolumes_true = [
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+        np.ones(shape=(2, 2, 2)),
+    ]
+
+    assert_array_equal(X_train_subvolumes[0], X_train_subvolumes_true[0])
+    assert_array_equal(y_train_subvolumes[0], y_train_subvolumes_true[0])
+
+
+def test_getting_torch_objects():
+    X_train = [np.zeros(shape=(4, 4, 4))]
+    y_train = [np.ones(shape=(4, 4, 4))]
+    X_test = [np.zeros(shape=(4, 4, 4))]
+    y_test = [np.ones(shape=(4, 4, 4))]
+
+    train_dataloader, test_dataloader = preprocess_cnn.getting_torch_objects(
+        X_train, y_train, X_test, y_test
+    )
+
+    train_dataloader_size = [2, 1, 1, 4, 4, 4]
+    test_dataloader_size = [2, 1, 1, 4, 4, 4]
+
+    assert_array_equal(list(next(iter(train_dataloader)).size()), train_dataloader_size)
+    assert_array_equal(list(next(iter(test_dataloader)).size()), test_dataloader_size)
diff --git a/brainlit/utils/make_masks.py b/brainlit/utils/make_masks.py
new file mode 100644
index 000000000..294bfdf8d
--- /dev/null
+++ b/brainlit/utils/make_masks.py
@@ -0,0 +1,146 @@
+from brainlit.utils.Neuron_trace import NeuronTrace
+import numpy as np
+from skimage import io
+import os
+from scipy.ndimage.morphology import distance_transform_edt
+from pathlib import Path
+from brainlit.viz.swc2voxel import Bresenham3D
+from brainlit.utils.benchmarking_params import (
+    brain_offsets,
+    vol_offsets,
+    scales,
+    type_to_date,
+)
+
+
+def make_masks(data_dir):
+    """Swc to numpy mask
+
+    Arguments:
+        data_dir: direction to base data folder that download_benchmarking points to.
+        Should contain sample-tif-location and sample-swc-location
+
+    Returns:
+        Saved numpy masks in data-dir/mask-location for each image in sample-tif-location
+    """
+    im_dir = Path(os.path.join(data_dir, "sample-tif-location"))
+    swc_dir = Path(os.path.join(data_dir, "sample-swc-location"))
+    mask_dir = os.path.join(data_dir, "mask-location")
+    if not os.path.exists(mask_dir):
+        os.makedirs(mask_dir)
+
+    gfp_files = list(im_dir.glob("**/*.tif"))
+
+    for im_num, im_path in enumerate(gfp_files):
+        # loading one gfp image
+        im = io.imread(im_path, plugin="tifffile")
+        im = np.swapaxes(im, 0, 2)
+
+        file_name = im_path.parts[-1][:-8]
+
+        scale, brain_offset, vol_offset, im_offset, dir1, dir2 = get_scales(im_path)
+
+        swc_path = swc_dir / "Manual-GT" / dir1 / dir2
+        swc_files = list(swc_path.glob("**/*.swc"))
+
+        paths_total = []
+
+        # generate paths and save them into paths_total
+        for swc_num, swc in enumerate(swc_files):
+            if "cube" in swc.parts[-1]:
+                # skip the bounding box swc
+                continue
+            swc = str(swc)
+            swc_trace = NeuronTrace(path=swc)
+            paths = swc_trace.get_paths()
+            swc_offset, _, _, _ = swc_trace.get_df_arguments()
+            offset_diff = np.subtract(swc_offset, im_offset)
+
+            # for every path in that swc
+            for path_num, p in enumerate(paths):
+                pvox = (p + offset_diff) / (scale) * 1000
+                paths_total.append(pvox)
+
+        # generate labels by using paths
+        labels_total = paths_to_Bresenham(im, paths_total, dilate_dist=1000)
+
+        label_flipped = labels_total * 0
+        label_flipped[labels_total == 0] = 1
+        dists = distance_transform_edt(label_flipped, sampling=scale)
+        labels_total[dists <= 1000] = 1
+
+        im_file_name = file_name + "_mask.npy"
+        out_file = mask_dir + "/" + im_file_name
+        np.save(out_file, labels_total)
+
+
+def get_scales(im_path):
+    """Get image and swc scaling factors
+
+    Arguments:
+        im_path: path to image
+
+    Returns:
+        scale: scaling image factor from benchmarking_params
+        brain_offset: brain_offset image factor from benchmarking_params
+        vol_offset: vol_offset image factor from benchmarking_params
+        im_offset: image offset factor from benchmarking_params
+        dir1: swc dir 1 to find swc file
+        dir2: swc dir 2 to find swc file
+    """
+    f = im_path.parts[-1][:-8].split("_")
+    image = f[0]
+    date = type_to_date[image]
+    num = int(f[1])
+
+    scale = scales[date]
+    brain_offset = brain_offsets[date]
+    vol_offset = vol_offsets[date][num]
+    im_offset = np.add(brain_offset, vol_offset)
+
+    # loading all the .swc files corresponding to the image
+    # all the paths of .swc files are saved in variable swc_files
+    lower = int(np.floor((num - 1) / 5) * 5 + 1)
+    upper = int(np.floor((num - 1) / 5) * 5 + 5)
+    dir1 = date + "_" + image + "_" + str(lower) + "-" + str(upper)
+    dir2 = date + "_" + image + "_" + str(num)
+
+    return scale, brain_offset, vol_offset, im_offset, dir1, dir2
+
+
+def paths_to_Bresenham(im, paths_total, dilate_dist=1000):
+    """generate Dilated Mask using paths
+
+    Arguments:
+        im: image corresponding to mask
+        paths_total: list of all paths from swc files
+        dilate_dist: amount in microns to dilate mask by, default = 1000
+    Returns:
+        labels_total: dilated mask from path
+    """
+    labels_total = np.zeros(im.shape)
+
+    for path_voxel in paths_total:
+        for voxel_num, voxel in enumerate(path_voxel):
+            if voxel_num == 0:
+                continue
+            voxel_prev = path_voxel[voxel_num - 1, :]
+            xs, ys, zs = Bresenham3D(
+                int(voxel_prev[0]),
+                int(voxel_prev[1]),
+                int(voxel_prev[2]),
+                int(voxel[0]),
+                int(voxel[1]),
+                int(voxel[2]),
+            )
+            for x, y, z in zip(xs, ys, zs):
+                vox = np.array((x, y, z))
+                if (vox >= 0).all() and (vox < im.shape).all():
+                    labels_total[x, y, z] = 1
+
+    label_flipped = labels_total * 0
+    label_flipped[labels_total == 0] = 1
+    dists = distance_transform_edt(label_flipped, sampling=scale)
+    labels_total[dists <= dilate_dist] = 1
+
+    return labels_total
diff --git a/docs/reference/utils.rst b/docs/reference/utils.rst
index 7506fb75b..924942bb1 100644
--- a/docs/reference/utils.rst
+++ b/docs/reference/utils.rst
@@ -11,6 +11,10 @@ Data Helper Methods
 
 .. autoapiclass:: NeuronTrace
     :members:
+    
+.. currentmodule:: brainlit.utils.make_masks
+    
+.. autoapifunction:: make_masks
 
 .. currentmodule:: brainlit.utils.upload_to_neuroglancer
 
@@ -24,3 +28,20 @@ S3 Helper Methods
 .. autoapifunction:: upload_chunks
 .. autoapifunction:: get_file_paths
 .. autoapifunction:: main
+
+
+CNN Segmentation
+-------------------
+
+.. currentmodule:: brainlit.utils.cnn_segmentation.preprocess_cnn
+
+.. autoapifunction:: get_subvolumes
+.. autoapifunction:: getting_torch_objects
+
+.. currentmodule:: brainlit.utils.cnn_segmentation.performance_cnn
+
+.. autoapifunction:: train_loop
+.. autoapifunction:: test_loop
+.. autoapifunction:: get_metrics
+
+
diff --git a/experiments/pytorch_model/Pytorch Segmentation.ipynb b/experiments/pytorch_model/Pytorch Segmentation.ipynb
new file mode 100644
index 000000000..230aacace
--- /dev/null
+++ b/experiments/pytorch_model/Pytorch Segmentation.ipynb	
@@ -0,0 +1,608 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "cd35537c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from brainlit.utils.cnn_segmentation import *\n",
+    "from brainlit.utils import make_masks\n",
+    "\n",
+    "import warnings\n",
+    "\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "892b6c02",
+   "metadata": {},
+   "source": [
+    "### Downloading Benchmarking Data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "f089bd1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import boto3\n",
+    "from botocore import UNSIGNED\n",
+    "from botocore.client import Config\n",
+    "import os\n",
+    "from pathlib import Path\n",
+    "import numpy as np\n",
+    "from skimage import io\n",
+    "from tqdm import tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ec1b7beb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading segments to /Users/shrey2/Documents/NDD/brainlit/experiments/pytorch_model/data\n"
+     ]
+    }
+   ],
+   "source": [
+    "cwd = Path(os.path.abspath(\"\"))\n",
+    "data_dir = os.path.join(cwd, \"data\")\n",
+    "print(f\"Downloading segments to {data_dir}\")\n",
+    "if not os.path.exists(data_dir):\n",
+    "    os.makedirs(data_dir)\n",
+    "\n",
+    "im_dir = Path(os.path.join(data_dir, \"sample-tif-location\"))\n",
+    "if not os.path.exists(im_dir):\n",
+    "    os.makedirs(im_dir)\n",
+    "\n",
+    "swc_dir = Path(os.path.join(data_dir, \"sample-swc-location\"))\n",
+    "if not os.path.exists(swc_dir):\n",
+    "    os.makedirs(swc_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bb987499",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "52it [11:33, 13.34s/it]\n"
+     ]
+    }
+   ],
+   "source": [
+    "s3 = boto3.resource(\"s3\", config=Config(signature_version=UNSIGNED))\n",
+    "bucket = s3.Bucket(\"open-neurodata\")\n",
+    "prefix = \"brainlit/benchmarking_data/tif-files\"  # use this for windows\n",
+    "# prefix = os.path.join(\"brainlit\", \"benchmarking_data\", \"tif-files\") #use this for mac/linux\n",
+    "im_count = 0\n",
+    "for _ in bucket.objects.filter(Prefix=prefix):\n",
+    "    im_count += 1\n",
+    "for i, im_obj in enumerate(tqdm(bucket.objects.filter(Prefix=prefix))):\n",
+    "    if im_obj.key[-4:] == \".tif\":\n",
+    "        im_name = os.path.basename(im_obj.key)\n",
+    "        im_path = os.path.join(im_dir, im_name)\n",
+    "        bucket.download_file(im_obj.key, im_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1203860b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "601it [00:53, 11.24it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "s3 = boto3.resource(\"s3\", config=Config(signature_version=UNSIGNED))\n",
+    "bucket = s3.Bucket(\"open-neurodata\")\n",
+    "prefix = \"brainlit/benchmarking_data/Manual-GT\"  # use this for windows\n",
+    "# prefix = os.path.join(\"brainlit\", \"benchmarking_data\", \"Manual-GT\") #use this for mac/linux\n",
+    "swc_count = 0\n",
+    "for _ in bucket.objects.filter(Prefix=prefix):\n",
+    "    swc_count += 1\n",
+    "for i, swc_obj in enumerate(tqdm(bucket.objects.filter(Prefix=prefix))):\n",
+    "    if swc_obj.key[-4:] == \".swc\":\n",
+    "        idx = swc_obj.key.find(\"Manual-GT\")\n",
+    "        swc_name = swc_obj.key[idx:]\n",
+    "        swc_path = os.path.join(swc_dir, swc_name)\n",
+    "        dir = os.path.dirname(swc_path)\n",
+    "        if not os.path.exists(dir):\n",
+    "            os.makedirs(dir)\n",
+    "        bucket.download_file(swc_obj.key, swc_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "374d960c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# creating image masks\n",
+    "make_masks(data_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dbd22cc6",
+   "metadata": {},
+   "source": [
+    "### Preprocessing data (preprocess.py)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "436c14f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "50cc88076eb74b669a933068d2eaf18a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/50 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# getting images and masks\n",
+    "X_img, y_mask = get_img_and_mask(data_dir)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "6b36feed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# train/test split of specified test size\n",
+    "X_train, y_train, X_test, y_test = train_test_split(X_img, y_mask, test_percent=0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "15ec1f3c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# getting training subvolumes <- can skip if you do want to train on whole image\n",
+    "X_train_subvolumes, y_train_subvolumes = get_subvolumes(\n",
+    "    X_train, y_train, x_dim=66, y_dim=66, z_dim=20\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "c746c8b2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training features shape: torch.Size([1, 4250, 66, 66, 20])\n",
+      "Testing features shape: torch.Size([1, 12, 330, 330, 100])\n",
+      "Using cpu device\n"
+     ]
+    }
+   ],
+   "source": [
+    "# getting torch objects\n",
+    "train_dataloader, test_dataloader = getting_torch_objects(\n",
+    "    X_train_subvolumes, y_train_subvolumes, X_test, y_test\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "619aa323",
+   "metadata": {},
+   "source": [
+    "### Training model (performance.py)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "bb693d60",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NeuralNetwork(\n",
+      "  (linear_relu_stack): Sequential(\n",
+      "    (0): Conv3d(1, 1, kernel_size=(3, 3, 3), stride=(1, 1, 1), padding=(1, 1, 1))\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Define your own neural network architecture here\n",
+    "\n",
+    "\n",
+    "class NeuralNetwork(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(NeuralNetwork, self).__init__()\n",
+    "        self.linear_relu_stack = nn.Sequential(\n",
+    "            nn.Conv3d(1, 1, kernel_size=3, stride=1, padding=1),\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        logits = self.linear_relu_stack(x)\n",
+    "        self.Sigmoid = nn.Sigmoid()\n",
+    "        logits = self.Sigmoid(logits)\n",
+    "        return logits\n",
+    "\n",
+    "\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
+    "model = NeuralNetwork().to(device)\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "badb0e38",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      "  0%|                                                     | 0/3 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1\n",
+      "-------------------------------\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 33%|███████████████                              | 1/3 [00:14<00:29, 14.51s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Avg test loss: 0.9932302584250768\n",
+      "Epoch 2\n",
+      "-------------------------------\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\r",
+      " 67%|██████████████████████████████               | 2/3 [00:28<00:14, 14.47s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Avg test loss: 0.9930826673905054\n",
+      "Epoch 3\n",
+      "-------------------------------\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████████████████████████████████████████████| 3/3 [00:46<00:00, 15.59s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Avg test loss: 0.9929339289665222\n",
+      "Done!\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# loss_fn = nn.BCELoss()\n",
+    "loss_fn = DiceLoss()\n",
+    "learning_rate = 0.09\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
+    "epochs = 3\n",
+    "\n",
+    "pred_list = []\n",
+    "y_list = []\n",
+    "loss_list = []\n",
+    "\n",
+    "for t in tqdm(range(epochs)):\n",
+    "    print(f\"Epoch {t+1}\\n-------------------------------\")\n",
+    "    train_loop(train_dataloader, model, loss_fn, optimizer)\n",
+    "    x_list, y_pred, y, loss = test_loop(test_dataloader, model, loss_fn)\n",
+    "\n",
+    "    pred_list.append(y_pred)\n",
+    "    y_list.append(y)\n",
+    "    loss_list.append(loss)\n",
+    "\n",
+    "print(\"Done!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "eb5bed4a",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b1b35fae71f74ec5b744808b1831acc5",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "239f3762a7164837b12c8688b7721f86",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "15c7f1d5c9e6490d9e6852c0d3205463",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f573f2bfed254848a91ae709ef55e0c1",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Accuracy at epoch 2 is 69.84087465564738\n",
+      "Precision at epoch 2 is 8.873433632571595\n",
+      "Recall at epoch 2 is 69.81770947917717\n",
+      "Percent nonzero at epoch 2 is 30.34612182430364\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "6c38cf6e3d874e88a8f83faf138abf9d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/12 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# getting performance metrics over all epochs\n",
+    "acc_list, precision_list, recall_list, percent_nonzero = get_metrics(pred_list, y_list)\n",
+    "\n",
+    "# printing performance metrics from specific epoch\n",
+    "quick_stats(\"all\", 2, acc_list, precision_list, recall_list, percent_nonzero)\n",
+    "\n",
+    "# plotting metrics\n",
+    "plot_metrics_over_epoch(\n",
+    "    loss_list, acc_list, precision_list, recall_list, percent_nonzero\n",
+    ")\n",
+    "\n",
+    "# plotting precision/recall histograms\n",
+    "plot_pr_histograms(pred_list, y_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1835b0b7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# plotting with napari\n",
+    "# plot_with_napari(x_list, pred_list, y_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "08f8e790",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/setup.py b/setup.py
index 58ea9bebb..287c3c07d 100644
--- a/setup.py
+++ b/setup.py
@@ -28,7 +28,8 @@
 "nibabel>=2.4.1",
 "nilearn>=0.5.2",
 "zarr>=2.10.2",
-"h5py>=3.3.0"
+"h5py>=3.3.0",
+"torch>=1.9.1" 
 
 ]