anofit 0.1.0.dev0__cp313-cp313-win_amd64.whl

anofit/__init__.py

@@ -0,0 +1,32 @@
+"""anofit — SCHAD 이상탐지 엔진 (구조부 + 논리부, 모드 선택).
+
+geofit(찾기) · gaugefit(재기) 형제. 이쪽은 **가려내기**다.
+
+    import anofit
+    b = anofit.load("juice", mode="struct")     # 학습된 분기의 부분집합만 허용
+    s, amap, parts = anofit.score(b, image_bgr)
+
+알고리즘 이름은 계속 SCHAD 다 — `anofit` 은 그것을 담아 파는 제품의 이름이다.
+"""
+# ⚠ **torch/transformers 임포트 전에** 캐시 경로를 심는다. 라이브러리가 임포트 시점에
+# 경로를 굳히므로 나중에 바꿔도 늦다. 아래 임포트들은 torch 를 지연 임포트하지만,
+# 순서를 지키는 것이 규약이다.
+from . import config as _config
+
+_config.apply_cache_env()
+
+from .bundle import BundleError, describe, evict, load
+from .modes import BRANCHES, MODES, Mode, ModeError, available, resolve
+from .scoring import fuse_from_raw, score, score_many, score_raw
+from .quality import drift, mode_table, operating, roi_mismatch
+from .state import ModelState, threshold_report
+
+__version__ = "0.1.0.dev0"
+
+__all__ = [
+    "load", "describe", "evict", "BundleError",
+    "score", "score_raw", "score_many", "fuse_from_raw",
+    "MODES", "Mode", "ModeError", "BRANCHES", "resolve", "available",
+    "ModelState", "threshold_report", "__version__",
+    "mode_table", "operating", "drift", "roi_mismatch",
+]

anofit/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+raise SystemExit(main())

anofit/_vendor/csad_onnx.py

