joonmyung 1.5.13__tar.gz → 1.5.15__tar.gz

{joonmyung-1.5.13 → joonmyung-1.5.15}/PKG-INFO

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

{joonmyung-1.5.13 → joonmyung-1.5.15}/joonmyung/draw.py

@@ -241,28 +241,22 @@ def saliency(attentions=None, gradients=None, head_fusion="mean",
 
 
 
+
 def data2PIL(datas):
-    if type(datas) == torch.Tensor: # MAKE TO (..., H, W, 3)
-        if datas.shape[-1] == 3:
-            pils = datas
-        elif len(datas.shape) == 2:
+    if type(datas) == torch.Tensor:
+        if len(datas.shape) == 2:
             pils = datas.unsqueeze(-1).detach().cpu()
-        elif len(datas.shape) == 3:
+        if len(datas.shape) == 3:
             pils = datas.permute(1, 2, 0).detach().cpu()
         elif len(datas.shape) == 4:
             pils = datas.permute(0, 2, 3, 1).detach().cpu()
     elif type(datas) == np.ndarray:
-        if len(datas.shape) == 2:
-            datas = np.expand_dims(datas, axis=-1)
-        # TODO NEED TO CHECK
-        # if datas.max() <= 1:
-        #     pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)  # 0.29ms
-        # else:
-        #     pils = datas
-
-        # image = Image.fromarray(image)                 # 0.32ms
-        pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)  # 0.29ms
-
+        if len(datas.shape) == 3: datas = np.expand_dims(datas, axis=0)
+        if datas.max() <= 1:
+            # image = Image.fromarray(image)                 # 0.32ms
+            pils = cv2.cvtColor(datas, cv2.COLOR_BGR2RGB)   # 0.29ms
+        else:
+            pils = datas
     elif type(datas) == PIL.JpegImagePlugin.JpegImageFile \
          or type(datas) == PIL.Image.Image:
         pils = datas

{joonmyung-1.5.13 → joonmyung-1.5.15}/joonmyung/script.py

@@ -97,7 +97,7 @@ class GPU_Worker():
         return
 
     def message(self, text):
-        url = "https://hooks.slack.com/services/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"
+        url = "https://hooks.slack.com/services/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"
         payload = {"text": text}
         headers = {'Content-type': 'application/json'}
 
@@ -105,7 +105,7 @@ class GPU_Worker():
 
         return response
 
-def Process_Worker(processes, gpuWorker, id = "", p = True):
+def Process_Worker(processes, gpuWorker, m = None, p = False):
     # TODO : 실험이 완전히 끝난 시간 체크할 필요가 존재함
     start = time.localtime()
     print("------ Start Running!! : {} ------".format(time2str(start)))
@@ -114,25 +114,30 @@ def Process_Worker(processes, gpuWorker, id = "", p = True):
         gpus = gpuWorker.getGPU()
         prefix = f"CUDA_VISIBLE_DEVICES={gpus} nohup sh -c \'"
         suffix = f"\' > {i+1}:gpu{gpus}.log 2>&1 "
-        # print("------ {}:GPU{}  {} ------".format(i + 1, gpus, prefix + process + suffix))
-        p = subprocess.Popen(prefix + process + suffix, shell=True)
-        gpuWorker.register_process(gpus, p)
+        if p:
+            print("------ {}:GPU{}  {} ------".format(i + 1, gpus, prefix + process + suffix))
+        session = subprocess.Popen(prefix + process + suffix, shell=True)
+        gpuWorker.register_process(gpus, session)
     gpuWorker.waitForEnd()
     end = time.localtime()
+
     print("------ End Running!!   : {} ------".format(time2str(end)))
     training_time = datetime.timedelta(seconds=time.mktime(end) - time.mktime(start))
     print(f"Time 1/all :  {training_time}/{training_time / len(processes)} ------")
-    gpuWorker.message(f"Experiments Finished" 
-                      f"{id} : "
-                      f"Time 1/all : {training_time}/{training_time / len(processes)}"
-                      )
-
-
-
+    if m:
+        gpuWorker.message(f"Experiments Finished {m} : "  
+                          f"Time 1/all : {training_time}/{training_time / len(processes)}"
+                          )
 
 
 if __name__ == '__main__':
     # Wokring Sample
     processes = [1,2,3,4,5]
     gpuWorker = GPU_Worker([0,1,2,3], 30, 120, checkType=1, utilRatio=50, need_gpu=4)
-    Process_Worker(processes, gpuWorker)
+    Process_Worker(processes, gpuWorker)
+
+
+
+# 1호기 : https://hooks.slack.com/services/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
+# 2호기 : https://hooks.slack.com/services/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
+# 3호기 : https://hooks.slack.com/services/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

{joonmyung-1.5.13 → joonmyung-1.5.15}/joonmyung.egg-info/PKG-INFO

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

{joonmyung-1.5.13 → joonmyung-1.5.15}/joonmyung.egg-info/SOURCES.txt

@@ -29,17 +29,4 @@ joonmyung/meta_data/__init__.py
 joonmyung/meta_data/label.py
 joonmyung/meta_data/utils.py
 joonmyung/models/__init__.py
