joonmyung 1.4.8__tar.gz → 1.4.9__tar.gz

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

@@ -1,13 +1,9 @@
 Metadata-Version: 2.1
 Name: joonmyung
-Version: 1.4.8
+Version: 1.4.9
 Summary: JoonMyung's Library
 Home-page: https://github.com/pizard/JoonMyung.git
 Author: JoonMyung Choi
 Author-email: pizard@korea.ac.kr
 License: MIT
-Platform: UNKNOWN
 License-File: LICENSE.txt
-
-UNKNOWN
-

joonmyung-1.4.9/README.md

@@ -0,0 +1,87 @@
+# 1. Introduction
+JoonMyung Choi's Package
+
+
+# 2. ToDo List
+### a. Library 
+1. joonmyung/Script
+ - [ ] 추가 스크립트, Queue 추가 
+
+2. joonmyung/draw 
+ - [ ] LinePlot 수정
+ 
+### b. Playground
+
+
+# 3. Previous
+## Version 1.4.1
+1. joonmyung/log
+ - [X] wandb table 저장 오류 수정
+2. joonmyung/utils
+ - [X] str2list 띄어쓰기 오류 수정
+
+## Version 1.4.0
+1. joonmyung/app.py
+ - [X] 실험 도중 스크립트 추가 기능
+2. joonmyung/log
+ - [X] 모델, 코드 저장 기능
+
+## Version 1.3.2
+1. joonmyung/Logger
+ - [X] wandb_id 작업
+
+## Version 1.3.2
+1. joonmyung/Script
+ - [X] Multi-GPU 적용
+2joonmyung/draw
+ - [X] rollout (Attention, Gradient) 추가   
+3. joonmyung/log
+ - [X] type에 대한 확인
+4. playground/profiling
+ - [X] 속도 측정 비교 메서드 구체화
+
+
+## Version 1.3.1
+### a. Library
+1. joonmyung/draw 
+ - [X] overlay 기능 추가
+
+### b. Playground
+1. playground/analysis
+   - [X] data  관련 분석 코드 작성
+   - [X] Model 관련 분석 코드 작성
+   
+## Version 1.3.0
+### a. Library 
+1. joonmyung/draw
+ - [X] drawImgPlot 추가   
+
+3. joonmyung/log
+- [X] Wandb Log / Table 추가
+
+
+
+
+
+
+
+
+[//]: # (CUDA_VISIBLE_DEVICES=2 python playground/models/fastsam/model.py --split 0)
+# CUDA_VISIBLE_DEVICES=2 nohup python playground/models/fastsam/model.py --split 0 > 0.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=2 nohup python playground/models/fastsam/model.py --split 1 > 1.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=2 nohup python playground/models/fastsam/model.py --split 2 > 2.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=2 nohup python playground/models/fastsam/model.py --split 3 > 3.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=3 nohup python playground/models/fastsam/model.py --split 4 > 4.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=3 nohup python playground/models/fastsam/model.py --split 5 > 5.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=3 nohup python playground/models/fastsam/model.py --split 6 > 6.log 2>&1  &
+# CUDA_VISIBLE_DEVICES=3 nohup python playground/models/fastsam/model.py --split 7 > 7.log 2>&1  &
+
+
+# nohup python playground/saliency/opencv.py --split 0 > 0.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 1 > 1.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 2 > 2.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 3 > 3.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 4 > 4.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 5 > 5.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 6 > 6.log 2>&1  &
+# nohup python playground/saliency/opencv.py --split 7 > 7.log 2>&1  &

joonmyung-1.4.9/joonmyung/analysis/analysis.py

@@ -0,0 +1,245 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "4"
+from joonmyung.analysis.dataset import JDataset
+from joonmyung.analysis.model import JModel
+from joonmyung.draw import saliency, overlay, drawImgPlot, drawHeatmap, unNormalize
+from joonmyung.meta_data import data2path
+from joonmyung.data import getTransform
+from joonmyung.metric import targetPred
+from joonmyung.log import AverageMeter
+from joonmyung.utils import to_leaf, to_np
+from tqdm import tqdm
+from contextlib import suppress
+import matplotlib.pyplot as plt
+import torch.nn.functional as F
+import numpy as np
+import torch
+import PIL
+import cv2
+
+
+def anaModel(transformer_class):
+    class VisionTransformer(transformer_class):
+        def forward_features(self, x):
+            x = self.patch_embed(x)
+            cls_token = self.cls_token.expand(x.shape[0], -1, -1)  # stole cls_tokens impl from Phil Wang, thanks
+            if self.dist_token is None:
+                x = torch.cat((cls_token, x), dim=1)
+            else:
+                x = torch.cat((cls_token, self.dist_token.expand(x.shape[0], -1, -1), x), dim=1)
+
+
+            if self.analysis[0] == 1:   # PATCH
+                x = x # (8, 197, 192)
+            elif self.analysis[0] == 2: # POS
+                x = self.pos_embed # (1, 197, 192)
+            elif self.analysis[0] == 3:  # PATCH (RANDOM I) + POS
+                x = torch.rand_like(self.pos_embed, device=x.device) + self.pos_embed
+            elif self.analysis[0] == 4:  # PATCH (RANDOM II) + POS
+                x = torch.rand_like(self.cls_token, device=x.device).repeat(1, x.shape[1], 1) + self.pos_embed
+            else: # PATCH + POS
+                x = x + self.pos_embed
+            x = self.pos_drop(x)
+
+            x = self.blocks(x)
+            x = self.norm(x)
+            if self.dist_token is None:
+                return self.pre_logits(x[:, 0])
+            else:
+                return x[:, 0], x[:, 1]
+
+    return VisionTransformer
+
+class Analysis:
+    def __init__(self, model, analysis = [0], activate = [True, False, False], detach=True, key_name=None, num_classes = 1000
+                 , cls_start=0, cls_end=1, patch_start=1, patch_end=None
+                 , ks = 5
+                 , amp_autocast=suppress, device="cuda"):
+        # Section A. Model
+        self.num_classes = num_classes
+        self.key_name = key_name
+
+        model_ = anaModel(model.__class__)
+        model.__class__ = model_
+        model.analysis = analysis
+        self.model = model
+        self.ks = ks
+        self.detach = detach
+
+        # Section B. Attention
+        self.kwargs_roll = {"cls_start" : cls_start, "cls_end" : cls_end,
+                            "patch_start" : patch_start, "patch_end" : patch_end}
+
+
+        # Section C. Setting
+        hooks = [{"name_i": 'attn_drop', "name_o": 'decoder', "fn_f": self.attn_forward, "fn_b": self.attn_backward},
+                 {"name_i": 'qkv', "name_o": 'decoder', "fn_f": self.qkv_forward, "fn_b": self.qkv_backward},
+                 {"name_i": 'head', "name_o": 'decoder', "fn_f": self.head_forward, "fn_b": self.head_backward}]
+        hooks = [h for h, a in zip(hooks, activate) if a]
+
+
+        self.amp_autocast = amp_autocast
+        self.device       = device
+
+        for name, module in self.model.named_modules():
+            for hook in hooks:
+                if hook["name_i"] in name and hook["name_o"] not in name:
+                    module.register_forward_hook(hook["fn_f"])
+                    module.register_backward_hook(hook["fn_b"])
+
+    def attn_forward(self, module, input, output):
+        # input  : 1 * (8, 3, 197, 197)
+        # output : (8, 3, 197, 197)
+        self.info["attn"]["f"].append(output.detach() if self.detach else output)
+
+    def attn_backward(self, module, grad_input, grad_output):
+        # input  : 1 * (8, 3, 197, 192)
+        # output : (8, 3, 197, 576)
+        self.info["attn"]["b"].insert(0, grad_input[0].detach() if self.detach else grad_input[0])
+
+    def qkv_forward(self, module, input, output):
+        # input  : 1 * (8, 197, 192)
+        # output : (8, 197, 576)
+        self.info["qkv"]["f"].append(output.detach())
+
+    def qkv_backward(self, module, grad_input, grad_output):
+        # self.info["qkv"]["b"].append(grad_input[0].detach())
+       pass
+
+    def head_forward(self, module, input, output):
+        # input : 1 * (8(B), 192(D)), output : (8(B), 1000(C))
+        # TP = targetPred(output.detach(), self.targets.detach(), topk=self.ks)
+        TP = targetPred(to_leaf(output), to_leaf(self.targets), topk=self.ks)
+        self.info["head"]["TP"] = torch.cat([self.info["head"]["TP"], TP], dim=0) if "TP" in self.info["head"].keys() else TP
+
+    def head_backward(self, module, grad_input, grad_output):
+        pass
+
+    def resetInfo(self):
+        self.info = {"attn": {"f": [], "b": []}, "qkv": {"f": [], "b": []},
+                     "head": {"acc1" : AverageMeter(),
+                              "acc5" : AverageMeter(),
+                              "pred" : None
+
+                              }}
+
+    def __call__(self, samples, index=None, **kwargs):
+        self.resetInfo()
+        self.model.zero_grad()
+        self.model.eval()
+
+        if type(samples) == torch.Tensor:
+            outputs = self.model(samples, **kwargs)
+            return outputs
+        else:
+            for sample, self.targets in tqdm(samples):
+                _ = self.model(sample)
+            return False
+
+    def anaSaliency(self, attn=True, grad=False, output=None, index=None,
+                    head_fusion="mean", discard_ratios=[0.], data_from="cls",
+                    ls_attentive=[], ls_rollout=[],
+                    reshape=False, device="cuda"):
+
+        if attn:
+            attn = self.info["attn"]["f"]
+        if grad:
+            self.info["attn"]["b"] = []
+            self.model.zero_grad()
+            if index == None: index = output.max(dim=1)[1]
+            index = torch.eye(self.num_classes, device=self.device)[index]
+            loss = (output * index).sum()
+            loss.backward(retain_graph=True)
+            grad = self.info["attn"]["b"]
+
+        return saliency(attn, grad
+                        , head_fusion=head_fusion, discard_ratios=discard_ratios, data_from=data_from
+                        , ls_rollout=ls_rollout, ls_attentive=ls_attentive, reshape=reshape, device=device)
+
+
+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
+        # 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
+
+    # 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 = 1, "deit_tiny_patch16_224"
+
+    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)