@@ -0,0 +1,251 @@
+"""
+    This file contains the ONNX/Pytorch model for CSAD.
+"""
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.onnx
+
+from .model import AutoEncoder, LocalStudent
+from .seg_model import Segmentor
+
+
+class FixedPatchClassDetector(nn.Module):
+    """
+        Optimized version of patch histogram detector for fast speed
+        and support batched input.
+        (Predefined patch sizes and overlap ratios)
+        (not using EMPatches to extract patches)
+    """
+    def __init__(self,num_classes=5,segmap_size=256,use_nahalanobis=True):
+        super().__init__()
+        self.num_classes = num_classes
+        self.segmap_size = segmap_size
+
+        self.use_nahalanobis = use_nahalanobis
+
+        self.hist_mean = torch.nn.Parameter(data=torch.randn((self.num_classes,1)),requires_grad=False)
+        self.hist_invcov = torch.nn.Parameter(data=torch.randn((self.num_classes,self.num_classes)),requires_grad=False)
+        self.patch_hist_mean = torch.nn.Parameter(data=torch.randn((self.num_classes*4,1)),requires_grad=False)
+        self.patch_hist_invcov = torch.nn.Parameter(data=torch.randn((self.num_classes*4,self.num_classes*4)),requires_grad=False)
+        self.hist_val_mean = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.hist_val_std = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.patch_hist_val_mean = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.patch_hist_val_std = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+
+
+    def set_params(self,params):
+        self.hist_mean = torch.nn.Parameter(data=params['hist_mean'].unsqueeze(1),requires_grad=False)
+        self.hist_invcov = torch.nn.Parameter(data=params['hist_invcov'],requires_grad=False)
+        self.patch_hist_mean = torch.nn.Parameter(data=params['patch_hist_mean'].unsqueeze(1),requires_grad=False)
+        self.patch_hist_invcov = torch.nn.Parameter(data=params['patch_hist_invcov'],requires_grad=False)
+        self.hist_val_mean = torch.nn.Parameter(data=params['hist_val_mean'],requires_grad=False)
+        self.hist_val_std = torch.nn.Parameter(data=params['hist_val_std'],requires_grad=False)
+        self.patch_hist_val_mean = torch.nn.Parameter(data=params['patch_hist_val_mean'],requires_grad=False)
+        self.patch_hist_val_std = torch.nn.Parameter(data=params['patch_hist_val_std'],requires_grad=False)
+
+    @staticmethod
+    def mahalanobis(u, v, invcov):
+        delta = u - v
+        m = torch.matmul(delta.T, torch.matmul(invcov, delta)).squeeze()
+        return torch.sqrt(m)
+
+    @staticmethod
+    def histogram(seg_map):
+        _, max_indices = torch.max(seg_map, dim=1)
+        # Create a tensor of zeros with the same shape as the input tensor
+        out = torch.zeros_like(seg_map)
+        # Set the max values to 1 by using advanced indexing
+        out.scatter_(1, max_indices.unsqueeze(1), 1)
+        hist = torch.mean(out,dim=[2,3])
+        hist = hist.unsqueeze(2)
+        return hist
+
+    @staticmethod
+    def patch_histogram(seg_map):
+        # patch_size = 128
+        a = seg_map[:,:,:128,:128]
+        b = seg_map[:,:,128:,:128]
+        c = seg_map[:,:,:128,128:]
+        d = seg_map[:,:,128:,128:]
+        return torch.concat([
+            FixedPatchClassDetector.histogram(a),
+            FixedPatchClassDetector.histogram(b),
+            FixedPatchClassDetector.histogram(c),
+            FixedPatchClassDetector.histogram(d)]
+            ,dim=1)
+
+
+
+    def forward(self,segmap):
+        hist = FixedPatchClassDetector.histogram(segmap)
+        patch_hist = FixedPatchClassDetector.patch_histogram(segmap)
+
+        diff_hists = []
+        diff_patchhists = []
+        for i in range(segmap.shape[0]):
+            if self.use_nahalanobis:
+                diff_hist = FixedPatchClassDetector.mahalanobis(hist[i],self.hist_mean,self.hist_invcov)
+                diff_patchhist = FixedPatchClassDetector.mahalanobis(patch_hist[i],self.patch_hist_mean,self.patch_hist_invcov)
+            else:
+                diff_hist = ((hist[i]-self.hist_mean)**2).sum()**0.5
+                diff_patchhist = ((patch_hist[i]-self.patch_hist_mean)**2).sum()**0.5
+            diff_hists.append(diff_hist)
+            diff_patchhists.append(diff_patchhist)
+        diff_hist = torch.stack(diff_hists)
+        diff_patchhist = torch.stack(diff_patchhists)
+
+        diff_hist = (diff_hist-self.hist_val_mean)/self.hist_val_std
+        diff_patchhist = (diff_patchhist-self.patch_hist_val_mean)/self.patch_hist_val_std
+
+        out_score = diff_hist + diff_patchhist
+        return out_score
+
+# without encoder
+class ResNetTeacher(nn.Module):
+    def __init__(self,out_dim=512,feat_size=64):
+        super().__init__()
+        self.out_dim = out_dim
+        self.feat_size = feat_size
+        self.proj = nn.Conv2d(1024+512, self.out_dim, kernel_size=1, stride=1, padding=0)
+        self.proj.requires_grad_(False)
+
+    def forward(self, x):
+        x = [x[1],x[2]]
+        concat_feat = []
+        for i in range(len(x)):
+            feat = x[i]
+            feat = F.interpolate(feat, size=self.feat_size, mode='bilinear',align_corners=False)
+            concat_feat.append(feat)
+        concat_feat = torch.cat(concat_feat,dim=1)
+        concat_feat = nn.AvgPool2d(kernel_size=3, stride=1, padding=1)(concat_feat)
+        proj_feat = self.proj(concat_feat)
+        return proj_feat
+
+class CSAD_ONNX(nn.Module):
+    def __init__(self,dim=512,num_classes=5):
+        super().__init__()
+        self.teacher_mean = torch.nn.Parameter(data=torch.randn((1,dim,1,1)),requires_grad=False)
+        self.teacher_std = torch.nn.Parameter(data=torch.randn((1,dim,1,1)),requires_grad=False)
+
+        self.q_st_start = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.q_st_end = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.q_ae_start = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.q_ae_end = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+
+        self.lgst_mean = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.lgst_std = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+
+        self.patch_hist_mean = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+        self.patch_hist_std = torch.nn.Parameter(data=torch.randn(1)[0],requires_grad=False)
+
+        self.encoder = timm.create_model('hf_hub:timm/wide_resnet50_2.tv2_in1k'
+                                                ,pretrained=True,
+                                                features_only=True,
+                                                out_indices=[1,2,3])
+        self.teacher = ResNetTeacher(out_dim=512,feat_size=64)
+        self.local_st = LocalStudent(out_dim=512,feat_size=64,padding=True)
+        self.autoencoder = AutoEncoder(out_dim=512,out_size=64)
+        self.segmentor = Segmentor(num_classes=num_classes)
+        self.patch_hist_detector = FixedPatchClassDetector(
+            num_classes=num_classes
+            ,segmap_size=256,
+            use_nahalanobis=True
+        )
+
+    def load_model_params(self,models,params):
+        self.teacher_mean = torch.nn.Parameter(data=params['teacher_mean'],requires_grad=False)
+        self.teacher_std = torch.nn.Parameter(data=params['teacher_std'],requires_grad=False)
+
+        self.q_st_start = torch.nn.Parameter(data=params['q_st_start'],requires_grad=False)
+        self.q_st_end = torch.nn.Parameter(data=params['q_st_end'],requires_grad=False)
+        self.q_ae_start = torch.nn.Parameter(data=params['q_ae_start'],requires_grad=False)
+        self.q_ae_end = torch.nn.Parameter(data=params['q_ae_end'],requires_grad=False)
+
+        self.lgst_mean = torch.nn.Parameter(data=params['lgst_mean'],requires_grad=False)
+        self.lgst_std = torch.nn.Parameter(data=params['lgst_std'],requires_grad=False)
+        if self.lgst_std < 1e-3:
+            self.lgst_std = torch.nn.Parameter(data=torch.tensor([1])[0],requires_grad=False)
+
+        self.patch_hist_mean = torch.nn.Parameter(data=params['patchhist_mean'],requires_grad=False)
+        self.patch_hist_std = torch.nn.Parameter(data=params['patchhist_std'],requires_grad=False)
+        if self.patch_hist_std < 1e-3:
+            self.patch_hist_std = torch.nn.Parameter(data=torch.tensor([1])[0],requires_grad=False)
+
+        self.encoder = models['encoder']
+        self.teacher = models['teacher']
+        self.local_st = models['local_st']
+        self.autoencoder = models['autoencoder']
+        self.segmentor = models['segmentor']
+        self.patch_hist_detector = models['patch_hist_detector']
+        return self
+
+
+    @classmethod
+    def from_pretrained(cls,models,params):
+        num_classes = models['segmentor'].fc2.conv3.out_channels
+        return cls(num_classes=num_classes).load_model_params(models,params)
+
+
+    def forward(self, image):
+        # shape: (B,3,256,256)
+        feat = self.encoder(image)
+
+        # Patch Histogram branch
+        segmap = self.segmentor(feat)
+        # segmap = torch.argmax(segmap,dim=1)
+        patch_hist_score = self.patch_hist_detector(segmap)
+
+        # LGST branch
+        teacher_feat = self.teacher(feat)
+        teacher_feat = (teacher_feat-self.teacher_mean)/self.teacher_std
+        local_feat,global_feat = self.local_st(image)
+        ae_global_feat = self.autoencoder(image)
+
+        diff_local = torch.pow(teacher_feat-local_feat,2).mean(1)
+        diff_global = torch.pow(global_feat-ae_global_feat,2).mean(1)
+
+        # map normalization
+        diff_local = 0.1 * (diff_local - self.q_st_start) / (self.q_st_end - self.q_st_start)
+        diff_global = 0.1 * (diff_global - self.q_ae_start) / (self.q_ae_end - self.q_ae_start)
+
+        LGST_score = torch.amax(diff_local+diff_global,dim=(1,2))
+
+        # score fusion
+        LGST_score = (LGST_score-self.lgst_mean)/self.lgst_std
+        patch_hist_score = (patch_hist_score-self.patch_hist_mean)/self.patch_hist_std
+
+
+
+        return LGST_score+patch_hist_score
+
+    def forward_maps(self, image):
+        """forward 와 동일 점수 + 오버레이용 2D 이상맵(LGST 공간맵, (B,64,64)) 반환.
+
+        patch-histogram(논리) 브랜치는 히스토그램 기반이라 자연스러운 공간맵이 없어,
+        오버레이는 LGST(구조) 공간맵으로 위치를 표시하고, 최종 점수에는 둘 다 반영된다.
+        """
+        feat = self.encoder(image)
+
+        segmap = self.segmentor(feat)
+        patch_hist_score = self.patch_hist_detector(segmap)
+
+        teacher_feat = self.teacher(feat)
+        teacher_feat = (teacher_feat - self.teacher_mean) / self.teacher_std
+        local_feat, global_feat = self.local_st(image)
+        ae_global_feat = self.autoencoder(image)
+
+        diff_local = torch.pow(teacher_feat - local_feat, 2).mean(1)
+        diff_global = torch.pow(global_feat - ae_global_feat, 2).mean(1)
+        diff_local = 0.1 * (diff_local - self.q_st_start) / (self.q_st_end - self.q_st_start)
+        diff_global = 0.1 * (diff_global - self.q_ae_start) / (self.q_ae_end - self.q_ae_start)
+
+        lgst_map = diff_local + diff_global  # (B,64,64)
+        LGST_score = torch.amax(lgst_map, dim=(1, 2))
+
+        LGST_score = (LGST_score - self.lgst_mean) / self.lgst_std
+        patch_hist_score = (patch_hist_score - self.patch_hist_mean) / self.patch_hist_std
+
+        score = LGST_score + patch_hist_score
+        return score, lgst_map

