Upload 28 files

.gitattributes

@@ -35,3 +35,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 sample_data/mnist_test.csv filter=lfs diff=lfs merge=lfs -text
 sample_data/mnist_train_small.csv filter=lfs diff=lfs merge=lfs -text
+CV[[:space:]]final[[:space:]]report.pdf filter=lfs diff=lfs merge=lfs -text

AD_Dataset.py

@@ -0,0 +1,45 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+
+class AD_Dataset(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file, transform=None):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+            transform (callable, optional): Optional transform to be applied on a sample.
+            data_augmentation (boolean): Optional data augmentation.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+        self.transform = transform
+    
+    def __len__(self):
+        return sum(1 for line in open(self.data_file))
+    
+    def __getitem__(self, idx):
+        df = open(self.data_file)
+        lines = df.readlines()
+        lst = lines[idx].split()
+        img_name = lst[0]
+        img_label = lst[1]
+        image_path = os.path.join(self.root_dir, img_name)
+        image = nib.load(image_path)
+
+        
+        if img_label == 'Normal':
+            label = 0
+        elif img_label == 'AD':
+            label = 1
+        elif img_label == 'MCI':
+            label = 2
+
+        if self.transform:
+            image = self.transform(image)
+
+        sample = {'image': image, 'label': label}
+        
+        return sample

AD_Standard_2DRandomSlicesData.py

@@ -0,0 +1,101 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.transform import resize 
+from PIL import Image
+import random
+
+
+AX_INDEX = 78
+COR_INDEX = 79
+SAG_INDEX = 57
+AX_SCETION = "[:, :, slice_i]"
+COR_SCETION = "[:, slice_i, :]"
+SAG_SCETION = "[slice_i, :, :]"
+
+
+class AD_Standard_2DRandomSlicesData(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file, transform=None, slice = slice):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+            transform (callable, optional): Optional transform to be applied on a sample.
+            data_augmentation (boolean): Optional data augmentation.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+        self.transform = transform
+    
+    def __len__(self):
+        return sum(1 for line in open(self.data_file))
+    
+    def __getitem__(self, idx):
+        df = open(self.data_file)
+        lines = df.readlines()
+        lst = lines[idx].split()
+        img_name = lst[0]
+        img_label = lst[1]
+        image_path = os.path.join(self.root_dir, img_name)
+        image = nib.load(image_path)
+        samples = []
+        if img_label == 'Normal':
+            label = 0
+        elif img_label == 'AD':
+            label = 1
+        elif img_label == 'MCI':
+            label = 2
+
+        AXimageList = axRandomSlice(image)
+        CORimageList = corRandomSlice(image)
+        SAGimageList = sagRandomSlice(image)
+
+        for img2DList in (AXimageList, CORimageList, SAGimageList):
+            for image2D in img2DList:
+                if self.transform:
+                    image2D = self.transform(image2D)
+                sample = {'image': image2D, 'label': label}
+                samples.append(sample)
+        random.shuffle(samples)
+        return samples
+
+
+def getRandomSlice(image_array, keyIndex, section, step = 1):
+    slice_p = keyIndex
+    slice_2Dimgs = []
+    slice_select_0 = None
+    slice_select_1 = None
+    slice_select_2 = None
+
+    randomShift = random.randint(-9, 9)
+    slice_p = slice_p + randomShift
+    i = 0
+    for slice_i in range(slice_p-step, slice_p+step+1, step):
+        slice_select = eval("image_array"+section)
+        exec("slice_select_"+str(i)+"=slice_select")
+        i += 1
+    slice_2Dimg = np.stack((slice_select_0, slice_select_1, slice_select_2), axis = 2)
+    slice_2Dimgs.append(slice_2Dimg)
+    return slice_2Dimgs
+
+def axRandomSlice(image):
+    image_array = np.array(image.get_data())
+    return getRandomSlice(image_array, AX_INDEX, AX_SCETION)
+
+
+def corRandomSlice(image):
+    image_array = np.array(image.get_data())
+    return getRandomSlice(image_array, COR_INDEX, COR_SCETION)
+
+
+def sagRandomSlice(image):
+    image_array = np.array(image.get_data())
+    return getRandomSlice(image_array, SAG_INDEX, SAG_SCETION)
+
+
+
+

AD_Standard_2DSlicesData.py

@@ -0,0 +1,95 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.transform import resize 
+from PIL import Image
+import random
+
+
+AX_SCETION = "[:, :, slice_i]"
+COR_SCETION = "[:, slice_i, :]"
+SAG_SCETION = "[slice_i, :, :]"
+AX_INDEX = 78
+COR_INDEX = 79
+SAG_INDEX = 57
+
+class AD_Standard_2DSlicesData(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file, transform=None, slice = slice):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+            transform (callable, optional): Optional transform to be applied on a sample.
+            data_augmentation (boolean): Optional data augmentation.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+        self.transform = transform
+    
+    def __len__(self):
+        return sum(1 for line in open(self.data_file))
+    
+    def __getitem__(self, idx):
+        df = open(self.data_file)
+        lines = df.readlines()
+        lst = lines[idx].split()
+        img_name = lst[0]
+        img_label = lst[1]
+        image_path = os.path.join(self.root_dir, img_name)
+        image = nib.load(image_path)
+        samples = []
+        if img_label == 'Normal':
+            label = 0
+        elif img_label == 'AD':
+            label = 1
+        elif img_label == 'MCI':
+            label = 2
+
+        AXimageList = axKeySlice(image)
+        CORimageList = corKeySlice(image)
+        SAGimageList = sagKeySlice(image)
+
+        for img2DList in (AXimageList, CORimageList, SAGimageList):
+            for image2D in img2DList:
+                if self.transform:
+                    image2D = self.transform(image2D)
+                sample = {'image': image2D, 'label': label}
+                samples.append(sample)
+        random.shuffle(samples)
+        return samples
+
+
+def getSlice(image_array, keyIndex, section, step = 1):
+    slice_p = keyIndex
+    slice_2Dimgs = []
+    slice_select_0 = None
+    slice_select_1 = None
+    slice_select_2 = None
+    i = 0
+    for slice_i in range(slice_p-step, slice_p+step+1, step):
+        slice_select = eval("image_array"+section)
+        exec("slice_select_"+str(i)+"=slice_select")
+        i += 1
+    slice_2Dimg = np.stack((slice_select_0, slice_select_1, slice_select_2), axis = 2)
+    slice_2Dimgs.append(slice_2Dimg)
+    return slice_2Dimgs
+
+
+def axKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, AX_INDEX, AX_SCETION)
+
+
+def corKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, COR_INDEX, COR_SCETION)
+
+
+def sagKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, SAG_INDEX, SAG_SCETION)
+

AD_Standard_2DTestingSlices.py

@@ -0,0 +1,148 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.transform import resize 
+from PIL import Image
+import random
+
+
+AX_INDEX = 78
+COR_INDEX = 79
+SAG_INDEX = 57
+AX_SCETION = "[:, :, slice_i]"
+COR_SCETION = "[:, slice_i, :]"
+SAG_SCETION = "[slice_i, :, :]"
+
+
+class AD_Standard_2DTestingSlices(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file, transform=None, slice = slice, size = 9):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+            transform (callable, optional): Optional transform to be applied on a sample.
+            data_augmentation (boolean): Optional data augmentation.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+        self.transform = transform
+        self.size = size
+    
+    def __len__(self):
+        return sum(1 for line in open(self.data_file))
+    
+    def __getitem__(self, idx):
+        df = open(self.data_file)
+        lines = df.readlines()
+        lst = lines[idx].split()
+        img_name = lst[0]
+        img_label = lst[1]
+        image_path = os.path.join(self.root_dir, img_name)
+        image = nib.load(image_path)
+        samples = []
+        if img_label == 'Normal':
+            label = 0
+        elif img_label == 'AD':
+            label = 1
+        elif img_label == 'MCI':
+            label = 2
+
+        AXimageList = None
+        CORimageList = None
+        SAGimageList = None
+
+        if self.size == 3:
+            AXimageList = axKeySlice(image)
+            CORimageList = corKeySlice(image)
+            SAGimageList = sagKeySlice(image)
+        elif self.size == 9:
+            AXimageList = ax3Slices(image)
+            CORimageList = cor3Slices(image)
+            SAGimageList = sag3Slices(image)
+
+
+        for img2DList in (AXimageList, CORimageList, SAGimageList):
+            for image2D in img2DList:
+                if self.transform:
+                    image2D = self.transform(image2D)
+                sample = {'image': image2D, 'label': label}
+                samples.append(sample)
+        assert len(samples) == self.size
+        random.shuffle(samples)
+        return samples
+
+
+
+def getSlice(image_array, keyIndex, section, step = 1):
+    slice_p = keyIndex
+    slice_2Dimgs = []
+    slice_select_0 = None
+    slice_select_1 = None
+    slice_select_2 = None
+    i = 0
+    for slice_i in range(slice_p-step, slice_p+step+1, step):
+        slice_select = eval("image_array"+section)
+        exec("slice_select_"+str(i)+"=slice_select")
+        i += 1
+    slice_2Dimg = np.stack((slice_select_0, slice_select_1, slice_select_2), axis = 2)
+    slice_2Dimgs.append(slice_2Dimg)
+    return slice_2Dimgs
+
+
+def axKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, AX_INDEX, AX_SCETION)
+
+
+def corKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, COR_INDEX, COR_SCETION)
+
+
+def sagKeySlice(image):
+    image_array = np.array(image.get_data())
+    return getSlice(image_array, SAG_INDEX, SAG_SCETION)
+
+
+
+def get3Slices(image_array, keyIndex, section, step = 1):
+    slice_p = keyIndex
+    slice_2Dimgs = []
+    slice_select_0 = None
+    slice_select_1 = None
+    slice_select_2 = None
+    for shift in (-5, 0, 5):
+        slice_sp = slice_p + shift
+        i = 0
+        slice_select_0 = None
+        slice_select_1 = None
+        slice_select_2 = None
+        for slice_i in range(slice_sp-step, slice_sp+step+1, step):
+            slice_select = eval("image_array"+section)
+            exec("slice_select_"+str(i)+"=slice_select")
+            i += 1
+        slice_2Dimg = np.stack((slice_select_0, slice_select_1, slice_select_2), axis = 2)
+        slice_2Dimgs.append(slice_2Dimg)
+    return slice_2Dimgs
+
+
+
+def ax3Slices(image):
+    image_array = np.array(image.get_data())
+    return get3Slices(image_array, AX_INDEX, AX_SCETION)
+
+
+def cor3Slices(image):
+    image_array = np.array(image.get_data())
+    return get3Slices(image_array, COR_INDEX, COR_SCETION)
+
+
+def sag3Slices(image):
+    image_array = np.array(image.get_data())
+    return get3Slices(image_array, SAG_INDEX, SAG_SCETION)
+
+

AD_Standard_3DRandomPatch.py

