joonmyung 1.4.9__tar.gz → 1.5.1__tar.gz

{joonmyung-1.4.9 → joonmyung-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: joonmyung
-Version: 1.4.9
+Version: 1.5.1
 Summary: JoonMyung's Library
 Home-page: https://github.com/pizard/JoonMyung.git
 Author: JoonMyung Choi

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/analysis/analysis.py

@@ -1,5 +1,5 @@
 import os
-os.environ["CUDA_VISIBLE_DEVICES"] = "4"
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
 from joonmyung.analysis.dataset import JDataset
 from joonmyung.analysis.model import JModel
 from joonmyung.draw import saliency, overlay, drawImgPlot, drawHeatmap, unNormalize
@@ -160,86 +160,98 @@ class Analysis:
 if __name__ == '__main__':
     # Section A. Data
     dataset_name, device, amp_autocast, debug = "imagenet", 'cuda', torch.cuda.amp.autocast, True
-    data_path, _, _ = data2path(dataset_name)
-    data_num, batch_size, bs = [[0, 0], [1, 0], [2, 0], [3, 0], [0, 1], [1, 1], [2, 1], [3, 1]], 16, []
-    view, activate = [False, True, False, False, False], [True, False, False] #
-        # VIEW     : IMG, SALIENCY(M), SALIENCY(D), SALIENCY(S), ATTN. MOVEMENT
+    data_path, num_classes, _, _ = data2path(dataset_name)
+    view, activate = [False, True, False, False, False], [True, False, False]
+        # VIEW     : IMG, SALIENCY:ATTN, SALIENCY:OPENCV, SALIENCY:GRAD, ATTN. MOVEMENT
         # ACTIVATE : ATTN, QKV, HEAD
-    analysis = [2]
-        # [0] : INPUT TYPE, [0 : SAMPLE + POS, 1 : SAMPLE, 2 : POS]
-    if not debug:
-        dataset = JDataset(data_path, dataset_name, device=device)
-        samples, targets, imgs, label_names = dataset.getItems(data_num)
-        loader = dataset.getAllItems(batch_size)
-        num_classes = dataset.num_classes
-    else:
-        transform = getTransform(False, True)
-        img = PIL.Image.open('/hub_data1/joonmyung/data/imagenet/train/n01440764/n01440764_10026.JPEG')
-        samples, targets, label_names = transform(img)[None].to(device), torch.tensor([0]).to(device)[None].to(device), 'tench, Tinca tinca'
-        num_classes = 1000
+    analysis = [0] # [0] : INPUT TYPE, [0 : SAMPLE + POS, 1 : SAMPLE, 2 : POS]
+
+    dataset = JDataset(data_path, dataset_name, device=device)
+    data_idxs = [[c, i] for i in range(1000) for c in range(50)]
+    # data_idxs = [[21, 0], [22, 0], [2, 0], [0, 0], [0, 1], [1, 1], [2, 1], [3, 1]]
 
     # Section B. Model
-    model_number, model_name = 0, "deit_tiny_patch16_224" # deit_tiny_patch16_224, deit_small_patch16_224, deit_base_patch16_224
-    # model_number, model_name = 0, "vit_tiny_patch16_224" # vit_tiny_patch16_224,  vit_small_patch16_224,  vit_base_patch16_224
+    model_number, model_name = 0, "deit_tiny_patch16_224" # deit, vit | tiny, small, base
     # model_number, model_name = 1, "deit_tiny_patch16_224"
 
+    # Section C. Setting
+    ls_rollout, ls_attentive, col = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 12
+
     modelMaker = JModel(num_classes, device=device)
     model = modelMaker.getModel(model_number, model_name)
     model = Analysis(model, analysis = analysis, activate = activate, device=device)
-
-
-    samples_ = samples[bs] if bs else samples
-    targets_ = targets[bs] if bs else targets
-    output = model(samples_)
-    if view[0]:
-        drawImgPlot(unNormalize(samples_, "imagenet"))
-
-    if view[1]: # SALIENCY W/ MODEL
-        ls_rollout, ls_attentive, col = [0,1,2,3,4,5,6,7,8,9,10,11], [0,1,2,3,4,5,6,7,8,9,10,11], 12
-        # discard_ratios, v_ratio, head_fusion, data_from = [0.0, 0.4, 0.8], 0.1, "mean", "cls"  # Attention, Gradient
-        discard_ratios, v_ratio, head_fusion, data_from = [0.0], 0.0, "mean", "patch"  # Attention, Gradient
-        rollout, attentive = model.anaSaliency(True, False, output, discard_ratios=discard_ratios,
-                                         ls_attentive = ls_attentive, ls_rollout=ls_rollout,
-                                         head_fusion  = head_fusion, index=targets_, data_from=data_from,
-                                         reshape      = True) # (12(L), 8(B), 14(H), 14(W))
-        print(1)
-        # datas_rollout = overlay(samples_, rollout,   dataset_name)
-        # drawImgPlot(datas_rollout, col=col)
-        # datas_attn    = overlay(samples_, attentive, dataset_name)
-        # drawImgPlot(datas_attn, col=col)
-
-    if view[2]:  # SALIENCY W/ DATA
-        img = np.array(imgs[0])
-
-        saliency = cv2.saliency.StaticSaliencySpectralResidual_create()
-        (success, saliencyMap) = saliency.computeSaliency(img)
-        saliencyMap = (saliencyMap * 255).astype("uint8")
-
-        saliency = cv2.saliency.StaticSaliencyFineGrained_create()
-        (success, saliencyFineMap) = saliency.computeSaliency(img)
-        threshMap = cv2.threshold((saliencyFineMap * 255).astype("uint8"), 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
-        # plt.imshow(threshMap)
-        # plt.show()
-
-    if view[3]:  # SALIENCY FOR INPUT
-        samples_.requires_grad, model.detach, k = True, False, 3
-        output = model(samples_)
-        attn = torch.stack(model.info["attn"]["f"], dim=1).mean(dim=[2,3])[0,-2]
-        topK = attn[1:].topk(k, -1, True)[1]
-        # a = torch.autograd.grad(attn.sum(), samples, retain_graph=True)[0].sum(dim=1)
-        a = torch.autograd.grad(output[:,3], samples_, retain_graph=True)[0].sum(dim=1)
-        b = F.interpolate(a.unsqueeze(0), scale_factor=0.05, mode='nearest')[0]
-        # drawHeatmap(b)
-        print(1)
-        # to_np(torch.stack([attn[:, :, 0], attn[:, :, 1:].sum(dim=-1)], -1)[0])
-
-    if view[4]: # ATTENTION MOVEMENT (FROM / TO)
-        attn = torch.stack(model.info["attn"]["f"]).mean(dim=2).transpose(0,1) # (8 (B), 12 (L), 197(T_Q), 197(T_K))
-        cls2cls     = attn[:, :, :1, 0].mean(dim=2)              # (8(B), 12(L))
-        patch2cls   = attn[:, :, :1, 1:].mean(dim=2).sum(dim=-1) # (8(B), 12(L))
-        to_np(torch.stack([cls2cls.mean(dim=0), patch2cls.mean(dim=0)]))
-
-        cls2patch   = attn[:, :, 1:, 0].mean(dim=2)
-        patch2patch = attn[:, :, 1:, 1:].mean(dim=2).sum(dim=-1)
-        to_np(torch.stack([cls2patch.mean(dim=0), patch2patch.mean(dim=0)]))
-        print(1)
+    for idx, data_idx in enumerate(data_idxs):
+        print(f"------------------------- [{data_idx[0]}]/[{data_idx[1]}] -------------------------")
+
+        sample, target, label_name = dataset[data_idx[0], data_idx[1]]
+        # sample, _, img, _ = dataset.getItemPath('/hub_data1/joonmyung/data/imagenet/train/n01440764/n01440764_39.JPEG')
+        output = model(sample)
+        if view[0]:
+            drawImgPlot(unNormalize(sample, "imagenet"))
+
+        if view[1]: # SALIENCY W/ MODEL
+            # ls_rollout, ls_attentive, col = [], [0,2,4,6,8,10], 6
+            # discard_ratios, v_ratio, head_fusion, data_from = [0.0, 0.4, 0.8], 0.1, "mean", "cls"
+            discard_ratios, v_ratio, head_fusion, data_from = [0.0], 0.0, "mean", "patch"  # Attention, Gradient
+            rollout, attentive = model.anaSaliency(True, False, output, discard_ratios=discard_ratios,
+                                                   ls_attentive = ls_attentive, ls_rollout=ls_rollout,
+                                                   head_fusion  = head_fusion, index=target, data_from=data_from,
+                                                   reshape      = True) # (12(L), 8(B), 14(H), 14(W))
+            datas_attn    = overlay(sample, attentive, dataset_name)
+            drawImgPlot(datas_attn, col=col)
+
+            discard_ratios, v_ratio, head_fusion, data_from = [0.0], 0.0, "mean", "cls"  # Attention, Gradient
+            rollout, attentive = model.anaSaliency(True, False, output, discard_ratios=discard_ratios,
+                                                   ls_attentive = ls_attentive, ls_rollout=ls_rollout,
+                                                   head_fusion  = head_fusion, index=target, data_from=data_from,
+                                                   reshape      = True) # (12(L), 8(B), 14(H), 14(W))
+            datas_attn = overlay(sample, attentive, dataset_name)
+            drawImgPlot(datas_attn, col=col)
+
+
+            # datas_rollout = overlay(sample, rollout,   dataset_name)
+            # drawImgPlot(datas_rollout, col=col)
+
+            # datas_attn = overlay(sample, attentive, dataset_name)
+            # drawImgPlot(datas_attn, col=col)
+
+            # a = attentive[5]
+            # b = torch.stack([a.clamp(max=a.quantile(1 - v_ratio)) for v_ratio in [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55]])
+            # datas_attn    = overlay(sample, b, dataset_name)
+            # drawImgPlot(datas_attn, col=col)
+            # print(1)
+
+        if view[2]:  # SALIENCY W/ DATA
+            img = np.array(dataset[data_idx[0], data_idx[1], 2][0])
+
+            saliency = cv2.saliency.StaticSaliencySpectralResidual_create()
+            (success, saliencyMap) = saliency.computeSaliency(img)
+            saliencyMap = (saliencyMap * 255).astype("uint8")
+
+            saliency = cv2.saliency.StaticSaliencyFineGrained_create()
+            (success, saliencyFineMap) = saliency.computeSaliency(img)
+            threshMap = cv2.threshold((saliencyFineMap * 255).astype("uint8"), 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
+            # plt.imshow(threshMap)
+            # plt.show()
+
+        if view[3]:  # SALIENCY FOR INPUT
+            sample.requires_grad, model.detach, k = True, False, 3
+            output = model(sample)
+            attn = torch.stack(model.info["attn"]["f"], dim=1).mean(dim=[2,3])[0,-2]
+            topK = attn[1:].topk(k, -1, True)[1]
+            # a = torch.autograd.grad(attn.sum(), samples, retain_graph=True)[0].sum(dim=1)
+            a = torch.autograd.grad(output[:,3], sample, retain_graph=True)[0].sum(dim=1)
+            b = F.interpolate(a.unsqueeze(0), scale_factor=0.05, mode='nearest')[0]
+            # drawHeatmap(b)
+            print(1)
+            # to_np(torch.stack([attn[:, :, 0], attn[:, :, 1:].sum(dim=-1)], -1)[0])
+
+        if view[4]: # ATTENTION MOVEMENT (FROM / TO)
+            attn = torch.stack(model.info["attn"]["f"]).mean(dim=2).transpose(0,1) # (8 (B), 12 (L), 197(T_Q), 197(T_K))
+            cls2cls     = attn[:, :, :1, 0].mean(dim=2)              # (8(B), 12(L))
+            patch2cls   = attn[:, :, :1, 1:].mean(dim=2).sum(dim=-1) # (8(B), 12(L))
+            # PATCH가 받는 정도
+            cls2patch   = attn[:, :, 1:, 0].mean(dim=2)
+            patch2patch = attn[:, :, 1:, 1:].mean(dim=2).sum(dim=-1)
+            # to_np(torch.stack([cls2cls.mean(dim=0), patch2cls.mean(dim=0), cls2patch.mean(dim=0), patch2patch.mean(dim=0)]))
+            print(1)

joonmyung-1.5.1/joonmyung/analysis/dataset.py

@@ -0,0 +1,129 @@
+from joonmyung.meta_data.label import imnet_label, cifar_label
+from timm.data import create_dataset, create_loader
+from torchvision import transforms
+from joonmyung.utils import getDir
+import torch
+import copy
+import glob
+import PIL
+import os
+
+
+# CIFAR Setting
+# pip install cifar2png
+# cifar2png cifar100 ./cifar100
+# cifar2png cifar10  ./cifar10
+
+class JDataset():
+    # transforms.Resize(int((256 / 224) * input_size), interpolation=InterpolationMode.BICUBIC),
+    settings = {"imagenet" : {
+                    "num_classes"   : 1000,
+                    "data_types"    : ["val", "train"],
+                    "label_name"    : imnet_label,
+                    "distributions" : {"mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225]},
+                    "size": (224, 224)
+                    },
+                "cifar100" : {
+                    "num_classes" : 100,
+                    "data_types": ["test", "train"],
+                    "label_name" : cifar_label,
+                    "distributions": {"mean": [0.4914, 0.4822, 0.4465], "std": [0.2023, 0.1994, 0.2010]},
+                    "size" : (32, 32)
+                    }
+    }
+
+    def __init__(self, data_path="/hub_data1/joonmyung/data", dataset="imagenet", train=False, transform_type = 0,
+                 distribution = None, size = None, device="cuda"):
+        self.dataset = dataset.lower()
+        setting = self.settings[self.dataset]
+        self.label_name     = setting["label_name"]
+        self.data_type      = setting["data_types"][train]
+        self.transform_type = transform_type
+        self.distribution   = distribution if distribution else setting["distributions"]
+        size                = size if size else setting["size"]
+
+        self.transform = [
+                transforms.Compose([transforms.Resize(size, interpolation=3), transforms.ToTensor(), transforms.Normalize(self.distribution["mean"], self.distribution["std"])]),
+                transforms.Compose([transforms.Resize(size, interpolation=3), transforms.ToTensor()]),
+                transforms.Compose([transforms.ToTensor()])
+        ]
+
+        self.device = device
+        self.data_path = data_path
+        self.label_paths = sorted(getDir(os.path.join(self.data_path, self.data_type)))
+        self.img_paths   = [sorted(glob.glob(os.path.join(self.data_path, self.data_type, label_path, "*"))) for label_path in self.label_paths]
+        # self.img_paths   = [sorted(glob.glob(os.path.join(self.data_path, self.data_type, "*", "*")))]
+
+
+    def __getitem__(self, idx):
+        if len(idx) == 2:
+            label_num, img_num = idx
+            transform_type = self.transform_type
+        elif len(idx) == 3:
+            label_num, img_num, transform_type = idx
+
+        img_path = self.img_paths[label_num][img_num]
+        img = PIL.Image.open(img_path)
+        data = self.transform[transform_type](img)
+
+        return data.unsqueeze(0).to(self.device), torch.tensor(label_num).to(self.device), self.label_name[int(label_num)]
+
+    def getItems(self, indexs):
+        ds, ls, lns = [], [], []
+        for index in indexs:
+            d, l, ln = self.__getitem__(index)
+            ds.append(d)
+            ls.append(l)
+            lns.append(ln)
+        return torch.cat(ds, dim=0), torch.stack(ls, dim=0), lns
+
+    def getItemPath(self, img_path):
+        img = PIL.Image.open(img_path)
+        data = self.transform(img)
+        return data.unsqueeze(0).to(self.device)
+
+    def __len__(self):
+        return
+
+    def getAllItems(self, batch_size=32):
+        dataset = create_dataset(
+            root=self.data_path, name="IMNET"
+            , split='validation', is_training=False
+            , load_bytes=False, class_map='')
+
+        loader = create_loader(
+            dataset,
+            input_size=(3, 224, 224),
+            batch_size=batch_size,
+            use_prefetcher=True,
+            interpolation='bicubic',
+            mean = self.distribution["mean"],
+            std  = self.distribution["std"],
+            num_workers=8,
+            crop_pct=0.9,
+            pin_memory=False,
+            tf_preprocessing=False)
+        return loader
+
+    def validation(self, data):
+        return data.lower()
+
+    def unNormalize(self, image):
+        result = torch.zeros_like(image)
+        for c, (m, s) in enumerate(zip(self.distribution["mean"], self.distribution["std"])):
+            result[:, c] = image[:, c].mul(s).add(m)
+        return result
+
+    def normalize(self, image):
+        result = copy.deepcopy(image)
+        for c, (m, s) in enumerate(zip(self.distribution["mean"], self.distribution["std"])):
+            result[:, c].sub_(m).div_(s)
+        return result
+
+if __name__ == "__main__":
+    root_path = "/hub_data1/joonmyung/data"
+    dataset = "imagenet"
+    dataset = JDataset(root_path, dataset, train=True, )
+    d, l, l_n  = dataset[0, 1]
+    samples = dataset.getitems([[0,1], [0,2], [0,3]])
+    print(1)

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/draw.py

@@ -212,8 +212,10 @@ def saliency(attentions=None, gradients=None, head_fusion="mean",
             rollouts = rollouts.reshape(-1, B, H, W) # L, B, H, W
 
     if ls_attentive:
+        # attentive = saliencys[ls_attentive, :, 0] \
+        #         if data_from == "cls" else saliencys[ls_attentive, :, 1:].mean(dim=2) # (L, B, T)
         attentive = saliencys[ls_attentive, :, 0] \
-                if data_from == "cls" else saliencys[ls_attentive, :, 1:].mean(dim=2) # (L, B, T)
+            if data_from == "cls" else saliencys[ls_attentive].mean(dim=2)  # (L, B, T)
         attentive = attentive[:, :, 1:]
         if reshape:
             attentive = attentive.reshape(-1, B, H, W)

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/log.py

@@ -1,3 +1,5 @@
+import pickle
+
 from joonmyung.utils import is_dist_avail_and_initialized
 from collections import defaultdict, deque
 from joonmyung.draw import data2PIL

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/meta_data/utils.py

@@ -31,9 +31,13 @@ def data2path(dataset,
 
     if dataset in ["imagenet", "IMNET"]:
         data_path = os.path.join(data_path, "imagenet") if "kakao" not in server else os.path.join(data_path, "imagenet-pytorch")
+        num_classes = 1000
+    else:
+        raise ValueError
+
     output_dir    = os.path.join(output_dir, conference, wandb_version, wandb_name)
 
-    return data_path, output_dir, server
+    return data_path, num_classes, output_dir, server
 
 def get_label(key, d_name ="imagenet"):
     d_name = d_name.lower()

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/metric.py

@@ -1,4 +1,4 @@
-from fvcore.nn import FlopCountAnalysis, flop_count_table, flop_count_str
+from fvcore.nn import FlopCountAnalysis, flop_count_table
 from torchprofile import profile_macs
 from typing import Tuple
 from thop import profile
@@ -24,7 +24,7 @@ def numel(model,
     return round(params, round_num)
 
 @torch.no_grad()
-def flops(model, size, round_num=1, eval=True, device="cuda", fp16=False, **kwargs):
+def flops(model, size, round_num=1, eval=True, fp16=False, device="cuda", **kwargs):
     if eval: model.eval()
     with torch.cuda.amp.autocast(enabled=fp16):
         inputs = torch.randn(size, device=device, requires_grad=True)

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung/script.py

@@ -3,6 +3,7 @@ from tqdm import tqdm
 import subprocess
 import time
 import pynvml
+import datetime
 
 class GPU_Worker():
     def __init__(self, gpus:list, waitTimeInit = 30, waitTime = 60, count = 0,
@@ -69,7 +70,7 @@ class GPU_Worker():
         if len(self.availGPUs) < self.need_gpu: self.setGPU()
         gpus, self.availGPUs = self.availGPUs[:self.need_gpu], self.availGPUs[self.need_gpu:]
 
-        return ', '.join(map(str, gpus))
+        return ','.join(map(str, gpus))
 
 
     def check_process(self):

{joonmyung-1.4.9 → joonmyung-1.5.1}/joonmyung.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: joonmyung
-Version: 1.4.9
+Version: 1.5.1
 Summary: JoonMyung's Library
 Home-page: https://github.com/pizard/JoonMyung.git
 Author: JoonMyung Choi

{joonmyung-1.4.9 → joonmyung-1.5.1}/setup.py

@@ -3,7 +3,7 @@ from setuptools import find_packages
 
 setuptools.setup(
     name="joonmyung",
-    version="1.4.9",
+    version="1.5.1",
     author="JoonMyung Choi",
     author_email="pizard@korea.ac.kr",
     description="JoonMyung's Library",
@@ -27,3 +27,4 @@ setuptools.setup(
 
 # python setup.py sdist; python -m twine upload dist/*
 # ID:JoonmyungChoi
+

joonmyung-1.4.9/joonmyung/analysis/dataset.py

@@ -1,108 +0,0 @@
-from joonmyung.meta_data.label import imnet_label, cifar_label
-from timm.data import create_dataset, create_loader
-from torchvision import transforms
-import torch
-import copy
-import glob
-import PIL
-import os
-
-from joonmyung.utils import getDir
-
-
-class JDataset():
-    distributions = {"imagenet": {"mean": [0.485, 0.456, 0.406], "std": [0.229, 0.224, 0.225]},
-                        "cifar": {"mean": [0.4914, 0.4822, 0.4465], "std": [0.2023, 0.1994, 0.2010]}}
-    transform_cifar         = transforms.Compose([transforms.ToTensor(), transforms.Normalize(distributions["cifar"]["mean"], distributions["cifar"]["std"])])
-    # transform_imagenet_     = transforms.Compose([transforms.ToTensor(), transforms.Normalize(distributions["imagenet"]["mean"], distributions["imagenet"]["std"])])
-    # transform_imagenet_vis = transforms.Compose([transforms.Resize(256, interpolation=3), transforms.CenterCrop(224)])
-    transform_imagenet_vis  = transforms.Compose([transforms.Resize((224, 224), interpolation=3)])
-    transform_imagenet_norm = transforms.Compose([transforms.ToTensor(), transforms.Normalize(distributions["imagenet"]["mean"], distributions["imagenet"]["std"])])
-
-    # transforms.Resize(int((256 / 224) * input_size), interpolation=InterpolationMode.BICUBIC),
-    transforms = {"imagenet" : [transform_imagenet_vis, transform_imagenet_norm], "cifar" : transform_cifar}
-
-    # CIFAR Setting
-    # pip install cifar2png
-    # cifar2png cifar100 ./cifar100
-    # cifar2png cifar10  ./cifar10
-    def validation(self, data):
-        return data.lower()
-
-    def unNormalize(self, image):
-        result = torch.zeros_like(image)
-        for c, (m, s) in enumerate(zip(self.distributions[self.d_kind]["mean"], self.distributions[self.d_kind]["std"])):
-            result[:, c] = image[:, c].mul(s).add(m)
-        return result
-
-    def normalize(self, image):
-        result = copy.deepcopy(image)
-        for c, (m, s) in enumerate(zip(self.distributions[self.d_kind]["mean"], self.distributions[self.d_kind]["std"])):
-            result[:, c].sub_(m).div_(s)
-        return result
-
-    def __init__(self, data_path="/hub_data1/joonmyung/data", dataset="imagenet", device="cuda", train = False):
-        dataset = dataset.lower()
-
-        self.d      = dataset.lower()
-        self.num_classes = 1000 if self.d == "imagenet" else 100
-        if train:
-            [self.d_kind, self.d_type] = ["imagenet", "val"] if self.d == "imagenet" else ["cifar", "test"]
-        else:
-            [self.d_kind, self.d_type] = ["imagenet", "train"] if self.d == "imagenet" else ["cifar", "train"]
-        self.device = device
-
-        self.transform = self.transforms[self.d_kind]
-        self.data_path = data_path
-        self.label_name = imnet_label if self.d_kind == "imagenet" else cifar_label
-        self.label_paths = sorted(getDir(os.path.join(self.data_path, self.d_type)))
-        self.img_paths = [sorted(glob.glob(os.path.join(self.data_path, self.d_type, label_path, "*"))) for label_path in self.label_paths]
-
-    def __getitem__(self, index):
-        label_num, img_num = index
-        img_path = self.img_paths[label_num][img_num]
-        img = PIL.Image.open(img_path)
-
-        img = self.transform[0](img)
-        data = self.transform[1](img)
-        return data.unsqueeze(0).to(self.device), torch.tensor(label_num).to(self.device), \
-                    img, self.label_name[int(label_num)]
-    def getItems(self, indexs):
-        ds, ls, ies, lns = [], [], [], []
-        for index in indexs:
-            d, l, i, ln = self.__getitem__(index)
-            ds.append(d)
-            ls.append(l)
-            ies.append(i)
-            lns.append(ln)
-        return torch.cat(ds, dim=0), torch.stack(ls, dim=0), ies, lns
-    def __len__(self):
-        return
-
-    def getAllItems(self, batch_size=32):
-
-        dataset = create_dataset(
-            root=self.data_path, name="IMNET" if self.d == "imagenet" else self.d.upper()
-            , split='validation', is_training=False
-            , load_bytes=False, class_map='')
-
-        loader = create_loader(
-            dataset,
-            input_size=(3, 224, 224),
-            batch_size=batch_size,
-            use_prefetcher=True,
-            interpolation='bicubic',
-            mean=self.distributions[self.d_kind]["mean"],
-            std=self.distributions[self.d_kind]["std"],
-            num_workers=8,
-            crop_pct=0.9,
-            pin_memory=False,
-            tf_preprocessing=False)
-        return loader
-
-# if __name__ == "__main__":
-#     root_path = "/hub_data1/joonmyung/data"
-#     dataset = "cifar100"
-#     dataset = JDataset(root_path, dataset)
-#     # sample  = dataset[0, 1]
-#     samples = dataset.getitems([[0,1], [0,2], [0,3]])