anofit/_vendor/logical.py

@@ -0,0 +1,115 @@
+"""SCHAD 논리부(patch-hist) — 벤더링된 CSAD LightCSAD 추론 코드.
+
+원본: modules/csad/runner.py 의 LightCSAD/_light_segmentor/_preprocess/_get_transform.
+schad 자립(standalone)을 위해 csad 모듈 의존 없이 _vendor 안으로 흡수한다.
+encoder(timm wide_resnet50_2.tv2_in1k)·전처리(PIL BILINEAR)는 원본과 동일해야 점수가 재현된다.
+
+오프라인 배포(CLAUDE.md §13-6): 인코더 가중치는 **프로젝트 내** weights/ 에 둔다.
+과거엔 timm 이 `hf_hub:` 로 HuggingFace 를 직접 쳤고, 그러면 가중치가 프로젝트가 아니라
+사용자 캐시(~/.cache/huggingface)에 떨어진다 — 프로젝트를 통째로 복사해도 인터넷 없는
+현장 PC 에서 첫 로드가 실패한다(다른 모듈은 이미 weights/ 로 오프라인화돼 있었는데 여기만 누락).
+"""
+from __future__ import annotations
+
+import logging
+
+import numpy as np
+
+logger = logging.getLogger("anofit.logical")
+
+# 학습 때 쓴 인코더와 동일해야 한다 — 바꾸면 segmentor 가 학습한 특징과 어긋나 점수가 재현되지 않는다.
+_ENCODER_MODEL = "wide_resnet50_2.tv2_in1k"
+_ENCODER_KW = dict(features_only=True, out_indices=[1, 2, 3])
+
+
+def _encoder_weight_path():
+    """인코더 가중치 로컬 보관 경로(weights/timm__{모델}/encoder.pth)."""
+    from ..config import find_weight
+
+    return find_weight(f"timm__{_ENCODER_MODEL}/encoder.pth")
+
+
+def _build_encoder():
+    """논리부 인코더 로드 — 오프라인 우선.
+
+    weights/ 에 받아둔 게 있으면 인터넷 없이 그것으로, 없으면 이때만 내려받아 weights/ 에
+    영속화한다(다음부터 오프라인 가능). patchcore/backbone.py 와 같은 방식.
+    """
+    import timm
+    import torch
+
+    local = _encoder_weight_path()
+    if local.exists():
+        enc = timm.create_model(_ENCODER_MODEL, pretrained=False, **_ENCODER_KW)
+        enc.load_state_dict(torch.load(str(local), map_location="cpu"))
+        logger.info("논리부 인코더 로컬 로드: %s", local)
+        return enc
+
+    logger.info("논리부 인코더 다운로드: %s → %s", _ENCODER_MODEL, local)
+    try:
+        enc = timm.create_model(f"hf_hub:timm/{_ENCODER_MODEL}", pretrained=True, **_ENCODER_KW)
+    except Exception as exc:
+        from ..config import weights_root
+
+        raise RuntimeError(
+            f"논리부 인코더 로드 실패({_ENCODER_MODEL}): {exc}. "
+            f"오프라인 현장이면 인터넷 PC 에서 한 번 받아 '{weights_root()}' 폴더를 "
+            "현장 PC 로 복사하세요."
+        ) from exc
+    try:
+        local.parent.mkdir(parents=True, exist_ok=True)
+        torch.save(enc.state_dict(), str(local))
+        logger.info("논리부 인코더 영속화 완료: %s", local)
+    except OSError as exc:
+        logger.warning("인코더 로컬 저장 실패(%s): %s — 이번 세션은 그대로 동작", local, exc)
+    return enc
+
+
+def _light_segmentor(num_classes, in_dim, state_dict):
+    """벤더링된 Segmentor 재구성(추론 전용)."""
+    from .models.segmentation.model import Segmentor  # 벤더 상대 import
+
+    seg = Segmentor(num_classes=num_classes, in_dim=in_dim, in_size=256)
+    seg.load_state_dict(state_dict)
+    return seg.eval()
+
+
+def LightCSAD(bundle):
+    import torch
+    import torch.nn as nn
+
+    from .csad_onnx import FixedPatchClassDetector
+
+    nc = int(bundle["num_classes"])
+    p = bundle["patchhist_params"]
+
+    class _LightCSAD(nn.Module):
+        def __init__(self):
+            super().__init__()
+            # 학습 때와 동일 encoder (segmentor 가 이 특징으로 학습됨) — weights/ 오프라인 우선
+            self.encoder = _build_encoder()
+            for q in self.encoder.parameters():
+                q.requires_grad = False
+            self.segmentor = _light_segmentor(nc, bundle.get("in_dim", [256, 1024]),
+                                              bundle["segmentor_state"])
+            self.patch_hist_detector = FixedPatchClassDetector(num_classes=nc, segmap_size=256, use_nahalanobis=True)
+            t = lambda x: torch.tensor(np.asarray(x), dtype=torch.float32)
+            self.patch_hist_detector.set_params({
+                "hist_mean": t(p["hist_mean"]), "hist_invcov": t(p["hist_invcov"]),
+                "patch_hist_mean": t(p["patch_hist_mean"]), "patch_hist_invcov": t(p["patch_hist_invcov"]),
+                "hist_val_mean": t(p["hist_val_mean"]), "hist_val_std": t(p["hist_val_std"]),
+                "patch_hist_val_mean": t(p["patch_hist_val_mean"]), "patch_hist_val_std": t(p["patch_hist_val_std"]),
+            })
+
+        def forward(self, image):
+            return self.patch_hist_detector(self.segmentor(self.encoder(image)))
+
+        def forward_maps(self, image):
+            # 경량(patch-hist)은 히스토그램 기반이라 공간 이상맵이 없음 → 오버레이 None
+            return self.forward(image), None
+
+    return _LightCSAD()
+
+
+# 전처리(_get_transform/_preprocess)는 anofit/preprocess.py 로 옮겼다 (기획서 §3.4-2).
+# 구조부 전용 경로가 논리부 모듈을 import 하지 않게 하려는 것이 목적이다.