@@ -0,0 +1,94 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+import numpy as np
+import matplotlib.pyplot as plt
+from skimage.transform import resize 
+from PIL import Image
+import random
+import torch
+
+NON_AX = (0, 1)
+NON_COR = (0, 2)
+NON_SAG = (1, 2)
+
+
+class AD_Standard_3DRandomPatch(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+    
+    def __len__(self):
+        with open(self.data_file) as df:
+            summation = sum(1 for line in df)
+        return summation
+    
+    def __getitem__(self, idx):
+        with open(self.data_file) as df:
+            lines = df.readlines()
+            lst = lines[idx].split()
+            img_name = lst[0]
+            image_path = os.path.join(self.root_dir, img_name)
+            image = nib.load(image_path)
+
+            image_array = np.array(image.get_data())
+            patch_samples = getRandomPatches(image_array)
+            patch_dict = {"patch": patch_samples}
+        return patch_dict
+
+
+def customToTensor(pic):
+    if isinstance(pic, np.ndarray):
+        img = torch.from_numpy(pic)
+        img = torch.unsqueeze(img,0)
+        # backward compatibility
+        return img.float()
+
+def getRandomPatches(image_array):
+    patches = []
+    mean_ax = np.ndarray.mean(image_array, axis = NON_AX)
+    mean_cor = np.ndarray.mean(image_array, axis = NON_COR)
+    mean_sag = np.ndarray.mean(image_array, axis = NON_SAG)
+
+    first_ax = int(round(list(mean_ax).index(filter(lambda x: x>0, mean_ax)[0])))
+    last_ax = int(round(list(mean_ax).index(filter(lambda x: x>0, mean_ax)[-1])))
+    first_cor = int(round(list(mean_cor).index(filter(lambda x: x>0, mean_cor)[0])))
+    last_cor = int(round(list(mean_cor).index(filter(lambda x: x>0, mean_cor)[-1])))
+    first_sag = int(round(list(mean_sag).index(filter(lambda x: x>0, mean_sag)[0])))
+    last_sag = int(round(list(mean_sag).index(filter(lambda x: x>0, mean_sag)[-1])))
+
+    first_ax = first_ax + 20
+    last_ax = last_ax - 5
+
+    ax_samples = [random.randint(first_ax - 3, last_ax - 3) for r in xrange(10000)]
+    cor_samples = [random.randint(first_cor - 3, last_cor - 3) for r in xrange(10000)]
+    sag_samples = [random.randint(first_sag - 3, last_sag - 3) for r in xrange(10000)]
+
+    for i in range(1000):
+        ax_i = ax_samples[i]
+        cor_i = cor_samples[i]
+        sag_i = sag_samples[i]
+        patch = image_array[ax_i-3:ax_i+4, cor_i-3:cor_i+4, sag_i-3:sag_i+4]
+        while (np.ndarray.sum(patch) == 0):
+            ax_ni = random.randint(first_ax - 3, last_ax - 4)
+            cor_ni = random.randint(first_cor - 3, last_cor - 4)
+            sag_ni = random.randint(first_sag - 3, last_sag - 4)
+            patch = image_array[ax_ni-3:ax_ni+4, cor_ni-3:cor_ni+4, sag_ni-3:sag_ni+4]
+        patch = customToTensor(patch)
+        patches.append(patch)
+    return patches
+
+
+# plt.imshow(array[i][3,:,:], cmap = 'gray')
+# plt.savefig('./section.png', dpi=100)
+
+
+
+

AD_Standard_CNN_Dataset.py

@@ -0,0 +1,69 @@
+import nibabel as nib
+import os
+from torch.utils.data import Dataset
+import numpy as np
+import torch
+import random
+
+class AD_Standard_CNN_Dataset(Dataset):
+    """labeled Faces in the Wild dataset."""
+    
+    def __init__(self, root_dir, data_file, transform=None, noise=True):
+        """
+        Args:
+            root_dir (string): Directory of all the images.
+            data_file (string): File name of the train/test split file.
+            transform (callable, optional): Optional transform to be applied on a sample.
+            data_augmentation (boolean): Optional data augmentation.
+        """
+        self.root_dir = root_dir
+        self.data_file = data_file
+        self.transform = transform
+        self.noise = noise
+    
+    def __len__(self):
+        return sum(1 for line in open(self.data_file))
+    
+    def __getitem__(self, idx):
+        df = open(self.data_file)
+        lines = df.readlines()
+        lst = lines[idx].split()
+        img_name = lst[0]
+        img_label = lst[1]
+        image_path = os.path.join(self.root_dir, img_name)
+        image = nib.load(image_path)
+        
+        if img_label == 'Normal':
+            label = 0
+        elif img_label == 'AD':
+            label = 1
+        elif img_label == 'MCI':
+            label = 2
+        
+        image_array = np.array(image.get_data())
+        if self.noise:
+            image_array = gaussianNoise(image_array)
+        image_array = customToTensor(image_array)
+        sample = {'image': image_array, 'label': label}
+        
+        return sample
+
+def customToTensor(pic):
+    if isinstance(pic, np.ndarray):
+        img = torch.from_numpy(pic)
+        img = torch.unsqueeze(img,0)
+        # backward compatibility
+        return img.float()
+
+def gaussianNoise(img_array):
+    var_lst = [0, 0.0005, 0.00075, 0.001, 0.0025, 0.005]
+    w,h,d= img_array.shape
+    mean = 0
+    var = random.choice(var_lst)
+    sigma = var**0.5
+    gauss_noise = np.random.normal(mean,sigma,(w,h,d))
+    gauss_noise = gauss_noise.reshape(w,h,d)
+    noise_image = img_array + gauss_noise
+    return noise_image
+
+

AlexNet2D.py

@@ -0,0 +1,74 @@
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+import math
+
+
+__all__ = ['AlexNet', 'alexnet']
+
+
+model_urls = {
+    'alexnet': 'https://download.pytorch.org/models/alexnet-owt-4df8aa71.pth',
+}
+
+
+class AlexNet(nn.Module):
+
+    def __init__(self, num_classes=1000):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+            nn.Conv2d(192, 384, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(384, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=3, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(),
+            nn.Linear(256 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Linear(4096, num_classes),
+        )
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), 256 * 6 * 6)
+        x = self.classifier(x)
+        return x
+
+
+def alexnet(pretrained=False, **kwargs):
+    r"""AlexNet model architecture from the
+    `"One weird trick..." <https://arxiv.org/abs/1404.5997>`_ paper.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+    """
+    model = AlexNet(**kwargs)
+    if pretrained:
+        model.load_state_dict(model_zoo.load_url(model_urls['alexnet']))
+        for p in model.features.parameters():
+            p.requires_grad = False
+
+        # fine-tune the last convolution layer
+        for p in model.features[10].parameters():
+            p.requires_grad = True
+
+    model.classifier.add_module('fc_out', nn.Linear(1000,2))
+    model.classifier.add_module('sigmoid', nn.LogSoftmax())
+
+    stdv = 1.0 / math.sqrt(1000)
+    for p in model.classifier.fc_out.parameters():
+        p.data.uniform_(-stdv, stdv)
+
+    return model

AlexNet3D.py

@@ -0,0 +1,46 @@
+import torch.nn as nn
+
+class AlexNet(nn.Module):
+
+    def __init__(self, num_classes=3):
+        super(AlexNet, self).__init__()
+        self.features = nn.Sequential(
+            nn.Conv3d(1, 64, kernel_size=11, stride=4, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool3d(kernel_size=3, stride=2),
+            nn.Conv3d(64, 192, kernel_size=5, padding=2),
+            nn.ReLU(inplace=True),
+            nn.MaxPool3d(kernel_size=3, stride=2),
+            nn.Conv3d(192, 384, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv3d(384, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.Conv3d(256, 256, kernel_size=3, padding=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool3d(kernel_size=3, stride=2),
+        )
+        self.classifier = nn.Sequential(
+            nn.Dropout(),
+            nn.Linear(256 * 6 * 6 * 6, 4096),
+            nn.ReLU(inplace=True),
+            nn.Dropout(),
+            nn.Linear(4096, 4096),
+            nn.ReLU(inplace=True),
+            nn.Linear(4096, num_classes),
+        )
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for weight in self.parameters():
+            weight.data.uniform_(-0.1, 0.1)
+
+
+
+
+
+    def forward(self, x):
+        x = self.features(x)
+        x = x.view(x.size(0), 256 * 6 * 6 * 6)
+        x = self.classifier(x)
+        return x

CV final report.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5099301619a38b57ba1afc6e67e92f2dfe0c18e759b4b47e4388bfc321fac146
+size 1664143

autoencoder.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+
+class AutoEncoder(nn.Module):
+    def __init__(self):
+        super(AutoEncoder, self).__init__()
+        self.encoder = nn.Linear(343, 410)
+        self.sparsify = nn.Sigmoid()
+        self.decoder = nn.Linear(410, 343)
+
+    def forward(self, out):
+        out = out.view(-1, 343)
+        out = self.encoder(out)
+        out = self.sparsify(out)
+        s_ = out
+        out = self.decoder(out)
+        return out, s_

cnn_3d_with_ae.py

@@ -0,0 +1,43 @@
+import torch
+from autoencoder import AutoEncoder 
+import torch.nn as nn
+import math
+
+class CNN(nn.Module):
+    def __init__(self, num_classes=2):
+        super(CNN, self).__init__()
+        self.conv1 = nn.Conv3d(1, 410, kernel_size=7, stride=7, padding=3)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.pool1 = nn.MaxPool3d(kernel_size=7,stride=7)
+        # self.conv2 = nn.Conv3d(410, 200, kernel_size=3, stride=1, padding=1)
+        # self.relu2 = nn.ReLU(inplace=True)
+        # self.pool2 = nn.MaxPool3d(kernel_size=3, stride=3)
+        # self.fc1 = nn.Linear(5*5*5*200, 800)
+        self.dropout1 = nn.Dropout(0.5)
+        self.fc1 = nn.Linear(2*3*2*410, 80)
+        self.dropout2 = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(80, num_classes)
+        self.softmax = nn.LogSoftmax()
+        self.parameter_initialization()
+
+
+
+    def forward(self, out):
+        out = self.pool1(self.relu1(self.conv1(out)))
+        out = self.dropout1(out)
+        # out = self.pool2(self.relu2(self.conv2(out)))
+        # out = out.view(-1,5*5*5*200)
+        out = out.view(-1, 2*3*2*410)
+        out = self.fc1(out)
+        out = self.dropout2(out)
+        out = self.fc2(out)
+        out = self.softmax(out)
+        return out
+
+    def parameter_initialization(self):
+        stdv = 1.0 / math.sqrt(410)
+        for weight in self.parameters():
+            weight.data.uniform_(-stdv, stdv)
+
+
+

cnn_3d_wtih_ae.py

@@ -0,0 +1,25 @@
+import torch
+from autoencoder import AutoEncoder 
+
+class CNN(nn.Module):
+    def __init__(self, num_classes=2):
+        super(CNN, self).__init__()
+        self.conv = nn.Conv3d(1, 410, kernel_size=7, stride=1, padding=1)
+        self.pool = nn.MaxPool3d(kernel_size=7,stride=7)
+        self.fc1 = nn.Linear(15*15*15, 800)
+        self.fc2 = nn.Linear(800, num_classes)
+        self.softmax = nn.Softmax()
+
+    def forward(self, out):
+        out = self.conv(out)
+        out = self.pool(out)
+        out = out.view(1,15*15*15)
+        out = self.fc1(out)
+        out = self.fc2(out)
+        out = self.softmax(out)
+        return out
+
+    def load_ae(self, ae):
+        cnn.state_dict()['conv.weight'] = ae.state_dict()['encoder.weight'].view(410,1,7,7,7)
+        cnn.state_dict()['conv.bias'] = ae.state_dict()['encoder.bias']
+        return cnn

custom_transform.py

@@ -0,0 +1,49 @@
+import numpy as np
+import random
+import math
+from PIL import Image
+from skimage.transform import resize
+import skimage
+import torch
+import matplotlib.pyplot as plt
+
+
+class CustomResize(object):
+    def __init__(self, network_type, trg_size):
+
+        self.trg_size = trg_size
+        self.network_type = network_type
+
+    def __call__(self, img):
+        resized_img = self.resize_image(img, self.trg_size)
+        return resized_img
+
+    def resize_image(self, img, trg_size):
+        img_array = np.asarray(img.get_data())
+        res = resize(img_array, trg_size, mode='reflect', anti_aliasing=False, preserve_range=True)
+
+        # type check
+        if type(res) != np.ndarray:
+            raise "type error!"
+
+        # PIL image cannot handle 3D image, only return ndarray type, which ToTensor accepts
+        return res
+
+class CustomToTensor(object):
+    def __init__(self, network_type):
+
+        self.network_type = network_type
+
+    def __call__(self, pic):
+
+        if isinstance(pic, np.ndarray):
+            
+            img = torch.from_numpy(pic.transpose((2, 0, 1)))
+            
+            # backward compatibility
+            return img.float().div(255)
+
+
+
+
+        

custom_transform2D.py

@@ -0,0 +1,47 @@
+import numpy as np
+import random
+import math
+from PIL import Image
+from skimage.transform import resize
+import skimage
+import torch
+import matplotlib.pyplot as plt
+
+
+class CustomResize(object):
+    def __init__(self, trg_size):
+
+        self.trg_size = trg_size
+
+
+    def __call__(self, img):
+        resized_img = self.resize_image(img, self.trg_size)
+        return resized_img
+
+    def resize_image(self, img_array, trg_size):
+        res = resize(img_array, trg_size, mode='reflect', preserve_range=True, anti_aliasing=False)
+
+        # type check
+        if type(res) != np.ndarray:
+            raise "type error!"
+
+        # PIL image cannot handle 3D image, only return ndarray type, which ToTensor accepts
+        return res
+
+class CustomToTensor(object):
+    def __init__(self):
+        pass
+
+    def __call__(self, pic):
+
+        if isinstance(pic, np.ndarray):
+            
+            img = torch.from_numpy(pic.transpose((2, 0, 1)))
+            
+            # backward compatibility
+            return img.float()
+
+
+
+
+        

imageExtract.py

@@ -0,0 +1,10 @@
+import shutil
+import os 
+
+for d in os.listdir('./Image'):
+    if d[0] != '.':
+        for f in os.listdir('./Image/' + d):
+            if f[-3:] == 'nii':
+                shutil.move("./Image/" + d + '/' + f, './Image1/' + d)
+shutil.rmtree('./Image')
+

main_alexnet.py

@@ -0,0 +1,238 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch import cuda
+from torch.autograd import Variable
+from torch.utils.data import DataLoader, Dataset
+
+import torchvision
+import torchvision.datasets as dset
+import torchvision.transforms as transforms
+import torchvision.utils
+from PIL import Image
+
+import torch.nn.functional as F
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as ticker
+import numpy as np
+import random
+from collections import Counter
+
+from custom_transform2D import CustomResize
+from custom_transform2D import CustomToTensor
+
+from AD_Dataset import AD_Dataset
+from AD_Standard_2DSlicesData import AD_Standard_2DSlicesData
+from AD_Standard_2DRandomSlicesData import AD_Standard_2DRandomSlicesData
+from AD_Standard_2DTestingSlices import AD_Standard_2DTestingSlices
+
+from AlexNet2D import alexnet
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for JHU CS661 Computer Vision HW3.")
+
+parser.add_argument("--load",
+                    help="Load saved network weights.")
+parser.add_argument("--save", default="AlexNet",
+                    help="Save network weights.")
+parser.add_argument("--augmentation", default=True, type=bool,
+                    help="Save network weights.")
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                    help='momentum')
+parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')
+parser.add_argument("--estop", default=1e-2, type=float,
+                    help="Early stopping criteria on the development set. (default=1e-2)")
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--optimizer", default="Adam", choices=["SGD", "Adadelta", "Adam"],
+                    help="Optimizer of choice for training. (default=Adam)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+
+
+# feel free to add more arguments as you need
+
+
+def main(options):
+    # Path configuration
+    TRAINING_PATH = 'train_2classes.txt'
+    TESTING_PATH = 'test_2classes.txt'
+    IMG_PATH = './Image'
+
+    trg_size = (224, 224)
+
+    transformations = transforms.Compose([CustomResize(trg_size),
+                                          CustomToTensor()
+                                        ])
+    dset_train = AD_Standard_2DRandomSlicesData(IMG_PATH, TRAINING_PATH, transformations)
+    dset_test = AD_Standard_2DSlicesData(IMG_PATH, TESTING_PATH, transformations)
+
+    # Use argument load to distinguish training and testing
+    if options.load is None:
+        train_loader = DataLoader(dset_train,
+                                  batch_size=options.batch_size,
+                                  shuffle=True,
+                                  num_workers=4,
+                                  drop_last=True
+                                  )
+    else:
+        # Only shuffle the data when doing training
+        train_loader = DataLoader(dset_train,
+                                  batch_size=options.batch_size,
+                                  shuffle=False,
+                                  num_workers=4,
+                                  drop_last=True
+                                  )
+
+    test_loader = DataLoader(dset_test,
+                             batch_size=options.batch_size,
+                             shuffle=False,
+                             num_workers=4,
+                             drop_last=True
+                             )
+
+    use_cuda = (len(options.gpuid) >= 1)
+    if options.gpuid:
+        cuda.set_device(options.gpuid[0])
+
+
+    # Initial the model
+    model = alexnet(pretrained=True)
+    # model.load_state_dict(torch.load(options.load))
+
+    if use_cuda > 0:
+        model.cuda()
+    else:
+        model.cpu()
+
+    # Binary cross-entropy loss
+    # criterion = torch.nn.CrossEntropyLoss()
+    criterion = torch.nn.NLLLoss()
+
+    lr = options.learning_rate
+    optimizer = eval("torch.optim." + options.optimizer)(filter(lambda x: x.requires_grad, model.parameters()), lr)
+
+    best_accuracy = float("-inf")
+
+    train_loss_f = open("train_loss.txt", "w")
+    test_acu_f = open("test_accuracy.txt", "w")
+
+    for epoch_i in range(options.epochs):
+
+        logging.info("At {0}-th epoch.".format(epoch_i))
+        train_loss, correct_cnt = train(model, train_loader, use_cuda, criterion, optimizer, train_loss_f)
+        # each instance in one batch has 3 views
+        train_avg_loss = train_loss / (len(dset_train) * 3 / options.batch_size)
+        train_avg_acu = float(correct_cnt) / (len(dset_train) * 3)
+        logging.info(
+            "Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch_i))
+        logging.info("Average training accuracy is {0:.5f} at the end of epoch {1}".format(train_avg_acu, epoch_i))
+
+
+        correct_cnt = validate(model, test_loader, use_cuda, criterion)
+        dev_avg_acu = float(correct_cnt) / len(dset_test)
+        logging.info("Average validation accuracy is {0:.5f} at the end of epoch {1}".format(dev_avg_acu, epoch_i))
+
+        # write validation accuracy to file
+        test_acu_f.write("{0:.5f}\n".format(dev_avg_acu))
+
+        if dev_avg_acu > best_accuracy:
+            best_accuracy = dev_avg_acu
+            torch.save(model.state_dict(), open(options.save, 'wb'))
+
+    train_loss_f.close()
+    test_acu_f.close()
+
+def train(model, train_loader, use_cuda, criterion, optimizer, train_loss_f):
+    # main training loop
+    train_loss = 0.0
+    correct_cnt = 0.0
+    model.train()
+    for it, train_data in enumerate(train_loader):
+        for data_dic in train_data:
+            if use_cuda:
+                imgs, labels = Variable(data_dic['image']).cuda(), Variable(data_dic['label']).cuda()
+            else:
+                imgs, labels = Variable(data_dic['image']), Variable(data_dic['label'])
+            integer_encoded = labels.data.cpu().numpy()
+            # target should be LongTensor in loss function
+            ground_truth = Variable(torch.from_numpy(integer_encoded)).long()
+            if use_cuda:
+                ground_truth = ground_truth.cuda()
+            train_output = model(imgs)
+            _, predict = train_output.topk(1)
+            loss = criterion(train_output, ground_truth)
+            train_loss += loss
+            correct_this_batch = (predict.squeeze(1) == ground_truth).sum().float()
+            correct_cnt += correct_this_batch
+            accuracy = float(correct_this_batch) / len(ground_truth)
+            logging.info("batch {0} training loss is : {1:.5f}".format(it, loss.data[0]))
+            logging.info("batch {0} training accuracy is : {1:.5f}".format(it, accuracy))
+
+            # write the training loss to file
+            train_loss_f.write("{0:.5f}\n".format(loss.data[0]))
+
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+    return train_loss, correct_cnt
+
+
+
+def validate(model, test_loader, use_cuda, criterion):
+    # validation -- this is a crude estimation because there might be some paddings at the end
+    correct_cnt = 0.0
+    model.eval()
+    for it, test_data in enumerate(test_loader):
+        vote = []
+        for data_dic in test_data:
+            if use_cuda:
+                imgs, labels = Variable(data_dic['image'], volatile=True).cuda(), Variable(data_dic['label'],
+                                                                                           volatile=True).cuda()
+            else:
+                imgs, labels = Variable(data_dic['image'], volatile=True), Variable(data_dic['label'],
+                                                                                    volatile=True)
+            test_output = model(imgs)
+            _, predict = test_output.topk(1)
+            vote.append(predict)
+
+        vote = torch.cat(vote, 1)
+        final_vote, _ = torch.mode(vote, 1)
+        ground_truth = test_data[0]['label']
+        correct_this_batch = (final_vote.cpu().data == ground_truth).sum()
+        correct_cnt += correct_this_batch
+        accuracy = float(correct_this_batch) / len(ground_truth)
+
+        logging.info("batch {0} dev accuracy is : {1:.5f}".format(it, accuracy))
+
+    return correct_cnt
+
+
+
+
+def show_plot(points):
+    plt.figure()
+    fig, ax = plt.subplots()
+    loc = ticker.MultipleLocator(base=0.2) # put ticks at regular intervals
+    ax.yaxis.set_major_locator(loc)
+    plt.plot(points)
+
+
+if __name__ == "__main__":
+    ret = parser.parse_known_args()
+    options = ret[0]
+    if ret[1]:
+        logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+    main(options)

main_autoencoder.py

@@ -0,0 +1,103 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch import cuda
+from torch.autograd import Variable
+from torch.utils.data import DataLoader,Dataset
+import torchvision
+
+from autoencoder import AutoEncoder 
+from AD_Standard_3DRandomPatch import AD_Standard_3DRandomPatch
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for AutoEncoder")
+
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                    help='momentum')
+parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+parser.add_argument("--num_classes", default=2, type=int,
+                    help="Number of classes.")
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")
+parser.add_argument("--estop", default=1e-4, type=float,
+                    help="Early stopping criteria on the development set. (default=1e-4)")  
+
+def main(options):
+
+    if options.num_classes == 2:
+        TRAINING_PATH = 'train_2classes.txt'
+    else:
+        TRAINING_PATH = 'train.txt'
+    IMG_PATH = './Whole'
+
+    dset_train = AD_Standard_3DRandomPatch(IMG_PATH, TRAINING_PATH)
+
+    train_loader = DataLoader(dset_train,
+                              batch_size = options.batch_size,
+                              shuffle = True,
+                              num_workers = 4,
+                              drop_last = True
+                              )
+    sparsity = 0.05
+    beta = 0.5
+
+    mean_square_loss = nn.MSELoss()
+    #kl_div_loss = nn.KLDivLoss(reduce=False)
+
+    use_gpu = len(options.gpuid)>=1
+    autoencoder = AutoEncoder()
+
+    if(use_gpu):
+        autoencoder = autoencoder.cuda()
+    else:
+        autoencoder = autoencoder.cpu()
+
+    #autoencoder.load_state_dict(torch.load("./autoencoder_pretrained_model19"))
+
+    optimizer = torch.optim.Adam(autoencoder.parameters(), lr=options.learning_rate, weight_decay=options.weight_decay)
+    
+    last_train_loss = 1e-4
+    f = open("autoencoder_loss", 'a')
+    for epoch in range(options.epochs):
+        train_loss = 0.
+        print("At {0}-th epoch.".format(epoch))
+        for i, patches in enumerate(train_loader):
+            patch = patches['patch']
+            for b, batch in enumerate(patch):
+                batch = Variable(batch).cuda()
+                output, s_ = autoencoder(batch)
+                loss1 = mean_square_loss(output, batch)
+                s = Variable(torch.ones(s_.shape)*sparsity).cuda()
+                loss2 = (s*torch.log(s/(s_+1e-8)) + (1-s)*torch.log((1-s)/((1-s_+1e-8)))).sum()/options.batch_size
+                #kl_div_loss(mean_activitaion, sparsity)
+                loss = loss1 + beta * loss2
+                train_loss += loss
+                logging.info("batch {0} training loss is : {1:.5f}, {2:.5f}".format(i*1000+b, loss1.data[0], loss2.data[0]))
+                f.write("batch {0} training loss is : {1:.3f}\n".format(i*1000+b, loss.data[0]))
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+        train_avg_loss = train_loss/(len(train_loader)*1000)
+        print("Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch))
+        if (abs(train_avg_loss.data[0] - last_training_loss) <= options.estop) or ((epoch+1)%20==0):
+            torch.save(autoencoder.state_dict(), open("autoencoder_pretrained_model"+str(epoch), 'wb'))
+        last_train_loss = train_avg_loss.data[0]
+    f.close()
+if __name__ == "__main__":
+  ret = parser.parse_known_args()
+  options = ret[0]
+  if ret[1]:
+    logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+  main(options)

main_cnn_autoencoder.py

@@ -0,0 +1,218 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch import cuda
+from torch.autograd import Variable
+from torch.utils.data import DataLoader,Dataset
+
+import torchvision
+import torchvision.datasets as dset
+import torchvision.transforms as transforms
+import torchvision.utils
+from PIL import Image
+
+import torch.nn.functional as F
+
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+
+from custom_transform import CustomResize
+from custom_transform import CustomToTensor
+
+from AD_Standard_CNN_Dataset import AD_Standard_CNN_Dataset
+from cnn_3d_with_ae import CNN
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for CNN .")
+
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")  
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--weight_decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')         
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+parser.add_argument("--autoencoder", default=True, type=bool,
+                    help="Whether to use the parameters from pretrained autoencoder.")
+parser.add_argument("--num_classes", default=2, type=int,
+                    help="The number of classes, 2 or 3.")
+parser.add_argument("--estop", default=1e-5, type=float,
+                    help="Early stopping criteria on the development set. (default=1e-2)")  
+parser.add_argument("--noise", default=True, type=bool,
+                    help="Whether to add gaussian noise to scans.")
+# feel free to add more arguments as you need
+
+
+
+def main(options):
+    # Path configuration
+    if options.num_classes == 2:
+        TRAINING_PATH = 'train_2C_new.txt'
+        TESTING_PATH = 'validation_2C_new.txt'
+    else:
+        TRAINING_PATH = 'train.txt'
+        TESTING_PATH = 'test.txt'
+    IMG_PATH = './NewWhole'
+
+    trg_size = (121, 145, 121)
+    
+    # transformations = transforms.Compose([CustomResize("CNN", trg_size),
+    #                                       CustomToTensor("CNN")
+    #                                     ])
+
+    dset_train = AD_Standard_CNN_Dataset(IMG_PATH, TRAINING_PATH, noise=True)
+    dset_test = AD_Standard_CNN_Dataset(IMG_PATH, TESTING_PATH, noise=False)
+
+    # Use argument load to distinguish training and testing
+
+    train_loader = DataLoader(dset_train,
+                              batch_size = options.batch_size,
+                              shuffle = True,
+                              num_workers = 4,
+                              drop_last = True
+                              )
+
+    test_loader = DataLoader(dset_test,
+                             batch_size = options.batch_size,
+                             shuffle = False,
+                             num_workers = 4,
+                             drop_last=True
+                             )
+
+    use_cuda = (len(options.gpuid) >= 1)
+    # if options.gpuid:
+    #     cuda.set_device(options.gpuid[0])
+
+    # Training process
+    model = CNN(options.num_classes)
+
+    if use_cuda > 0:
+        model = model.cuda()
+    else:
+        model.cpu()
+
+    if options.autoencoder:
+        pretrained_ae = torch.load("./autoencoder_pretrained_model39")
+        model.state_dict()['conv1.weight'] = pretrained_ae['encoder.weight'].view(410,1,7,7,7)
+        model.state_dict()['conv1.bias'] = pretrained_ae['encoder.bias']
+
+        for p in model.conv1.parameters():
+            p.requires_grad = False
+
+    criterion = torch.nn.NLLLoss()
+
+    lr = options.learning_rate
+    optimizer = torch.optim.Adam(filter(lambda x: x.requires_grad, model.parameters()), lr, weight_decay=options.weight_decay)
+
+    # main training loop
+    last_dev_loss = 1e-4
+    max_acc = 0
+    max_epoch = 0
+    f1 = open("cnn_autoencoder_loss_train", 'a')
+    f2 = open("cnn_autoencoder_loss_dev", 'a')
+    for epoch_i in range(options.epochs):
+        logging.info("At {0}-th epoch.".format(epoch_i))
+        train_loss = 0.0
+        correct_cnt = 0.0
+        for it, train_data in enumerate(train_loader):
+            data_dic = train_data
+
+            if use_cuda:
+                imgs, labels = Variable(data_dic['image']).cuda(), Variable(data_dic['label']).cuda() 
+            else:
+                imgs, labels = Variable(data_dic['image']), Variable(data_dic['label'])
+
+            # add channel dimension: (batch_size, D, H ,W) to (batch_size, 1, D, H ,W)
+            # since 3D convolution requires 5D tensors
+            img_input = imgs#.unsqueeze(1)
+
+            integer_encoded = labels.data.cpu().numpy()
+            # target should be LongTensor in loss function
+            ground_truth = Variable(torch.from_numpy(integer_encoded)).long()
+            if use_cuda:
+                ground_truth = ground_truth.cuda()
+            train_output = model(img_input)
+            train_prob_predict = F.softmax(train_output, dim=1)
+            _, predict = train_prob_predict.topk(1)
+            loss = criterion(train_output, ground_truth)
+
+            train_loss += loss
+            correct_this_batch = (predict.squeeze(1) == ground_truth).sum().float()
+            correct_cnt += correct_this_batch
+            accuracy = float(correct_this_batch) / len(ground_truth)
+            logging.info("batch {0} training loss is : {1:.5f}".format(it, loss.data[0]))
+            logging.info("batch {0} training accuracy is : {1:.5f}".format(it, accuracy))
+            f1.write("batch {0} training loss is : {1:.5f}\n".format(it, loss.data[0]))
+            f1.write("batch {0} training accuracy is : {1:.5f}\n".format(it, loss.data[0]))
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        train_avg_loss = train_loss / (len(dset_train) / options.batch_size)
+        train_avg_acu = float(correct_cnt) / len(dset_train)
+        logging.info("Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch_i))
+        logging.info("Average training accuracy is {0:.5f} at the end of epoch {1}".format(train_avg_acu, epoch_i))
+        
+        # validation -- this is a crude esitmation because there might be some paddings at the end
+        dev_loss = 0.0
+        correct_cnt = 0.0
+        model.eval()
+        for it, test_data in enumerate(test_loader):
+            data_dic = test_data
+
+            if use_cuda:
+                imgs, labels = Variable(data_dic['image'], volatile=True).cuda(), Variable(data_dic['label'], volatile=True).cuda() 
+            else:
+                imgs, labels = Variable(data_dic['image'], volatile=True), Variable(data_dic['label'], volatile=True)
+
+            img_input = imgs#.unsqueeze(1)
+            integer_encoded = labels.data.cpu().numpy()
+            ground_truth = Variable(torch.from_numpy(integer_encoded), volatile=True).long()
+            if use_cuda:
+                ground_truth = ground_truth.cuda()
+            test_output = model(img_input)
+            test_prob_predict = F.softmax(test_output, dim=1)
+            _, predict = test_prob_predict.topk(1)
+            loss = criterion(test_output, ground_truth)
+            dev_loss += loss
+            correct_this_batch = (predict.squeeze(1) == ground_truth).sum().float()
+            correct_cnt += (predict.squeeze(1) == ground_truth).sum()
+            accuracy = float(correct_this_batch) / len(ground_truth)
+            logging.info("batch {0} dev loss is : {1:.5f}".format(it, loss.data[0]))
+            logging.info("batch {0} dev accuracy is : {1:.5f}".format(it, accuracy))
+            f2.write("batch {0} dev loss is : {1:.5f}\n".format(it, loss.data[0]))
+            f2.write("batch {0} dev accuracy is : {1:.5f}\n".format(it, accuracy))
+
+        dev_avg_loss = dev_loss / (len(dset_test) / options.batch_size)
+        dev_avg_acu = float(correct_cnt) / len(dset_test)
+        logging.info("Average validation loss is {0:.5f} at the end of epoch {1}".format(dev_avg_loss.data[0], epoch_i))
+        logging.info("Average validation accuracy is {0:.5f} at the end of epoch {1}".format(dev_avg_acu, epoch_i))
+
+        if dev_avg_acu > max_acc:
+            max_acc = dev_avg_acu
+            max_epoch = epoch_i
+
+        #if (abs(dev_avg_loss.data[0] - last_dev_loss) <= options.estop) or ((epoch_i+1)%20==0):
+        if max_acc>=0.75:
+            torch.save(model.state_dict(), open("3DCNN_model_" + str(epoch_i) + '_' + str(max_acc), 'wb'))
+        last_dev_loss = dev_avg_loss.data[0]
+        logging.info("Maximum accuracy on dev set is {0:.5f} for now".format(max_acc))
+    logging.info("Maximum accuracy on dev set is {0:.5f} at the end of epoch {1}".format(max_acc, max_epoch))
+    f1.close()
+    f2.close()
+
+if __name__ == "__main__":
+  ret = parser.parse_known_args()
+  options = ret[0]
+  if ret[1]:
+    logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+  main(options)

main_resnet.py

@@ -0,0 +1,241 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch import cuda
+from torch.autograd import Variable
+from torch.utils.data import DataLoader,Dataset
+
+import torchvision
+import torchvision.datasets as dset
+import torchvision.transforms as transforms
+import torchvision.utils
+from PIL import Image
+
+import torch.nn.functional as F
+
+import matplotlib.pyplot as plt
+import numpy as np
+import random
+
+from custom_transform import CustomResize
+from custom_transform import CustomToTensor
+
+from AD_Dataset import AD_Dataset
+from AD_2DSlicesData import AD_2DSlicesData
+
+from AlexNet2D import alexnet
+from AlexNet3D import AlexNet
+
+import ResNet2D
+import ResNet3D
+
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for JHU CS661 Computer Vision HW3.")
+
+parser.add_argument("--network_type", "--nt", default="AlexNet2D", choices=["AlexNet2D", "AlexNet3D", "ResNet2D", "ResNet3D"],
+                    help="Deep network type. (default=AlexNet)")
+parser.add_argument("--load",
+                    help="Load saved network weights.")
+parser.add_argument("--save", default="best_model",
+                    help="Save network weights.")  
+parser.add_argument("--augmentation", default=True, type=bool,
+                    help="Save network weights.")
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")  
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                    help='momentum')
+parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')
+parser.add_argument("--estop", default=1e-2, type=float,
+                    help="Early stopping criteria on the development set. (default=1e-2)")               
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--optimizer", default="Adam", choices=["SGD", "Adadelta", "Adam"],
+                    help="Optimizer of choice for training. (default=Adam)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+# feel free to add more arguments as you need
+
+
+
+def main(options):
+    # Path configuration
+    TRAINING_PATH = 'train.txt'
+    TESTING_PATH = 'test.txt'
+    IMG_PATH = './Image'
+
+    if options.network_type == 'AlexNet3D':
+        trg_size = (224, 224, 224)
+    elif options.network_type == 'AlexNet2D':
+        trg_size = (224, 224)
+    elif options.network_type == 'ResNet3D':
+        trg_size = (110, 110, 110)
+    elif options.network_type == 'ResNet2D':
+        trg_size = (224, 224)
+    
+    if options.network_type == "AlexNet3D" or "ResNet3D":
+        transformations = transforms.Compose([CustomResize(options.network_type, trg_size),
+                                              CustomToTensor(options.network_type)
+                                        ])
+        dset_train = AD_2DSlicesData(IMG_PATH, TRAINING_PATH, transformations)
+        dset_test = AD_2DSlicesData(IMG_PATH, TESTING_PATH, transformations)
+
+    elif options.network_type == 'AlexNet2D' or "ResNet2D":
+        transformations = transforms.Compose([transforms.Resize(trg_size, Image.BICUBIC),
+                                              transforms.RandomHorizontalFlip(),
+                                              transforms.ToTensor()
+                                              ])
+        dset_train = AD_2DSlicesData(IMG_PATH, TRAINING_PATH, transformations)
+        dset_test = AD_2DSlicesData(IMG_PATH, TESTING_PATH, transformations)
+
+    # Use argument load to distinguish training and testing
+    if options.load is None:
+        train_loader = DataLoader(dset_train,
+                                  batch_size = options.batch_size,
+                                  shuffle = True,
+                                  num_workers = 4,
+                                  drop_last = True
+                                 )
+    else:
+        # Only shuffle the data when doing training
+        train_loader = DataLoader(dset_train,
+                                  batch_size=options.batch_size,
+                                  shuffle=False,
+                                  num_workers=4,
+                                  drop_last=True
+                                  )
+
+    test_loader = DataLoader(dset_test,
+                             batch_size = options.batch_size,
+                             shuffle = False,
+                             num_workers = 4,
+                             drop_last=True
+                             )
+
+    use_cuda = (len(options.gpuid) >= 1)
+    # if options.gpuid:
+    #     cuda.set_device(options.gpuid[0])
+
+    # Training process
+    if options.load is None:
+        # Initial the model
+        if options.network_type == 'AlexNet3D':
+            model = AlexNet()
+        elif options.network_type == 'AlexNet2D':
+            model = alexnet(pretrained=True)
+        elif options.network_type == 'ResNet2D':
+            model = ResNet2D.resnet152(pretrained=True)
+        elif options.network_type == 'ResNet3D':
+            model = ResNet3D.ResNet()
+
+        if use_cuda > 0:
+            model = nn.DataParallel(model, device_ids=options.gpuid).cuda()
+        else:
+            model.cpu()
+
+        # Binary cross-entropy loss
+        criterion = torch.nn.CrossEntropyLoss()
+
+        lr = options.learning_rate
+        optimizer = eval("torch.optim." + options.optimizer)(model.parameters(), lr,
+                                                             #momentum=options.momentum,
+                                                             weight_decay=options.weight_decay)
+        # Prepare for label encoding
+        last_dev_avg_loss = float("inf")
+        best_accuracy = float("-inf")
+
+        # main training loop
+        for epoch_i in range(options.epochs):
+            logging.info("At {0}-th epoch.".format(epoch_i))
+            train_loss = 0.0
+            correct_cnt = 0.0
+            model.train()
+            for it, train_data in enumerate(train_loader):
+                data_dic = train_data
+
+                if use_cuda:
+                    imgs, labels = Variable(data_dic['image']).cuda(), Variable(data_dic['label']).cuda() 
+                else:
+                    imgs, labels = Variable(data_dic['image']), Variable(data_dic['label'])
+
+                # add channel dimension: (batch_size, D, H ,W) to (batch_size, 1, D, H ,W)
+                # since 3D convolution requires 5D tensors
+                img_input = imgs#.unsqueeze(1)
+
+                integer_encoded = labels.data.cpu().numpy()
+                # target should be LongTensor in loss function
+                ground_truth = Variable(torch.from_numpy(integer_encoded)).long()
+                if use_cuda:
+                    ground_truth = ground_truth.cuda()
+                train_output = model(img_input)
+                train_prob_predict = F.softmax(train_output, dim=1)
+                _, predict = train_prob_predict.topk(1)
+                loss = criterion(train_output, ground_truth)
+
+                train_loss += loss
+                correct_this_batch = (predict.squeeze(1) == ground_truth).sum()
+                correct_cnt += correct_this_batch
+                accuracy = float(correct_this_batch) / len(ground_truth)
+                logging.info("batch {0} training loss is : {1:.5f}".format(it, loss.data[0]))
+                logging.info("batch {0} training accuracy is : {1:.5f}".format(it, accuracy))
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+
+            train_avg_loss = train_loss / (len(dset_train) / options.batch_size)
+            train_avg_acu = float(correct_cnt) / len(dset_train)
+            logging.info("Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch_i))
+            logging.info("Average training accuracy is {0:.5f} at the end of epoch {1}".format(train_avg_acu, epoch_i))
+            
+            # validation -- this is a crude esitmation because there might be some paddings at the end
+            dev_loss = 0.0
+            correct_cnt = 0.0
+            model.eval()
+            for it, test_data in enumerate(test_loader):
+                data_dic = test_data
+
+                if use_cuda:
+                    imgs, labels = Variable(data_dic['image'], volatile=True).cuda(), Variable(data_dic['label'], volatile=True).cuda() 
+                else:
+                    imgs, labels = Variable(data_dic['image'], volatile=True), Variable(data_dic['label'], volatile=True)
+
+                img_input = imgs#.unsqueeze(1)
+                integer_encoded = labels.data.cpu().numpy()
+                ground_truth = Variable(torch.from_numpy(integer_encoded), volatile=True).long()
+                if use_cuda:
+                    ground_truth = ground_truth.cuda()
+                test_output = model(img_input)
+                test_prob_predict = F.softmax(test_output, dim=1)
+                _, predict = test_prob_predict.topk(1)
+                loss = criterion(test_output, ground_truth)
+                dev_loss += loss
+                correct_this_batch = (predict.squeeze(1) == ground_truth).sum()
+                correct_cnt += (predict.squeeze(1) == ground_truth).sum()
+                accuracy = float(correct_this_batch) / len(ground_truth)
+                logging.info("batch {0} dev loss is : {1:.5f}".format(it, loss.data[0]))
+                logging.info("batch {0} dev accuracy is : {1:.5f}".format(it, accuracy))
+
+            dev_avg_loss = dev_loss / (len(dset_test) / options.batch_size)
+            dev_avg_acu = float(correct_cnt) / len(dset_test)
+            logging.info("Average validation loss is {0:.5f} at the end of epoch {1}".format(dev_avg_loss.data[0], epoch_i))
+            logging.info("Average validation accuracy is {0:.5f} at the end of epoch {1}".format(dev_avg_acu, epoch_i))
+
+            torch.save(model.state_dict(), open(options.save + ".nll_{0:.3f}.epoch_{1}".format(dev_avg_loss.data[0], epoch_i), 'wb'))
+
+            last_dev_avg_loss = dev_avg_loss
+
+
+if __name__ == "__main__":
+  ret = parser.parse_known_args()
+  options = ret[0]
+  if ret[1]:
+    logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+  main(options)

test.py

@@ -0,0 +1,91 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+from torch.utils.data import DataLoader,Dataset
+import torchvision
+
+from autoencoder import AutoEncoder 
+from AD_3DRandomPatch import AD_3DRandomPatch
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for AutoEncoder")
+
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                    help='momentum')
+parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+parser.add_argument("--num_classes", default=2, type=int,
+                    help="Number of classes.")
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")  
+
+def main(options):
+
+    if options.num_classes == 2:
+        TRAINING_PATH = 'train_2classes.txt'
+    else:
+        TRAINING_PATH = 'train.txt'
+    IMG_PATH = '/Users/waz/JHU/CV-ADNI/ImageNoSkull'
+
+    dset_train = AD_3DRandomPatch(IMG_PATH, TRAINING_PATH)
+
+    train_loader = DataLoader(dset_train,
+                              batch_size = options.batch_size,
+                              shuffle = True,
+                              num_workers = 4,
+                              drop_last = True
+                              )
+
+    sparsity = 0.05
+    beta = 0.5
+
+    mean_square_loss = nn.MSELoss()
+    kl_div_loss = nn.KLDivLoss()
+
+    use_gpu = len(options.gpuid)>=1
+    autoencoder = AutoEncoder()
+
+
+    autoencoder = autoencoder.cpu()
+
+    optimizer = torch.optim.Adam(autoencoder.parameters(), lr=options.learning_rate, weight_decay=options.weight_decay)
+
+    train_loss = 0.
+    for epoch in range(options.epochs):
+        print("At {0}-th epoch.".format(epoch))
+        for i, patches in enumerate(train_loader):
+            for b, batch in enumerate(patches):
+                batch = Variable(batch) 
+                output, mean_activitaion = autoencoder(batch)
+                loss1 = mean_square_loss(output, batch)
+                loss2 = kl_div_loss(mean_activitaion, Variable(torch.Tensor([sparsity])))
+                print "loss1", loss1
+                print "loss2", loss2
+                loss = loss1 + loss2
+                train_loss += loss
+                logging.info("batch {0} training loss is : {1:.5f}, {1:.5f}".format(b, loss1.data[0], loss2.data[0]))
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+        train_avg_loss = train_loss/len(train_loader*1000)
+        print("Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch))
+    torch.save(model.state_dict(), open("autoencoder_model", 'wb'))
+
+if __name__ == "__main__":
+  ret = parser.parse_known_args()
+  options = ret[0]
+  if ret[1]:
+    logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+  main(options)

test.txt

@@ -0,0 +1,198 @@
+128_S_1409.nii AD
+116_S_0834.nii MCI
+109_S_0967.nii Normal
+009_S_1354.nii AD
+032_S_0479.nii Normal
+133_S_0792.nii MCI
+126_S_0680.nii Normal
+137_S_0301.nii Normal
+073_S_1207.nii AD
+010_S_0067.nii Normal
+018_S_0155.nii MCI
+130_S_0783.nii MCI
+126_S_0891.nii AD
+007_S_0041.nii MCI
+036_S_0976.nii MCI
+018_S_0450.nii MCI
+082_S_0641.nii MCI
+094_S_0711.nii Normal
+021_S_0231.nii MCI
+002_S_0816.nii AD
+128_S_0863.nii Normal
+068_S_0476.nii MCI
+128_S_0230.nii Normal
+062_S_1091.nii MCI
+094_S_1015.nii MCI
+005_S_1341.nii AD
+012_S_1292.nii MCI
+032_S_0095.nii Normal
+141_S_1244.nii MCI
+126_S_0865.nii MCI
+033_S_0513.nii MCI
+012_S_1133.nii Normal
+133_S_0488.nii Normal
+109_S_1343.nii MCI
+013_S_0699.nii AD
+114_S_0979.nii AD
+082_S_1079.nii AD
+133_S_0913.nii MCI
+136_S_0300.nii AD
+027_S_1082.nii AD
+114_S_0374.nii AD
+094_S_1027.nii AD
+109_S_1013.nii Normal
+027_S_0403.nii Normal
+132_S_0987.nii MCI
+100_S_0015.nii Normal
+036_S_1135.nii MCI
+002_S_1018.nii AD
+109_S_1157.nii AD
+099_S_0958.nii MCI
+094_S_1090.nii AD
+127_S_0684.nii Normal
+027_S_0118.nii Normal
+057_S_1217.nii MCI
+082_S_0761.nii Normal
+141_S_0810.nii Normal
+100_S_0747.nii AD
+010_S_0786.nii AD
+099_S_0054.nii MCI
+133_S_0771.nii MCI
+128_S_0701.nii AD
+133_S_0912.nii MCI
+098_S_0896.nii Normal
+023_S_0083.nii AD
+131_S_0441.nii Normal
+033_S_0889.nii AD
+031_S_0568.nii MCI
+128_S_0272.nii Normal
+016_S_1263.nii AD
+114_S_0601.nii Normal
+130_S_0886.nii Normal
+006_S_0547.nii AD
+041_S_0898.nii Normal
+027_S_1277.nii MCI
+033_S_0739.nii AD
+131_S_1301.nii Normal
+099_S_0111.nii MCI
+029_S_0824.nii Normal
+141_S_1024.nii AD
+022_S_0044.nii MCI
+027_S_0417.nii MCI
+022_S_0543.nii AD
+137_S_0796.nii AD
+094_S_1188.nii MCI
+114_S_0173.nii Normal
+052_S_1054.nii MCI
+131_S_0436.nii Normal
+062_S_1294.nii MCI
+126_S_0405.nii Normal
+041_S_0282.nii MCI
+099_S_0880.nii MCI
+032_S_0400.nii AD
+021_S_0753.nii AD
+033_S_0734.nii Normal
+136_S_0196.nii Normal
+031_S_0773.nii AD
+002_S_0955.nii AD
+021_S_0984.nii Normal
+033_S_0724.nii AD
+013_S_1035.nii Normal
+094_S_1397.nii AD
+082_S_0469.nii MCI
+109_S_0840.nii Normal
+011_S_0856.nii MCI
+012_S_1212.nii Normal
+033_S_1098.nii Normal
+941_S_1194.nii Normal
+009_S_0842.nii Normal
+136_S_0086.nii Normal
+027_S_1387.nii MCI
+126_S_1221.nii AD
+082_S_0363.nii Normal
+067_S_0045.nii MCI
+098_S_0172.nii Normal
+072_S_1211.nii MCI
+109_S_0876.nii Normal
+141_S_0851.nii MCI
+011_S_0053.nii AD
+073_S_0565.nii AD
+029_S_0878.nii MCI
+023_S_0061.nii Normal
+027_S_1385.nii AD
+100_S_0743.nii AD
+067_S_0336.nii MCI
+013_S_0996.nii AD
+099_S_0090.nii Normal
+099_S_0060.nii MCI
+099_S_0470.nii AD
+023_S_0030.nii MCI
+057_S_0643.nii Normal
+033_S_1086.nii Normal
+100_S_0190.nii MCI
+006_S_0731.nii Normal
+100_S_0069.nii Normal
+141_S_0852.nii AD
+130_S_1200.nii Normal
+062_S_1299.nii MCI
+067_S_0243.nii MCI
+007_S_0070.nii Normal
+012_S_1033.nii MCI
+027_S_0120.nii Normal
+032_S_0718.nii MCI
+094_S_1241.nii Normal
+053_S_0389.nii MCI
+067_S_0176.nii MCI
+123_S_0091.nii AD
+003_S_1059.nii AD
+123_S_0094.nii AD
+100_S_1113.nii AD
+020_S_0899.nii Normal
+136_S_0195.nii MCI
+057_S_0779.nii Normal
+131_S_0123.nii Normal
+116_S_0392.nii AD
+010_S_0419.nii Normal
+012_S_1321.nii MCI
+116_S_0890.nii MCI
+023_S_0604.nii MCI
+094_S_0531.nii MCI
+126_S_0506.nii Normal
+130_S_0969.nii Normal
+023_S_1190.nii Normal
+114_S_0410.nii MCI
+007_S_0414.nii MCI
+052_S_0951.nii Normal
+141_S_0340.nii AD
+128_S_0805.nii AD
+023_S_1104.nii MCI
+024_S_1400.nii MCI
+073_S_0445.nii MCI
+012_S_0712.nii AD
+128_S_0608.nii MCI
+018_S_0406.nii MCI
+129_S_0778.nii Normal
+100_S_1154.nii MCI
+031_S_0554.nii AD
+137_S_0841.nii AD
+018_S_0633.nii AD
+033_S_1285.nii AD
+099_S_1144.nii AD
+010_S_0829.nii AD
+006_S_0521.nii MCI
+033_S_1016.nii Normal
+141_S_1051.nii MCI
+114_S_0458.nii MCI
+128_S_0545.nii Normal
+094_S_0964.nii MCI
+022_S_0544.nii MCI
+941_S_1363.nii MCI
+037_S_0627.nii AD
+130_S_1201.nii AD
+057_S_1007.nii MCI
+022_S_0219.nii AD
+016_S_0354.nii MCI
+002_S_0938.nii AD
+014_S_0356.nii AD
+082_S_0640.nii Normal
+130_S_1337.nii AD

test_2C_new.txt

@@ -0,0 +1,66 @@
+131_S_1301.nii Normal
+109_S_4499.nii Normal
+128_S_0701.nii AD
+016_S_4583.nii AD
+073_S_5016.nii AD
+070_S_4856.nii Normal
+023_S_0061.nii Normal
+109_S_0967.nii Normal
+036_S_5210.nii AD
+126_S_0680.nii Normal
+070_S_4719.nii AD
+128_S_0230.nii Normal
+016_S_5032.nii AD
+109_S_1157.nii AD
+009_S_0842.nii Normal
+128_S_0272.nii Normal
+032_S_4755.nii AD
+128_S_1409.nii AD
+114_S_0374.nii AD
+027_S_4801.nii AD
+116_S_4453.nii Normal
+123_S_0094.nii AD
+022_S_0543.nii AD
+082_S_4224.nii Normal
+082_S_4428.nii Normal
+128_S_4609.nii Normal
+100_S_0747.nii AD
+033_S_1086.nii Normal
+012_S_1212.nii Normal
+011_S_4912.nii AD
+130_S_1200.nii Normal
+011_S_4222.nii Normal
+051_S_5005.nii AD
+099_S_4124.nii AD
+099_S_0090.nii Normal
+021_S_4276.nii Normal
+137_S_4482.nii Normal
+027_S_4938.nii AD
+023_S_5241.nii AD
+027_S_0120.nii Normal
+016_S_4688.nii Normal
+014_S_4080.nii Normal
+082_S_0761.nii Normal
+021_S_0753.nii AD
+129_S_4369.nii Normal
+016_S_4121.nii Normal
+153_S_4125.nii Normal
+098_S_0172.nii Normal
+037_S_4410.nii Normal
+057_S_0779.nii Normal
+032_S_0095.nii Normal
+033_S_0724.nii AD
+114_S_0601.nii Normal
+013_S_0699.nii AD
+137_S_0796.nii AD
+082_S_4208.nii Normal
+099_S_0470.nii AD
+023_S_4020.nii Normal
+006_S_0731.nii Normal
+094_S_0711.nii Normal
+128_S_0863.nii Normal
+006_S_0547.nii AD
+021_S_4335.nii Normal
+005_S_1341.nii AD
+033_S_0734.nii Normal
+003_S_1059.nii AD

test_2classes.txt

@@ -0,0 +1,100 @@
+128_S_1409.nii AD
+109_S_0967.nii Normal
+009_S_1354.nii AD
+032_S_0479.nii Normal
+126_S_0680.nii Normal
+137_S_0301.nii Normal
+073_S_1207.nii AD
+010_S_0067.nii Normal
+126_S_0891.nii AD
+094_S_0711.nii Normal
+002_S_0816.nii AD
+128_S_0863.nii Normal
+128_S_0230.nii Normal
+005_S_1341.nii AD
+032_S_0095.nii Normal
+012_S_1133.nii Normal
+133_S_0488.nii Normal
+013_S_0699.nii AD
+114_S_0979.nii AD
+082_S_1079.nii AD
+136_S_0300.nii AD
+027_S_1082.nii AD
+114_S_0374.nii AD
+094_S_1027.nii AD
+109_S_1013.nii Normal
+027_S_0403.nii Normal
+100_S_0015.nii Normal
+002_S_1018.nii AD
+109_S_1157.nii AD
+094_S_1090.nii AD
+127_S_0684.nii Normal
+027_S_0118.nii Normal
+082_S_0761.nii Normal
+141_S_0810.nii Normal
+100_S_0747.nii AD
+010_S_0786.nii AD
+128_S_0701.nii AD
+098_S_0896.nii Normal
+023_S_0083.nii AD
+131_S_0441.nii Normal
+033_S_0889.nii AD
+128_S_0272.nii Normal
+016_S_1263.nii AD
+114_S_0601.nii Normal
+130_S_0886.nii Normal
+006_S_0547.nii AD
+041_S_0898.nii Normal
+033_S_0739.nii AD
+131_S_1301.nii Normal
+029_S_0824.nii Normal
+141_S_1024.nii AD
+022_S_0543.nii AD
+137_S_0796.nii AD
+114_S_0173.nii Normal
+131_S_0436.nii Normal
+126_S_0405.nii Normal
+032_S_0400.nii AD
+021_S_0753.nii AD
+033_S_0734.nii Normal
+136_S_0196.nii Normal
+031_S_0773.nii AD
+002_S_0955.nii AD
+021_S_0984.nii Normal
+033_S_0724.nii AD
+013_S_1035.nii Normal
+094_S_1397.nii AD
+109_S_0840.nii Normal
+012_S_1212.nii Normal
+033_S_1098.nii Normal
+941_S_1194.nii Normal
+009_S_0842.nii Normal
+136_S_0086.nii Normal
+126_S_1221.nii AD
+082_S_0363.nii Normal
+098_S_0172.nii Normal
+109_S_0876.nii Normal
+011_S_0053.nii AD
+073_S_0565.nii AD
+023_S_0061.nii Normal
+027_S_1385.nii AD
+100_S_0743.nii AD
+013_S_0996.nii AD
+099_S_0090.nii Normal
+099_S_0470.nii AD
+057_S_0643.nii Normal
+033_S_1086.nii Normal
+006_S_0731.nii Normal
+100_S_0069.nii Normal
+141_S_0852.nii AD
+130_S_1200.nii Normal
+007_S_0070.nii Normal
+027_S_0120.nii Normal
+094_S_1241.nii Normal
+123_S_0091.nii AD
+003_S_1059.nii AD
+123_S_0094.nii AD
+100_S_1113.nii AD
+020_S_0899.nii Normal
+057_S_0779.nii Normal
+131_S_0123.nii Normal

test_encoder.py

@@ -0,0 +1,92 @@
+import argparse
+import logging
+
+import torch
+import torch.nn as nn
+from torch import cuda
+from torch.autograd import Variable
+from torch.utils.data import DataLoader,Dataset
+import torchvision
+
+from autoencoder import AutoEncoder 
+from AD_3DRandomPatch import AD_3DRandomPatch
+
+logging.basicConfig(
+    format='%(asctime)s %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO)
+
+parser = argparse.ArgumentParser(description="Starter code for AutoEncoder")
+
+parser.add_argument("--learning_rate", "-lr", default=1e-3, type=float,
+                    help="Learning rate of the optimization. (default=0.01)")
+parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
+                    help='momentum')
+parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
+                    metavar='W', help='weight decay (default: 1e-4)')
+parser.add_argument("--batch_size", default=1, type=int,
+                    help="Batch size for training. (default=1)")
+parser.add_argument("--gpuid", default=[0], nargs='+', type=int,
+                    help="ID of gpu device to use. Empty implies cpu usage.")
+parser.add_argument("--num_classes", default=2, type=int,
+                    help="Number of classes.")
+parser.add_argument("--epochs", default=20, type=int,
+                    help="Epochs through the data. (default=20)")  
+
+def main(options):
+
+    if options.num_classes == 2:
+        TRAINING_PATH = 'train_2classes.txt'
+    else:
+        TRAINING_PATH = 'train.txt'
+    IMG_PATH = './Image'
+
+    dset_train = AD_3DRandomPatch(IMG_PATH, TRAINING_PATH)
+
+    train_loader = DataLoader(dset_train,
+                              batch_size = options.batch_size,
+                              shuffle = True,
+                              num_workers = 4,
+                              drop_last = True
+                              )
+
+    sparsity = 0.05
+    beta = 0.5
+
+    mean_square_loss = nn.MSELoss()
+    kl_div_loss = nn.KLDivLoss(reduce=False)
+
+    use_gpu = len(options.gpuid)>=1
+    autoencoder = AutoEncoder()
+
+    if(use_gpu):
+        autoencoder = autoencoder.cuda()
+    else:
+        autoencoder = autoencoder.cpu()
+
+    optimizer = torch.optim.Adam(autoencoder.parameters(), lr=options.learning_rate, weight_decay=options.weight_decay)
+
+    train_loss = 0.
+    for epoch in range(options.epochs):
+        print("At {0}-th epoch.".format(epoch))
+        for i, patches in enumerate(train_loader):
+            print i
+            print len(patches)
+            # for batch in patches:
+            #     batch = Variable(batch).cuda()
+            #     output, mean_activitaion = autoencoder(batch)
+            #     loss = mean_square_loss(batch, output) + kl_div_loss(mean_activitaion, sparsity)
+            #     train_loss += loss
+            #     logging.info("batch {0} training loss is : {1:.5f}".format(i, loss.data[0]))
+            #     optimizer.zero_grad()
+            #     loss.backward()
+            #     optimizer.step()
+    #     train_avg_loss = train_loss/len(train_loader*1000)
+    #     print("Average training loss is {0:.5f} at the end of epoch {1}".format(train_avg_loss.data[0], epoch))
+    # torch.save(model.state_dict(), open("autoencoder_model", 'wb'))
+
+if __name__ == "__main__":
+  ret = parser.parse_known_args()
+  options = ret[0]
+  if ret[1]:
+    logging.warning("unknown arguments: {0}".format(parser.parse_known_args()[1]))
+  main(options)

train.txt

@@ -0,0 +1,486 @@
+011_S_0005.nii Normal
+022_S_0014.nii Normal
+016_S_0769.nii MCI
+127_S_1382.nii AD
+033_S_0725.nii MCI
+067_S_0098.nii MCI
+023_S_1262.nii AD
+068_S_0210.nii Normal
+137_S_0158.nii MCI
+067_S_0110.nii AD
+133_S_0629.nii MCI
+116_S_0657.nii Normal
+123_S_0113.nii Normal
+094_S_1102.nii AD
+137_S_0825.nii MCI
+003_S_0981.nii Normal
+114_S_0228.nii AD
+057_S_0839.nii MCI
+941_S_1197.nii Normal
+022_S_0066.nii Normal
+024_S_1063.nii Normal
+137_S_1041.nii AD
+067_S_1185.nii AD
+035_S_0555.nii Normal
+068_S_1191.nii Normal
+116_S_0360.nii Normal
+010_S_0662.nii MCI
+033_S_1281.nii AD
+023_S_0613.nii MCI
+099_S_0352.nii Normal
+032_S_0677.nii Normal
+094_S_0692.nii Normal
+011_S_0002.nii Normal
+126_S_0606.nii AD
+141_S_0696.nii AD
+131_S_0691.nii AD
+023_S_0084.nii AD
+136_S_0299.nii AD
+023_S_0093.nii AD
+012_S_1009.nii Normal
+127_S_0397.nii MCI
+141_S_0717.nii Normal
+941_S_1203.nii Normal
+137_S_0481.nii MCI
+057_S_1373.nii AD
+016_S_0991.nii AD
+128_S_0167.nii AD
+027_S_0179.nii MCI
+094_S_0489.nii Normal
+127_S_0622.nii Normal
+029_S_1073.nii MCI
+116_S_1083.nii AD
+032_S_0147.nii AD
+027_S_0948.nii MCI
+037_S_1421.nii MCI
+073_S_0518.nii MCI
+018_S_0425.nii Normal
+128_S_0740.nii AD
+031_S_0618.nii Normal
+068_S_0109.nii AD
+141_S_0853.nii AD
+011_S_0861.nii MCI
+057_S_0464.nii MCI
+073_S_0089.nii Normal
+137_S_0459.nii Normal
+067_S_0056.nii Normal
+014_S_0357.nii AD
+036_S_0656.nii MCI
+098_S_0884.nii AD
+033_S_0516.nii Normal
+024_S_0985.nii Normal
+128_S_0310.nii AD
+024_S_1171.nii AD
+141_S_0767.nii Normal
+100_S_1286.nii Normal
+012_S_0637.nii Normal
+013_S_1120.nii MCI
+131_S_0409.nii MCI
+133_S_0525.nii Normal
+133_S_1170.nii AD
+033_S_0511.nii MCI
+041_S_1002.nii Normal
+082_S_0928.nii MCI
+128_S_1181.nii MCI
+014_S_0328.nii AD
+018_S_0369.nii Normal
+029_S_1384.nii MCI
+029_S_1056.nii AD
+033_S_1087.nii AD
+073_S_0386.nii Normal
+051_S_1040.nii MCI
+099_S_0551.nii MCI
+041_S_0446.nii MCI
+067_S_0284.nii MCI
+007_S_1222.nii Normal
+024_S_1307.nii AD
+032_S_1101.nii AD
+109_S_0950.nii MCI
+136_S_0579.nii MCI
+041_S_0314.nii MCI
+013_S_0240.nii MCI
+116_S_0487.nii AD
+067_S_0077.nii MCI
+137_S_0972.nii Normal
+051_S_1131.nii MCI
+057_S_1379.nii AD
+011_S_0008.nii Normal
+041_S_1010.nii MCI
+123_S_0390.nii MCI
+018_S_0087.nii MCI
+012_S_0803.nii AD
+022_S_0924.nii MCI
+013_S_0575.nii Normal
+033_S_1309.nii MCI
+136_S_0186.nii Normal
+035_S_0033.nii MCI
+137_S_0669.nii MCI
+073_S_1357.nii MCI
+100_S_0995.nii MCI
+137_S_0443.nii MCI
+016_S_1138.nii MCI
+014_S_0548.nii Normal
+037_S_0467.nii Normal
+011_S_0326.nii MCI
+021_S_0647.nii Normal
+127_S_0431.nii AD
+014_S_0519.nii Normal
+041_S_1391.nii AD
+029_S_0866.nii Normal
+033_S_1284.nii MCI
+033_S_1283.nii AD
+029_S_1184.nii AD
+037_S_1225.nii MCI
+033_S_0567.nii MCI
+094_S_1164.nii AD
+053_S_0621.nii MCI
+020_S_0213.nii AD
+021_S_1109.nii AD
+005_S_0221.nii AD
+022_S_0750.nii MCI
+114_S_0416.nii Normal
+006_S_0653.nii AD
+041_S_1420.nii MCI
+005_S_0222.nii MCI
+005_S_0929.nii AD
+036_S_0672.nii Normal
+082_S_1256.nii Normal
+053_S_0507.nii MCI
+022_S_0130.nii Normal
+012_S_1175.nii MCI
+109_S_1183.nii MCI
+141_S_1231.nii MCI
+128_S_1430.nii AD
+141_S_0982.nii MCI
+005_S_0814.nii AD
+012_S_0720.nii AD
+007_S_0128.nii MCI
+016_S_0359.nii Normal
+022_S_1366.nii MCI
+013_S_0325.nii MCI
+029_S_1038.nii MCI
+121_S_1322.nii MCI
+100_S_0006.nii MCI
+029_S_0871.nii MCI
+021_S_0642.nii AD
+137_S_1426.nii MCI
+057_S_0818.nii Normal
+073_S_0909.nii MCI
+137_S_0631.nii MCI
+023_S_0078.nii MCI
+116_S_1315.nii MCI
+012_S_0932.nii MCI
+062_S_0730.nii AD
+068_S_0473.nii Normal
+136_S_0184.nii Normal
+035_S_0341.nii AD
+133_S_0727.nii MCI
+100_S_1062.nii AD
+123_S_0298.nii Normal
+022_S_0096.nii Normal
+067_S_0177.nii Normal
+130_S_0102.nii MCI
+109_S_0777.nii AD
+941_S_1311.nii MCI
+041_S_0407.nii MCI
+127_S_1140.nii MCI
+006_S_0675.nii MCI
+035_S_0156.nii Normal
+014_S_0520.nii Normal
+016_S_1028.nii MCI
+018_S_0103.nii MCI
+128_S_0517.nii AD
+011_S_0016.nii Normal
+141_S_1094.nii Normal
+136_S_0426.nii AD
+021_S_0273.nii MCI
+067_S_0038.nii MCI
+068_S_0442.nii MCI
+128_S_0266.nii AD
+941_S_1295.nii MCI
+127_S_0393.nii MCI
+057_S_0934.nii Normal
+035_S_0048.nii Normal
+051_S_1338.nii MCI
+023_S_0081.nii Normal
+136_S_0874.nii MCI
+002_S_0685.nii Normal
+116_S_1232.nii Normal
+041_S_0598.nii MCI
+131_S_0457.nii AD
+011_S_0362.nii MCI
+062_S_0793.nii AD
+027_S_0074.nii Normal
+133_S_0493.nii Normal
+057_S_0474.nii AD
+136_S_0194.nii AD
+131_S_0497.nii AD
+010_S_0904.nii MCI
+062_S_0690.nii AD
+023_S_0926.nii Normal
+023_S_0855.nii MCI
+011_S_0023.nii Normal
+062_S_0768.nii Normal
+941_S_1202.nii Normal
+128_S_0611.nii MCI
+005_S_0602.nii Normal
+032_S_1169.nii Normal
+137_S_0686.nii Normal
+023_S_1247.nii MCI
+053_S_1044.nii AD
+005_S_0610.nii Normal
+031_S_0821.nii MCI
+013_S_0860.nii MCI
+128_S_0522.nii Normal
+941_S_1195.nii Normal
+016_S_1149.nii MCI
+005_S_1224.nii MCI
+032_S_1037.nii AD
+067_S_0607.nii MCI
+007_S_1339.nii AD
+123_S_0162.nii AD
+029_S_0845.nii Normal
+012_S_1165.nii MCI
+136_S_1227.nii MCI
+036_S_0577.nii AD
+003_S_0907.nii Normal
+033_S_0741.nii Normal
+018_S_0057.nii MCI
+099_S_0534.nii Normal
+035_S_0204.nii MCI
+073_S_0311.nii Normal
+082_S_0304.nii Normal
+027_S_1254.nii AD
+011_S_0022.nii Normal
+003_S_0931.nii Normal
+136_S_0873.nii MCI
+020_S_0883.nii Normal
+016_S_0590.nii MCI
+021_S_0141.nii MCI
+052_S_1250.nii Normal
+100_S_0035.nii Normal
+002_S_0954.nii MCI
+033_S_0888.nii AD
+010_S_0420.nii Normal
+127_S_0754.nii AD
+099_S_0492.nii AD
+013_S_0592.nii AD
+027_S_1081.nii AD
+007_S_0249.nii MCI
+128_S_0188.nii MCI
+041_S_0721.nii MCI
+116_S_0382.nii Normal
+009_S_1334.nii AD
+033_S_0723.nii MCI
+123_S_0106.nii Normal
+099_S_0533.nii Normal
+011_S_0021.nii Normal
+094_S_0921.nii MCI
+018_S_0286.nii AD
+067_S_0076.nii AD
+029_S_0836.nii AD
+067_S_0059.nii Normal
+121_S_1350.nii MCI
+127_S_0394.nii MCI
+037_S_0454.nii Normal
+067_S_0020.nii AD
+130_S_1290.nii AD
+041_S_1412.nii MCI
+094_S_1402.nii AD
+002_S_0619.nii AD
+067_S_0257.nii Normal
+072_S_0315.nii Normal
+036_S_0748.nii MCI
+036_S_0576.nii Normal
+018_S_0682.nii AD
+027_S_1213.nii MCI
+033_S_1308.nii AD
+021_S_0332.nii MCI
+100_S_0893.nii AD
+068_S_0127.nii Normal
+114_S_0166.nii Normal
+041_S_0125.nii Normal
+068_S_0401.nii MCI
+141_S_1137.nii AD
+094_S_1398.nii MCI
+082_S_1119.nii MCI
+067_S_0029.nii AD
+141_S_1245.nii MCI
+033_S_0733.nii AD
+041_S_1411.nii MCI
+012_S_0689.nii AD
+098_S_0149.nii AD
+013_S_1161.nii AD
+029_S_1215.nii MCI
+013_S_1275.nii MCI
+098_S_0171.nii Normal
+141_S_0726.nii Normal
+128_S_0500.nii Normal
+128_S_0216.nii AD
+007_S_1248.nii AD
+021_S_0159.nii Normal
+022_S_0007.nii AD
+023_S_0139.nii AD
+121_S_0953.nii AD
+033_S_0920.nii Normal
+099_S_0040.nii Normal
+002_S_1070.nii MCI
+062_S_0535.nii AD
+127_S_1210.nii MCI
+051_S_1296.nii AD
+005_S_0324.nii MCI
+011_S_0003.nii AD
+041_S_1435.nii AD
+020_S_1288.nii Normal
+137_S_0973.nii MCI
+002_S_0782.nii MCI
+012_S_0917.nii MCI
+023_S_0058.nii Normal
+127_S_0259.nii Normal
+127_S_0844.nii AD
+141_S_1152.nii AD
+029_S_1218.nii MCI
+036_S_0813.nii Normal
+067_S_1253.nii AD
+032_S_0187.nii MCI
+136_S_0429.nii MCI
+073_S_0312.nii Normal
+002_S_0295.nii Normal
+022_S_0004.nii MCI
+011_S_0183.nii AD
+036_S_1023.nii Normal
+036_S_0760.nii AD
+128_S_0528.nii AD
+123_S_0072.nii Normal
+016_S_1121.nii MCI
+123_S_0088.nii AD
+010_S_0422.nii MCI
+067_S_0812.nii AD
+109_S_1014.nii Normal
+023_S_0963.nii Normal
+027_S_0461.nii MCI
+014_S_0558.nii Normal
+051_S_1123.nii Normal
+057_S_1371.nii AD
+010_S_0788.nii MCI
+007_S_1206.nii Normal
+141_S_0790.nii AD
+052_S_1251.nii Normal
+137_S_0438.nii AD
+041_S_1423.nii MCI
+005_S_0553.nii Normal
+002_S_1280.nii Normal
+126_S_0784.nii AD
+137_S_0366.nii AD
+007_S_0316.nii AD
+022_S_0961.nii MCI
+011_S_0010.nii AD
+068_S_1075.nii MCI
+023_S_0625.nii MCI
+100_S_0047.nii Normal
+002_S_1261.nii Normal
+133_S_1031.nii MCI
+007_S_0344.nii MCI
+005_S_0223.nii Normal
+094_S_1293.nii MCI
+062_S_1099.nii Normal
+136_S_0695.nii MCI
+012_S_0634.nii MCI
+062_S_1182.nii MCI
+018_S_0277.nii AD
+010_S_0472.nii Normal
+020_S_0097.nii Normal
+009_S_1199.nii MCI
+014_S_1095.nii AD
+094_S_0434.nii MCI
+109_S_1192.nii AD
+027_S_0485.nii MCI
+094_S_0526.nii Normal
+057_S_0957.nii MCI
+094_S_1314.nii MCI
+131_S_0319.nii Normal
+021_S_0337.nii Normal
+011_S_0241.nii MCI
+027_S_1335.nii MCI
+126_S_0605.nii Normal
+132_S_0339.nii MCI
+037_S_0182.nii MCI
+007_S_0293.nii MCI
+007_S_0068.nii Normal
+114_S_1103.nii MCI
+013_S_0502.nii Normal
+029_S_0999.nii AD
+027_S_0404.nii AD
+027_S_0850.nii AD
+023_S_0031.nii Normal
+116_S_1249.nii Normal
+041_S_1368.nii AD
+099_S_0372.nii AD
+007_S_1304.nii AD
+041_S_0262.nii Normal
+137_S_0283.nii Normal
+023_S_1289.nii AD
+067_S_0290.nii MCI
+133_S_1055.nii AD
+031_S_1209.nii AD
+029_S_0843.nii Normal
+094_S_1267.nii Normal
+130_S_0423.nii MCI
+116_S_0370.nii AD
+041_S_0549.nii MCI
+033_S_0923.nii Normal
+094_S_1330.nii MCI
+022_S_0129.nii AD
+057_S_0941.nii MCI
+130_S_0232.nii Normal
+036_S_1001.nii AD
+082_S_1377.nii AD
+133_S_0433.nii Normal
+021_S_0343.nii AD
+011_S_0168.nii MCI
+023_S_0916.nii AD
+128_S_0245.nii Normal
+003_S_1257.nii AD
+016_S_0538.nii Normal
+126_S_0708.nii MCI
+036_S_0759.nii AD
+018_S_0080.nii MCI
+033_S_1279.nii MCI
+006_S_0681.nii Normal
+067_S_0024.nii Normal
+016_S_1092.nii MCI
+037_S_0327.nii Normal
+031_S_0321.nii AD
+037_S_0303.nii Normal
+126_S_1077.nii MCI
+009_S_0862.nii Normal
+002_S_0413.nii Normal
+100_S_0930.nii MCI
+126_S_1340.nii MCI
+127_S_0260.nii Normal
+133_S_0638.nii MCI
+018_S_0335.nii AD
+002_S_0559.nii Normal
+128_S_1242.nii Normal
+129_S_1204.nii MCI
+130_S_0956.nii AD
+024_S_1393.nii MCI
+006_S_0322.nii MCI
+013_S_1205.nii AD
+067_S_0828.nii AD
+036_S_1240.nii MCI
+067_S_0019.nii Normal
+003_S_1021.nii Normal
+130_S_0460.nii MCI
+052_S_1168.nii MCI
+123_S_0050.nii MCI
+009_S_0751.nii Normal
+006_S_0498.nii Normal
+021_S_0424.nii MCI
+062_S_0578.nii Normal
+116_S_0648.nii Normal
+023_S_1306.nii Normal
+057_S_1265.nii MCI
+013_S_1276.nii Normal
+018_S_0043.nii Normal
+011_S_1282.nii MCI

train_2C_new.txt

@@ -0,0 +1,519 @@
+006_S_0681.nii Normal
+129_S_0778.nii Normal
+099_S_1144.nii AD
+011_S_0008.nii Normal
+032_S_4348.nii Normal
+011_S_0016.nii Normal
+141_S_0696.nii AD
+127_S_5028.nii AD
+067_S_1253.nii AD
+021_S_1109.nii AD
+033_S_4508.nii Normal
+036_S_5149.nii AD
+041_S_4083.nii Normal
+098_S_4002.nii Normal
+098_S_0884.nii AD
+127_S_1382.nii AD
+016_S_4951.nii Normal
+137_S_4632.nii Normal
+021_S_0337.nii Normal
+062_S_0535.nii AD
+023_S_1190.nii Normal
+128_S_0528.nii AD
+114_S_4379.nii AD
+029_S_4385.nii Normal
+116_S_1083.nii AD
+141_S_0726.nii Normal
+009_S_4612.nii Normal
+003_S_4872.nii Normal
+009_S_0751.nii Normal
+041_S_1002.nii Normal
+128_S_0245.nii Normal
+116_S_0657.nii Normal
+005_S_4707.nii AD
+128_S_4607.nii Normal
+033_S_1087.nii AD
+062_S_0730.nii AD
+005_S_0553.nii Normal
+010_S_0420.nii Normal
+024_S_1063.nii Normal
+002_S_0619.nii AD
+037_S_4028.nii Normal
+014_S_4093.nii Normal
+023_S_0081.nii Normal
+023_S_0058.nii Normal
+013_S_1276.nii Normal
+094_S_1102.nii AD
+016_S_4952.nii Normal
+033_S_5017.nii AD
+941_S_4376.nii Normal
+136_S_0186.nii Normal
+121_S_0953.nii AD
+135_S_4446.nii Normal
+098_S_0171.nii Normal
+128_S_0517.nii AD
+100_S_1062.nii AD
+013_S_0502.nii Normal
+067_S_5205.nii AD
+098_S_4018.nii Normal
+116_S_4855.nii Normal
+014_S_0328.nii AD
+128_S_0310.nii AD
+036_S_5112.nii AD
+011_S_0002.nii Normal
+141_S_0717.nii Normal
+021_S_4924.nii AD
+005_S_0929.nii AD
+024_S_1171.nii AD
+123_S_4526.nii AD
+005_S_0223.nii Normal
+098_S_4215.nii AD
+116_S_4732.nii AD
+011_S_4906.nii AD
+029_S_1184.nii AD
+073_S_5090.nii AD
+029_S_4307.nii AD
+003_S_4900.nii Normal
+007_S_4637.nii Normal
+020_S_0097.nii Normal
+032_S_4277.nii Normal
+128_S_0805.nii AD
+013_S_0575.nii Normal
+073_S_0089.nii Normal
+018_S_0277.nii AD
+130_S_0956.nii AD
+135_S_4676.nii AD
+051_S_1123.nii Normal
+024_S_1307.nii AD
+136_S_0299.nii AD
+005_S_0610.nii Normal
+029_S_0843.nii Normal
+022_S_4266.nii Normal
+003_S_0907.nii Normal
+141_S_1152.nii AD
+141_S_0340.nii AD
+014_S_0558.nii Normal
+068_S_0473.nii Normal
+082_S_0304.nii Normal
+051_S_1296.nii AD
+072_S_4103.nii Normal
+153_S_4139.nii Normal
+116_S_0487.nii AD
+012_S_0712.nii AD
+033_S_1016.nii Normal
+067_S_0029.nii AD
+128_S_4774.nii AD
+116_S_4010.nii Normal
+100_S_1286.nii Normal
+094_S_4649.nii Normal
+067_S_0828.nii AD
+041_S_1391.nii AD
+014_S_0520.nii Normal
+129_S_4422.nii Normal
+022_S_4196.nii Normal
+037_S_0327.nii Normal
+021_S_4558.nii Normal
+024_S_4280.nii AD
+109_S_4378.nii AD
+002_S_0685.nii Normal
+029_S_0999.nii AD
+127_S_4645.nii Normal
+024_S_4223.nii AD
+031_S_0554.nii AD
+011_S_4827.nii AD
+021_S_0159.nii Normal
+073_S_0386.nii Normal
+012_S_0637.nii Normal
+127_S_4749.nii AD
+023_S_1289.nii AD
+011_S_0021.nii Normal
+035_S_4082.nii Normal
+005_S_0602.nii Normal
+062_S_0578.nii Normal
+003_S_4840.nii Normal
+068_S_5206.nii AD
+018_S_0043.nii Normal
+052_S_0951.nii Normal
+130_S_1337.nii AD
+029_S_4290.nii Normal
+022_S_0007.nii AD
+116_S_4195.nii AD
+067_S_0110.nii AD
+128_S_0740.nii AD
+023_S_1306.nii Normal
+016_S_0991.nii AD
+116_S_4537.nii AD
+029_S_4279.nii Normal
+021_S_4718.nii AD
+057_S_0818.nii Normal
+032_S_4304.nii Normal
+002_S_0559.nii Normal
+009_S_4388.nii Normal
+012_S_1009.nii Normal
+057_S_0934.nii Normal
+036_S_1001.nii AD
+141_S_0790.nii AD
+016_S_4353.nii AD
+068_S_4174.nii Normal
+018_S_0633.nii AD
+073_S_5023.nii Normal
+029_S_0866.nii Normal
+007_S_4911.nii AD
+057_S_4110.nii AD
+022_S_0130.nii Normal
+009_S_1334.nii AD
+003_S_5187.nii AD
+128_S_0545.nii Normal
+032_S_4921.nii Normal
+037_S_0467.nii Normal
+027_S_4962.nii AD
+009_S_0862.nii Normal
+941_S_1197.nii Normal
+137_S_4258.nii AD
+003_S_4892.nii AD
+137_S_4211.nii AD
+116_S_0648.nii Normal
+137_S_0686.nii Normal
+127_S_5056.nii AD
+035_S_4783.nii AD
+011_S_4105.nii Normal
+136_S_0184.nii Normal
+094_S_1164.nii AD
+123_S_0298.nii Normal
+099_S_0492.nii AD
+062_S_0690.nii AD
+094_S_4282.nii AD
+022_S_0014.nii Normal
+014_S_4576.nii Normal
+024_S_0985.nii Normal
+131_S_0457.nii AD
+127_S_4604.nii Normal
+094_S_1267.nii Normal
+035_S_0555.nii Normal
+011_S_4845.nii AD
+032_S_4386.nii Normal
+037_S_0454.nii Normal
+068_S_0109.nii AD
+002_S_0295.nii Normal
+029_S_4585.nii Normal
+036_S_0760.nii AD
+002_S_1261.nii Normal
+128_S_4586.nii Normal
+137_S_0841.nii AD
+067_S_0056.nii Normal
+036_S_0759.nii AD
+941_S_4255.nii Normal
+006_S_0653.nii AD
+007_S_1339.nii AD
+135_S_4954.nii AD
+137_S_0972.nii Normal
+033_S_4505.nii Normal
+006_S_0498.nii Normal
+127_S_0844.nii AD
+127_S_0754.nii AD
+116_S_0370.nii AD
+014_S_0548.nii Normal
+062_S_1099.nii Normal
+100_S_0893.nii AD
+029_S_0845.nii Normal
+068_S_0210.nii Normal
+072_S_4391.nii Normal
+027_S_1254.nii AD
+003_S_0981.nii Normal
+032_S_0147.nii AD
+037_S_4001.nii AD
+027_S_0850.nii AD
+023_S_5120.nii AD
+009_S_5224.nii AD
+014_S_4039.nii AD
+007_S_1222.nii Normal
+137_S_0366.nii AD
+067_S_0019.nii Normal
+094_S_0692.nii Normal
+073_S_4853.nii AD
+098_S_0149.nii AD
+037_S_0303.nii Normal
+041_S_1435.nii AD
+023_S_0084.nii AD
+037_S_4879.nii AD
+082_S_5029.nii AD
+021_S_0343.nii AD
+016_S_4887.nii AD
+099_S_0040.nii Normal
+024_S_4905.nii AD
+099_S_0352.nii Normal
+013_S_1161.nii AD
+005_S_0221.nii AD
+011_S_4075.nii Normal
+014_S_0519.nii Normal
+007_S_4387.nii Normal
+116_S_1249.nii Normal
+141_S_0767.nii Normal
+137_S_4466.nii Normal
+016_S_0359.nii Normal
+067_S_0020.nii AD
+141_S_1094.nii Normal
+067_S_1185.nii AD
+073_S_4739.nii Normal
+127_S_0622.nii Normal
+114_S_0416.nii Normal
+073_S_4552.nii Normal
+128_S_4832.nii Normal
+020_S_1288.nii Normal
+003_S_1257.nii AD
+037_S_4071.nii Normal
+137_S_4756.nii AD
+082_S_1256.nii Normal
+109_S_1014.nii Normal
+011_S_0183.nii AD
+023_S_1262.nii AD
+041_S_1368.nii AD
+035_S_0156.nii Normal
+018_S_0369.nii Normal
+114_S_0166.nii Normal
+009_S_4337.nii Normal
+127_S_4148.nii Normal
+041_S_4060.nii Normal
+116_S_0360.nii Normal
+007_S_0316.nii AD
+941_S_1203.nii Normal
+007_S_1304.nii AD
+067_S_0812.nii AD
+068_S_0127.nii Normal
+068_S_4968.nii AD
+027_S_0404.nii AD
+068_S_4424.nii Normal
+032_S_1037.nii AD
+035_S_0341.nii AD
+018_S_0335.nii AD
+023_S_0963.nii Normal
+098_S_4506.nii Normal
+073_S_0312.nii Normal
+007_S_4516.nii Normal
+005_S_0814.nii AD
+021_S_0647.nii Normal
+021_S_0642.nii AD
+129_S_4396.nii Normal
+126_S_0784.nii AD
+135_S_4598.nii Normal
+133_S_1170.nii AD
+116_S_0382.nii Normal
+123_S_0088.nii AD
+116_S_1232.nii Normal
+007_S_1248.nii AD
+130_S_1290.nii AD
+123_S_0113.nii Normal
+116_S_0392.nii AD
+109_S_1192.nii AD
+130_S_1201.nii AD
+128_S_0500.nii Normal
+014_S_1095.nii AD
+036_S_0576.nii Normal
+057_S_0474.nii AD
+018_S_0682.nii AD
+041_S_4014.nii Normal
+041_S_4041.nii Normal
+023_S_0031.nii Normal
+002_S_1280.nii Normal
+027_S_1081.nii AD
+003_S_4839.nii Normal
+126_S_0606.nii AD
+036_S_1023.nii Normal
+128_S_1242.nii Normal
+123_S_0106.nii Normal
+116_S_4092.nii Normal
+114_S_0228.nii AD
+031_S_0321.nii AD
+128_S_0266.nii AD
+016_S_4009.nii AD
+051_S_4980.nii AD
+116_S_4483.nii Normal
+126_S_0506.nii Normal
+133_S_0525.nii Normal
+035_S_0048.nii Normal
+135_S_5275.nii AD
+128_S_1430.nii AD
+036_S_0577.nii AD
+014_S_4615.nii AD
+041_S_4200.nii Normal
+003_S_4644.nii Normal
+131_S_0497.nii AD
+022_S_0066.nii Normal
+033_S_1285.nii AD
+007_S_1206.nii Normal
+057_S_1371.nii AD
+126_S_4686.nii AD
+123_S_4362.nii Normal
+021_S_4254.nii Normal
+032_S_1169.nii Normal
+010_S_0472.nii Normal
+037_S_4308.nii Normal
+041_S_0262.nii Normal
+036_S_0813.nii Normal
+011_S_4120.nii Normal
+037_S_4770.nii AD
+023_S_0916.nii AD
+941_S_1202.nii Normal
+127_S_0259.nii Normal
+002_S_0938.nii AD
+007_S_4620.nii Normal
+062_S_0768.nii Normal
+014_S_4577.nii Normal
+005_S_4910.nii AD
+100_S_0047.nii Normal
+033_S_4179.nii Normal
+037_S_0627.nii AD
+130_S_0969.nii Normal
+133_S_1055.nii AD
+128_S_5123.nii AD
+094_S_4560.nii Normal
+013_S_1205.nii AD
+131_S_0319.nii Normal
+012_S_0803.nii AD
+126_S_0605.nii Normal
+022_S_0096.nii Normal
+022_S_0219.nii AD
+029_S_0836.nii AD
+073_S_4559.nii Normal
+010_S_0419.nii Normal
+016_S_4591.nii AD
+073_S_4795.nii Normal
+033_S_0741.nii Normal
+057_S_1379.nii AD
+137_S_1041.nii AD
+033_S_1281.nii AD
+068_S_4340.nii Normal
+057_S_1373.nii AD
+022_S_0129.nii AD
+099_S_0534.nii Normal
+099_S_4076.nii Normal
+127_S_0431.nii AD
+033_S_5013.nii AD
+128_S_0522.nii Normal
+012_S_0689.nii AD
+033_S_1283.nii AD
+072_S_0315.nii Normal
+098_S_4050.nii Normal
+137_S_0283.nii Normal
+098_S_4275.nii Normal
+116_S_4338.nii AD
+133_S_0493.nii Normal
+011_S_0003.nii AD
+141_S_0853.nii AD
+029_S_1056.nii AD
+135_S_4657.nii AD
+009_S_5027.nii AD
+082_S_1377.nii AD
+133_S_0433.nii Normal
+053_S_1044.nii AD
+002_S_0413.nii Normal
+031_S_0618.nii Normal
+067_S_0177.nii Normal
+011_S_4278.nii Normal
+016_S_0538.nii Normal
+062_S_0793.nii AD
+023_S_0139.nii AD
+033_S_1308.nii AD
+135_S_5015.nii AD
+009_S_5252.nii AD
+023_S_0093.nii AD
+127_S_4992.nii AD
+014_S_0356.nii AD
+073_S_0311.nii Normal
+094_S_4737.nii AD
+099_S_4994.nii AD
+011_S_0023.nii Normal
+135_S_4863.nii AD
+003_S_0931.nii Normal
+099_S_4104.nii Normal
+012_S_0720.nii AD
+027_S_4964.nii AD
+031_S_1209.nii AD
+041_S_0125.nii Normal
+067_S_0024.nii Normal
+137_S_0438.nii AD
+007_S_4568.nii AD
+073_S_4155.nii Normal
+129_S_4371.nii Normal
+009_S_5037.nii AD
+023_S_4501.nii AD
+052_S_1251.nii Normal
+052_S_1250.nii Normal
+128_S_0167.nii AD
+003_S_1021.nii Normal
+131_S_0691.nii AD
+098_S_4003.nii Normal
+941_S_4066.nii Normal
+036_S_0672.nii Normal
+941_S_1195.nii Normal
+130_S_0232.nii Normal
+136_S_0194.nii AD
+011_S_0022.nii Normal
+022_S_4291.nii Normal
+033_S_5087.nii AD
+128_S_4599.nii Normal
+022_S_4173.nii Normal
+024_S_5054.nii AD
+010_S_0829.nii AD
+033_S_0888.nii AD
+094_S_0489.nii Normal
+123_S_0162.nii AD
+011_S_0010.nii AD
+073_S_4382.nii Normal
+153_S_4151.nii Normal
+032_S_0677.nii Normal
+100_S_0035.nii Normal
+094_S_0526.nii Normal
+109_S_0777.nii AD
+018_S_0425.nii Normal
+136_S_0426.nii AD
+005_S_5038.nii AD
+116_S_4043.nii Normal
+099_S_0533.nii Normal
+041_S_4037.nii Normal
+099_S_4086.nii Normal
+007_S_0068.nii Normal
+067_S_0257.nii Normal
+094_S_1402.nii AD
+033_S_4177.nii Normal
+033_S_0516.nii Normal
+082_S_4339.nii Normal
+099_S_0372.nii AD
+128_S_0216.nii AD
+013_S_0592.nii AD
+141_S_1137.nii AD
+033_S_0733.nii AD
+094_S_4460.nii Normal
+033_S_0923.nii Normal
+137_S_4587.nii Normal
+067_S_0059.nii Normal
+016_S_4638.nii Normal
+067_S_4728.nii AD
+033_S_0920.nii Normal
+127_S_4500.nii AD
+018_S_0286.nii AD
+014_S_0357.nii AD
+137_S_4520.nii Normal
+023_S_0926.nii Normal
+128_S_4772.nii AD
+137_S_0459.nii Normal
+007_S_5196.nii AD
+073_S_4393.nii Normal
+067_S_0076.nii AD
+041_S_4427.nii Normal
+073_S_4762.nii Normal
+011_S_0005.nii Normal
+123_S_0072.nii Normal
+020_S_0883.nii Normal
+082_S_0640.nii Normal
+127_S_4198.nii Normal
+127_S_0260.nii Normal
+027_S_0074.nii Normal
+041_S_4509.nii Normal
+024_S_4084.nii Normal
+153_S_4172.nii AD
+068_S_1191.nii Normal
+032_S_1101.nii AD
+020_S_0213.nii AD
+032_S_4429.nii Normal
+094_S_4459.nii Normal

train_2classes.txt

@@ -0,0 +1,328 @@
+011_S_0005.nii Normal
+022_S_0014.nii Normal
+127_S_1382.nii AD
+023_S_1262.nii AD
+068_S_0210.nii Normal
+067_S_0110.nii AD
+116_S_0657.nii Normal
+123_S_0113.nii Normal
+094_S_1102.nii AD
+003_S_0981.nii Normal
+114_S_0228.nii AD
+941_S_1197.nii Normal
+022_S_0066.nii Normal
+024_S_1063.nii Normal
+137_S_1041.nii AD
+067_S_1185.nii AD
+035_S_0555.nii Normal
+068_S_1191.nii Normal
+116_S_0360.nii Normal
+033_S_1281.nii AD
+099_S_0352.nii Normal
+032_S_0677.nii Normal
+094_S_0692.nii Normal
+011_S_0002.nii Normal
+126_S_0606.nii AD
+141_S_0696.nii AD
+131_S_0691.nii AD
+023_S_0084.nii AD
+136_S_0299.nii AD
+023_S_0093.nii AD
+012_S_1009.nii Normal
+141_S_0717.nii Normal
+941_S_1203.nii Normal
+057_S_1373.nii AD
+016_S_0991.nii AD
+128_S_0167.nii AD
+094_S_0489.nii Normal
+127_S_0622.nii Normal
+116_S_1083.nii AD
+032_S_0147.nii AD
+018_S_0425.nii Normal
+128_S_0740.nii AD
+031_S_0618.nii Normal
+068_S_0109.nii AD
+141_S_0853.nii AD
+073_S_0089.nii Normal
+137_S_0459.nii Normal
+067_S_0056.nii Normal
+014_S_0357.nii AD
+098_S_0884.nii AD
+033_S_0516.nii Normal
+024_S_0985.nii Normal
+128_S_0310.nii AD
+024_S_1171.nii AD
+141_S_0767.nii Normal
+100_S_1286.nii Normal
+012_S_0637.nii Normal
+133_S_0525.nii Normal
+133_S_1170.nii AD
+041_S_1002.nii Normal
+014_S_0328.nii AD
+018_S_0369.nii Normal
+029_S_1056.nii AD
+033_S_1087.nii AD
+073_S_0386.nii Normal
+007_S_1222.nii Normal
+024_S_1307.nii AD
+032_S_1101.nii AD
+116_S_0487.nii AD
+137_S_0972.nii Normal
+057_S_1379.nii AD
+011_S_0008.nii Normal
+012_S_0803.nii AD
+013_S_0575.nii Normal
+136_S_0186.nii Normal
+014_S_0548.nii Normal
+037_S_0467.nii Normal
+021_S_0647.nii Normal
+127_S_0431.nii AD
+014_S_0519.nii Normal
+041_S_1391.nii AD
+029_S_0866.nii Normal
+033_S_1283.nii AD
+029_S_1184.nii AD
+094_S_1164.nii AD
+020_S_0213.nii AD
+021_S_1109.nii AD
+005_S_0221.nii AD
+114_S_0416.nii Normal
+006_S_0653.nii AD
+005_S_0929.nii AD
+036_S_0672.nii Normal
+082_S_1256.nii Normal
+022_S_0130.nii Normal
+128_S_1430.nii AD
+005_S_0814.nii AD
+012_S_0720.nii AD
+016_S_0359.nii Normal
+021_S_0642.nii AD
+057_S_0818.nii Normal
+062_S_0730.nii AD
+068_S_0473.nii Normal
+136_S_0184.nii Normal
+035_S_0341.nii AD
+100_S_1062.nii AD
+123_S_0298.nii Normal
+022_S_0096.nii Normal
+067_S_0177.nii Normal
+109_S_0777.nii AD
+035_S_0156.nii Normal
+014_S_0520.nii Normal
+128_S_0517.nii AD
+011_S_0016.nii Normal
+141_S_1094.nii Normal
+136_S_0426.nii AD
+128_S_0266.nii AD
+057_S_0934.nii Normal
+035_S_0048.nii Normal
+023_S_0081.nii Normal
+002_S_0685.nii Normal
+116_S_1232.nii Normal
+131_S_0457.nii AD
+062_S_0793.nii AD
+027_S_0074.nii Normal
+133_S_0493.nii Normal
+057_S_0474.nii AD
+136_S_0194.nii AD
+131_S_0497.nii AD
+062_S_0690.nii AD
+023_S_0926.nii Normal
+011_S_0023.nii Normal
+062_S_0768.nii Normal
+941_S_1202.nii Normal
+005_S_0602.nii Normal
+032_S_1169.nii Normal
+137_S_0686.nii Normal
+053_S_1044.nii AD
+005_S_0610.nii Normal
+128_S_0522.nii Normal
+941_S_1195.nii Normal
+032_S_1037.nii AD
+007_S_1339.nii AD
+123_S_0162.nii AD
+029_S_0845.nii Normal
+036_S_0577.nii AD
+003_S_0907.nii Normal
+033_S_0741.nii Normal
+099_S_0534.nii Normal
+073_S_0311.nii Normal
+082_S_0304.nii Normal
+027_S_1254.nii AD
+011_S_0022.nii Normal
+003_S_0931.nii Normal
+020_S_0883.nii Normal
+052_S_1250.nii Normal
+100_S_0035.nii Normal
+033_S_0888.nii AD
+010_S_0420.nii Normal
+127_S_0754.nii AD
+099_S_0492.nii AD
+013_S_0592.nii AD
+027_S_1081.nii AD
+116_S_0382.nii Normal
+009_S_1334.nii AD
+123_S_0106.nii Normal
+099_S_0533.nii Normal
+011_S_0021.nii Normal
+018_S_0286.nii AD
+067_S_0076.nii AD
+029_S_0836.nii AD
+067_S_0059.nii Normal
+037_S_0454.nii Normal
+067_S_0020.nii AD
+130_S_1290.nii AD
+094_S_1402.nii AD
+002_S_0619.nii AD
+067_S_0257.nii Normal
+072_S_0315.nii Normal
+036_S_0576.nii Normal
+018_S_0682.nii AD
+033_S_1308.nii AD
+100_S_0893.nii AD
+068_S_0127.nii Normal
+114_S_0166.nii Normal
+041_S_0125.nii Normal
+141_S_1137.nii AD
+067_S_0029.nii AD
+033_S_0733.nii AD
+012_S_0689.nii AD
+098_S_0149.nii AD
+013_S_1161.nii AD
+098_S_0171.nii Normal
+141_S_0726.nii Normal
+128_S_0500.nii Normal
+128_S_0216.nii AD
+007_S_1248.nii AD
+021_S_0159.nii Normal
+022_S_0007.nii AD
+023_S_0139.nii AD
+121_S_0953.nii AD
+033_S_0920.nii Normal
+099_S_0040.nii Normal
+062_S_0535.nii AD
+051_S_1296.nii AD
+011_S_0003.nii AD
+041_S_1435.nii AD
+020_S_1288.nii Normal
+023_S_0058.nii Normal
+127_S_0259.nii Normal
+127_S_0844.nii AD
+141_S_1152.nii AD
+036_S_0813.nii Normal
+067_S_1253.nii AD
+073_S_0312.nii Normal
+002_S_0295.nii Normal
+011_S_0183.nii AD
+036_S_1023.nii Normal
+036_S_0760.nii AD
+128_S_0528.nii AD
+123_S_0072.nii Normal
+123_S_0088.nii AD
+067_S_0812.nii AD
+109_S_1014.nii Normal
+023_S_0963.nii Normal
+014_S_0558.nii Normal
+051_S_1123.nii Normal
+057_S_1371.nii AD
+007_S_1206.nii Normal
+141_S_0790.nii AD
+052_S_1251.nii Normal
+137_S_0438.nii AD
+005_S_0553.nii Normal
+002_S_1280.nii Normal
+126_S_0784.nii AD
+137_S_0366.nii AD
+007_S_0316.nii AD
+011_S_0010.nii AD
+100_S_0047.nii Normal
+002_S_1261.nii Normal
+005_S_0223.nii Normal
+062_S_1099.nii Normal
+018_S_0277.nii AD
+010_S_0472.nii Normal
+020_S_0097.nii Normal
+014_S_1095.nii AD
+109_S_1192.nii AD
+094_S_0526.nii Normal
+131_S_0319.nii Normal
+021_S_0337.nii Normal
+126_S_0605.nii Normal
+007_S_0068.nii Normal
+013_S_0502.nii Normal
+029_S_0999.nii AD
+027_S_0404.nii AD
+027_S_0850.nii AD
+023_S_0031.nii Normal
+116_S_1249.nii Normal
+041_S_1368.nii AD
+099_S_0372.nii AD
+007_S_1304.nii AD
+041_S_0262.nii Normal
+137_S_0283.nii Normal
+023_S_1289.nii AD
+133_S_1055.nii AD
+031_S_1209.nii AD
+029_S_0843.nii Normal
+094_S_1267.nii Normal
+116_S_0370.nii AD
+033_S_0923.nii Normal
+022_S_0129.nii AD
+130_S_0232.nii Normal
+036_S_1001.nii AD
+082_S_1377.nii AD
+133_S_0433.nii Normal
+021_S_0343.nii AD
+023_S_0916.nii AD
+128_S_0245.nii Normal
+003_S_1257.nii AD
+016_S_0538.nii Normal
+036_S_0759.nii AD
+006_S_0681.nii Normal
+067_S_0024.nii Normal
+037_S_0327.nii Normal
+031_S_0321.nii AD
+037_S_0303.nii Normal
+009_S_0862.nii Normal
+002_S_0413.nii Normal
+127_S_0260.nii Normal
+018_S_0335.nii AD
+002_S_0559.nii Normal
+128_S_1242.nii Normal
+130_S_0956.nii AD
+013_S_1205.nii AD
+067_S_0828.nii AD
+067_S_0019.nii Normal
+003_S_1021.nii Normal
+009_S_0751.nii Normal
+006_S_0498.nii Normal
+062_S_0578.nii Normal
+116_S_0648.nii Normal
+023_S_1306.nii Normal
+013_S_1276.nii Normal
+018_S_0043.nii Normal
+116_S_0392.nii AD
+010_S_0419.nii Normal
+126_S_0506.nii Normal
+130_S_0969.nii Normal
+023_S_1190.nii Normal
+052_S_0951.nii Normal
+141_S_0340.nii AD
+128_S_0805.nii AD
+012_S_0712.nii AD
+129_S_0778.nii Normal
+031_S_0554.nii AD
+137_S_0841.nii AD
+018_S_0633.nii AD
+033_S_1285.nii AD
+099_S_1144.nii AD
+010_S_0829.nii AD
+033_S_1016.nii Normal
+128_S_0545.nii Normal
+037_S_0627.nii AD
+130_S_1201.nii AD
+022_S_0219.nii AD
+002_S_0938.nii AD
+014_S_0356.nii AD
+082_S_0640.nii Normal
+130_S_1337.nii AD

validation_2C_new.txt

@@ -0,0 +1,100 @@
+012_S_1133.nii Normal
+021_S_4421.nii Normal
+029_S_4652.nii Normal
+100_S_0743.nii AD
+126_S_4494.nii AD
+007_S_4488.nii Normal
+010_S_0786.nii AD
+136_S_0086.nii Normal
+128_S_4792.nii AD
+127_S_4940.nii AD
+009_S_1354.nii AD
+137_S_4672.nii AD
+024_S_4158.nii Normal
+109_S_1013.nii Normal
+016_S_1263.nii AD
+021_S_0984.nii Normal
+070_S_4692.nii AD
+068_S_5146.nii AD
+131_S_0436.nii Normal
+011_S_4949.nii AD
+002_S_0955.nii AD
+029_S_0824.nii Normal
+082_S_4090.nii Normal
+014_S_4401.nii Normal
+073_S_1207.nii AD
+082_S_0363.nii Normal
+033_S_1098.nii Normal
+010_S_0067.nii Normal
+114_S_0173.nii Normal
+153_S_4372.nii Normal
+094_S_1090.nii AD
+094_S_1027.nii AD
+027_S_1385.nii AD
+109_S_0876.nii Normal
+094_S_1397.nii AD
+022_S_4320.nii Normal
+027_S_0118.nii Normal
+141_S_1024.nii AD
+941_S_4100.nii Normal
+094_S_4503.nii Normal
+126_S_0891.nii AD
+027_S_0403.nii Normal
+131_S_0123.nii Normal
+136_S_0196.nii Normal
+094_S_1241.nii Normal
+126_S_0405.nii Normal
+100_S_1113.nii AD
+123_S_0091.nii AD
+127_S_4843.nii Normal
+057_S_0643.nii Normal
+141_S_0852.nii AD
+136_S_0300.nii AD
+068_S_4859.nii AD
+023_S_0083.nii AD
+020_S_0899.nii Normal
+016_S_5057.nii AD
+098_S_4201.nii AD
+013_S_1035.nii Normal
+023_S_4448.nii Normal
+114_S_0979.nii AD
+094_S_4089.nii AD
+035_S_4464.nii Normal
+033_S_0889.nii AD
+029_S_4384.nii Normal
+137_S_0301.nii Normal
+011_S_0053.nii AD
+041_S_0898.nii Normal
+002_S_1018.nii AD
+131_S_0441.nii Normal
+032_S_0400.nii AD
+003_S_5165.nii AD
+082_S_1079.nii AD
+126_S_1221.nii AD
+109_S_0840.nii Normal
+016_S_5251.nii AD
+013_S_0996.nii AD
+127_S_0684.nii Normal
+116_S_4625.nii AD
+133_S_0488.nii Normal
+082_S_5184.nii AD
+100_S_0015.nii Normal
+023_S_4164.nii Normal
+016_S_4963.nii AD
+941_S_4292.nii Normal
+033_S_0739.nii AD
+141_S_0810.nii Normal
+031_S_0773.nii AD
+094_S_4234.nii Normal
+033_S_4176.nii Normal
+073_S_0565.nii AD
+002_S_0816.nii AD
+007_S_0070.nii Normal
+016_S_4097.nii Normal
+941_S_1194.nii Normal
+100_S_0069.nii Normal
+027_S_1082.nii AD
+027_S_4802.nii AD
+130_S_0886.nii Normal
+098_S_0896.nii Normal
+032_S_0479.nii Normal