-joonmyung/models/tome.py
-models/__init__.py
-models/deit.py
-models/evit.py
-models/pvt.py
-models/pvt_v2.py
-models/tome.py
-models/SA/MHSA.py
-models/SA/PVTSA.py
-models/SA/TMSA.py
-models/SA/__init__.py
-models/modules/PE.py
-models/modules/__init__.py
-models/modules/blocks.py
+joonmyung/models/tome.py

{joonmyung-1.5.13 → joonmyung-1.5.15}/joonmyung.egg-info/top_level.txt

@@ -1,2 +1 @@
 joonmyung
-models

{joonmyung-1.5.13 → joonmyung-1.5.15}/setup.py

@@ -3,7 +3,7 @@ from setuptools import find_packages
 
 setuptools.setup(
     name="joonmyung",
-    version="1.5.13",
+    version="1.5.15",
     author="JoonMyung Choi",
     author_email="pizard@korea.ac.kr",
     description="JoonMyung's Library",

joonmyung-1.5.13/models/SA/MHSA.py

@@ -1,37 +0,0 @@
-import torch.nn as nn
-class MHSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.,
-                 talking_head=False):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = head_dim ** -0.5
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale # (B, H, T, D)
-        # attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_l(attn.transpose(1, -1)).transpose(1, -1)
-
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        # attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_w(attn.transpose(1, -1)).transpose(1, -1)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x

joonmyung-1.5.13/models/SA/PVTSA.py

@@ -1,90 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from functools import partial
-
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-from timm.models.registry import register_model
-from timm.models.vision_transformer import _cfg
-import math
-
-class PVTSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., sr_ratio=1, linear=False,
-                 talking_head=False):
-        super().__init__()
-        assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
-
-        self.dim = dim
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        self.q = nn.Linear(dim, dim, bias=qkv_bias)
-        self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-        self.linear = linear
-        self.sr_ratio = sr_ratio
-        if not linear:
-            if sr_ratio > 1:
-                self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
-                self.norm = nn.LayerNorm(dim)
-        else:
-            self.pool = nn.AdaptiveAvgPool2d(7)
-            self.sr = nn.Conv2d(dim, dim, kernel_size=1, stride=1)
-            self.norm = nn.LayerNorm(dim)
-            self.act = nn.GELU()
-        self.apply(self._init_weights)
-
-    def _init_weights(self, m):
-        if isinstance(m, nn.Linear):
-            trunc_normal_(m.weight, std=.02)
-            if isinstance(m, nn.Linear) and m.bias is not None:
-                nn.init.constant_(m.bias, 0)
-        elif isinstance(m, nn.LayerNorm):
-            nn.init.constant_(m.bias, 0)
-            nn.init.constant_(m.weight, 1.0)
-        elif isinstance(m, nn.Conv2d):
-            fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
-            fan_out //= m.groups
-            m.weight.data.normal_(0, math.sqrt(2.0 / fan_out))
-            if m.bias is not None:
-                m.bias.data.zero_()
-
-    def forward(self, x, H, W):
-        B, N, C = x.shape
-        q = self.q(x).reshape(B, N, self.num_heads, C // self.num_heads).permute(0, 2, 1, 3)
-
-        if not self.linear:
-            if self.sr_ratio > 1:
-                x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-                x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
-                x_ = self.norm(x_)
-                kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-            else:
-                kv = self.kv(x).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        else:
-            x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
-            x_ = self.sr(self.pool(x_)).reshape(B, C, -1).permute(0, 2, 1)
-            x_ = self.norm(x_)
-            x_ = self.act(x_)
-            kv = self.kv(x_).reshape(B, -1, 2, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        k, v = kv[0], kv[1]
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale
-
-        attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-
-        return x

joonmyung-1.5.13/models/SA/TMSA.py

@@ -1,37 +0,0 @@
-import torch.nn as nn
-class MHSA(nn.Module):
-    def __init__(self, dim, num_heads=8, qkv_bias=False, attn_drop=0., proj_drop=0.,
-                 talking_head=False):
-        super().__init__()
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = head_dim ** -0.5
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-
-        self.proj_l = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-        self.proj_w = nn.Linear(num_heads, num_heads) if talking_head else nn.Identity()
-
-
-    def forward(self, x):
-        B, N, C = x.shape
-        qkv = self.qkv(x).reshape(B, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]   # make torchscript happy (cannot use tensor as tuple)
-
-        attn = (q @ k.transpose(-2, -1)) * self.scale # (B, H, T, D)
-        # attn = self.proj_l(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_l(attn.transpose(1, -1)).transpose(1, -1)
-
-        attn = attn.softmax(dim=-1)
-        attn = self.attn_drop(attn)
-        # attn = self.proj_w(attn.permute(0, 2, 3, 1)).permute(0, 3, 1, 2)
-        attn = self.proj_w(attn.transpose(1, -1)).transpose(1, -1)
-
-        x = (attn @ v).transpose(1, 2).reshape(B, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x, k.mean(dim=1)