{joonmyung-1.4.8 → joonmyung-1.4.9}/joonmyung/analysis/dataset.py

@@ -1,21 +1,22 @@
 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
 
+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_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_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),
@@ -40,13 +41,15 @@ class JDataset():
             result[:, c].sub_(m).div_(s)
         return result
 
-    def __init__(self, data_path="/hub_data1/joonmyung/data", dataset="imagenet", device="cuda"):
+    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
-        [self.d_kind, self.d_type] = ["imagenet", "val"] if self.d == "imagenet" else ["cifar", "test"]
-        # [self.d_kind, self.d_type] = ["imagenet", "train"] if self.d == "imagenet" else ["cifar", "test"]
+        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]
@@ -81,7 +84,7 @@ class JDataset():
         dataset = create_dataset(
             root=self.data_path, name="IMNET" if self.d == "imagenet" else self.d.upper()
             , split='validation', is_training=False
-            , download=False, load_bytes=False, class_map='')
+            , load_bytes=False, class_map='')
 
         loader = create_loader(
             dataset,

joonmyung-1.4.9/joonmyung/analysis/model.py

@@ -0,0 +1,35 @@
+from collections import OrderedDict
+
+from joonmyung.utils import isDir
+from timm import create_model
+import torch
+import os
+
+class JModel():
+    def __init__(self, num_classes = None, model_path= None, device="cuda", p=False):
+        # Pretrained_Model
+        self.num_classes = num_classes
+
+        if model_path:
+            self.model_path = os.path.join(model_path, "checkpoint_{}.pth")
+        if p and model_path:
+            print("file list : ", sorted(os.listdir(model_path), reverse=True))
+        self.device = device
+
+    def load_state_dict(self, model, state_dict):
+        state_dict = OrderedDict((k.replace("module.", ""), v) for k, v in state_dict.items())
+        model.load_state_dict(state_dict)
+
+
+    def getModel(self, model_type=0, model_name ="deit_tiny", **kwargs):
+
+        if model_type == 0:
+            model = create_model(model_name, pretrained=True, num_classes=self.num_classes, in_chans=3, global_pool=None, scriptable=False)
+        elif model_type == 1:
+            model = torch.hub.load('facebookresearch/deit:main', model_name, pretrained=True)
+        else:
+            raise ValueError
+        model.eval()
+
+        return model.to(self.device)
+

joonmyung-1.4.9/joonmyung/data.py

@@ -0,0 +1,47 @@
+import torch
+
+def rangeBlock(block, vmin=0, vmax=5):
+    loss = torch.arange(vmin, vmax, (vmax - vmin) / block, requires_grad=False).unsqueeze(dim=1)
+    return loss
+
+def columnRename(df, ns):
+    for n in ns:
+        if n[0] in df.columns:
+            df.rename(columns = {n[0]: n[1]}, inplace = True)
+#     columnRemove(df, ['c1', 'c2' ... ])
+
+
+def columnRemove(df, ns):
+    delList = []
+    for n in ns:
+        if n in df.columns:
+            delList.append(n)
+    df.drop(delList, axis=1, inplace=True)
+#     columnRename(df, [['c1_p', 'c1_a'] , ['c2_p', 'c2_a']])
+
+
+def normalization(t, type = 0):
+    if type == 0:
+        return t / t.max()
+    elif type == 1:
+        return t / t.min()
+
+from torchvision import transforms
+from torchvision.transforms import InterpolationMode
+
+def getTransform(train = False, totensor = False, resize=True):
+
+    if not resize:
+        transform = lambda x: x
+    else:
+        transform = []
+
+        transform.append(transforms.RandomResizedCrop(224, scale=(0.5, 1.0), interpolation=InterpolationMode.BICUBIC)) \
+            if train else transform.append(transforms.Resize((224, 224), interpolation=3))
+
+        if totensor:
+            transform.append(transforms.ToTensor())
+            transform.append(transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]))
+        transform = transforms.Compose(transform)
+
+    return transform