anofit/_vendor/model.py

@@ -0,0 +1,191 @@
+
+import timm
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class PDN_M(nn.Module):
+    def __init__(self, out_dim=512,feat_size=64,padding=False):
+        super().__init__()
+        self.out_dim = out_dim
+        self.st_size = feat_size
+        self.ae_size = feat_size
+        self.padding = 1 if padding else 0
+        self.conv1 = nn.Conv2d(3, 256, kernel_size=4, stride=1, padding=3*self.padding)
+        self.conv2 = nn.Conv2d(256, 512, kernel_size=4, stride=1, padding=3*self.padding)
+        self.conv3 = nn.Conv2d(512, 512, kernel_size=1, stride=1, padding=0)
+        self.conv4 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1*self.padding)
+        self.conv5 = nn.Conv2d(512, self.out_dim*2, kernel_size=4, stride=1, padding=0)
+        self.conv6 = nn.Conv2d(self.out_dim*2, self.out_dim*2, kernel_size=1, stride=1, padding=0)
+        self.avgpool1 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1*self.padding)
+        self.avgpool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1*self.padding)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(x)
+        x = self.avgpool1(x)
+        x = self.conv2(x)
+        x = F.relu(x)
+        x = self.avgpool2(x)
+        x = self.conv3(x)
+        x = F.relu(x)
+        x = self.conv4(x)
+        x = F.relu(x)
+        x = self.conv5(x)
+        x = F.relu(x)
+        x = self.conv6(x)
+        # x = F.relu(x)
+        x = F.interpolate(x, size=self.st_size, mode='bilinear', align_corners=False)
+        st = x[:,:self.out_dim]
+        ae = x[:,self.out_dim:]
+        return st,ae
+
+
+class LocalStudent(nn.Module):
+
+    def __init__(self, out_dim=512,feat_size=64,padding=False):
+        super().__init__()
+        self.out_dim = out_dim
+        self.feat_size = feat_size
+        self.padding = 1 if padding else 0
+        self.conv1 = nn.Conv2d(3, 256, kernel_size=4, stride=1, padding=3*self.padding)
+        self.conv2 = nn.Conv2d(256, 512, kernel_size=4, stride=1, padding=3*self.padding)
+        self.conv3 = nn.Conv2d(512, 512, kernel_size=1, stride=1, padding=0)
+        self.conv4 = nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1*self.padding)
+        self.conv5 = nn.Conv2d(512, self.out_dim, kernel_size=4, stride=1, padding=0)
+        # self.conv6 = nn.Conv2d(self.out_dim, self.out_dim, kernel_size=1, stride=1, padding=0)
+
+        self.avgpool1 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1*self.padding)
+        self.avgpool2 = nn.AvgPool2d(kernel_size=2, stride=2, padding=1*self.padding)
+
+        self.conv_st = nn.Conv2d(self.out_dim, self.out_dim, kernel_size=1, stride=1, padding=0)
+        self.conv_ae = nn.Conv2d(self.out_dim, self.out_dim, kernel_size=1, stride=1, padding=0)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = F.relu(x)
+        x = self.avgpool1(x)
+        x = self.conv2(x)
+        x = F.relu(x)
+        x = self.avgpool2(x)
+        x = self.conv3(x)
+        x = F.relu(x)
+        x = self.conv4(x)
+        x = F.relu(x)
+        x = self.conv5(x)
+        x = F.relu(x)
+        x = F.interpolate(x, size=self.feat_size, mode='bilinear', align_corners=False)
+        st = self.conv_st(x)
+        ae = self.conv_ae(x)
+        return st,ae
+
+
+
+class AutoEncoder(nn.Module):
+    def __init__(self, out_size=64,out_dim=512,base_dim=64):
+        super().__init__()
+        self.out_dim = out_dim
+        self.base_dim = base_dim
+        self.out_size = out_size
+
+        self.enconv1 = nn.Conv2d(3, self.base_dim//2, kernel_size=4, stride=2, padding=1)
+        self.enconv2 = nn.Conv2d(self.base_dim//2, self.base_dim//2, kernel_size=4, stride=2, padding=1)
+        self.enconv3 = nn.Conv2d(self.base_dim//2, self.base_dim, kernel_size=4, stride=2, padding=1)
+        self.enconv4 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=2, padding=1)
+        self.enconv5 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=2, padding=1)
+        self.enconv6 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=8, stride=1, padding=0)
+
+        self.deconv1 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv2 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv3 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv4 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv5 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv6 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=4, stride=1, padding=2)
+        self.deconv7 = nn.Conv2d(self.base_dim, self.base_dim, kernel_size=3, stride=1, padding=1)
+        self.deconv8 = nn.Conv2d(self.base_dim, self.out_dim, kernel_size=3, stride=1, padding=1)
+        self.dropout1 = nn.Dropout(p=0.2)
+        self.dropout2 = nn.Dropout(p=0.2)
+        self.dropout3 = nn.Dropout(p=0.2)
+        self.dropout4 = nn.Dropout(p=0.2)
+        self.dropout5 = nn.Dropout(p=0.2)
+        self.dropout6 = nn.Dropout(p=0.2)
+
+
+    def forward(self, x):
+        x1 = F.relu(self.enconv1(x))
+        x2 = F.relu(self.enconv2(x1))
+        x3 = F.relu(self.enconv3(x2))
+        x4 = F.relu(self.enconv4(x3))
+        x5 = F.relu(self.enconv5(x4))
+        x6 = self.enconv6(x5)
+
+        x = F.interpolate(x6, size=3, mode='bilinear')
+        x = F.relu(self.deconv1(x))
+        x = self.dropout1(x)
+        x = F.interpolate(x, size=8, mode='bilinear')
+        x = F.relu(self.deconv2(x))
+        x = self.dropout2(x)
+        x = F.interpolate(x, size=15, mode='bilinear')
+        x = F.relu(self.deconv3(x))
+        x = self.dropout3(x)
+        x = F.interpolate(x, size=32, mode='bilinear')
+        x = F.relu(self.deconv4(x))
+        x = self.dropout4(x)
+        x = F.interpolate(x, size=63, mode='bilinear')
+        x = F.relu(self.deconv5(x))
+        x = self.dropout5(x)
+        x = F.interpolate(x, size=127, mode='bilinear')
+        x = F.relu(self.deconv6(x))
+        x = self.dropout6(x)
+        x = F.interpolate(x, size=self.out_size, mode='bilinear')
+        x = F.relu(self.deconv7(x))
+        x = self.deconv8(x)
+        return x
+
+class ResNetTeacher(nn.Module):
+    def __init__(self,out_dim=512,feat_size=64):
+        super().__init__()
+        # hf_hub:timm/wide_resnet50_2.tv2_in1k
+        # hf_hub:timm/wide_resnet50_2.racm_in1k
+        self.encoder = timm.create_model('hf_hub:timm/wide_resnet50_2.tv2_in1k'
+                                          ,pretrained=True,
+                                          features_only=True,
+                                          out_indices=[2,3])
+        for param in self.encoder.parameters():
+            param.requires_grad = False
+        self.encoder.eval()
+        self.out_dim = out_dim
+        self.feat_size = feat_size
+        self.proj = nn.Conv2d(1024+512, self.out_dim, kernel_size=1, stride=1, padding=0)
+        self.proj.requires_grad_(False)
+
+    def forward(self, x):
+        x = self.encoder(x)
+        concat_feat = []
+        for i in range(len(x)):
+            feat = x[i]
+            feat = F.interpolate(feat, size=self.feat_size, mode='bilinear',align_corners=False)
+            concat_feat.append(feat)
+        concat_feat = torch.cat(concat_feat,dim=1)
+        concat_feat = nn.AvgPool2d(kernel_size=3, stride=1, padding=1)(concat_feat)
+        proj_feat = self.proj(concat_feat)
+        return proj_feat
+
+
+
+
+if __name__ == '__main__':
+
+    import torch
+    import torchsummary
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    model = AutoEncoder(
+        out_size=64,
+        out_dim=512,
+        base_dim=64,
+        input_size=256
+    ).cuda()
+    torchsummary.summary(model, (3, 256, 256))
+

anofit/_vendor/models/__init__.py

@@ -0,0 +1 @@
+"""벤더링된 CSAD 논리부(patch-hist) — schad 자립용. 원본: modules/csad."""

anofit/_vendor/models/segmentation/__init__.py

@@ -0,0 +1 @@
+"""벤더링된 CSAD segmentation 모델(Segmentor) — schad 논리부용."""