Upload 10 files

tools/config.py

@@ -0,0 +1,160 @@
+import json
+from dataclasses import dataclass, field
+import os
+import cv2
+from datetime import datetime
+
+# JSON 파일에 저장된 통계정보의 구조와 동일한 필드를 갖는 dataclass들
+@dataclass(frozen=True)
+class StatConfig:
+    mean: float
+    std: float
+    min: float
+    max: float
+
+@dataclass(frozen=True)
+class ResistanceStats:
+    # 각 layer별 통계와 전체 통계를 포함합니다.
+    layers: dict = field(default_factory=dict)  # 예: {"m8": StatConfig, "via56": StatConfig, ...}
+    total: StatConfig = None
+
+@dataclass(frozen=True)
+class Config:
+    resolution: tuple = (256, 256)
+    interpolation: int = cv2.INTER_AREA
+    ir_drop: StatConfig = None
+    current: StatConfig = None
+    pad: StatConfig = None
+    pdn_density: StatConfig = None
+    resistances: ResistanceStats = None
+    conductance: dict = field(default_factory=dict)
+    comprehensive_feature: dict = field(default_factory=dict)
+    meta: dict = field(default_factory=dict)
+
+def map_json_to_config(json_data):
+    stats = json_data.get("stats", {})
+    meta = json_data.get("meta", {})
+
+    def create_stat(stat_dict):
+        if not stat_dict or stat_dict.get("mean") is None:
+            return None
+        return StatConfig(
+            mean=stat_dict["mean"],
+            std=stat_dict["std"],
+            min=stat_dict["min"],
+            max=stat_dict["max"]
+        )
+
+    # core stats
+    ir_drop_cfg = create_stat(stats.get("ir_drop"))
+    current_cfg = create_stat(stats.get("current"))
+    pad_cfg = create_stat(stats.get("pad"))
+    pdn_density_cfg = create_stat(stats.get("pdn_density"))
+
+    # resistance stats
+    res_stats = stats.get("resistance", {})
+    layers_cfg = {k: create_stat(v) for k, v in res_stats.get("layers", {}).items()}
+    total_cfg = create_stat(res_stats.get("total"))
+    resistance_cfg = ResistanceStats(layers=layers_cfg, total=total_cfg)
+
+    # conductance stats
+    cond_cfg = {k: create_stat(v) for k, v in stats.get("conductance", {}).items()}
+
+    # comprehensive_feature stats (channels indexed as strings)
+    comp_cfg = {}
+    for k, v in stats.get("comprehensive_feature", {}).items():
+        # k may be index or name, preserve as str
+        comp_cfg[str(k)] = create_stat(v)
+
+    return Config(
+        resolution=tuple(meta.get('resolution', (256,256))),
+        interpolation=cv2.INTER_AREA,
+        ir_drop=ir_drop_cfg,
+        current=current_cfg,
+        pad=pad_cfg,
+        pdn_density=pdn_density_cfg,
+        resistances=resistance_cfg,
+        conductance=cond_cfg,
+        comprehensive_feature=comp_cfg,
+        meta=meta
+    )
+
+def get_config(unit=None, configs_path="/IR_Drop_prior_study/XICCAD/configs", dataset_name='began_iccad_fake'):
+    if configs_path.lower().endswith('.json'):
+        config_json_path = configs_path
+    else:
+        config_json_path = os.path.join(configs_path, dataset_name, f'stats_{unit}.json')
+    with open(config_json_path, "r") as f:
+        json_data = json.load(f)
+    return map_json_to_config(json_data)
+
+# 출력 예시
+if __name__ == "__main__":
+    config = get_config('1um',configs_path='/workspace/IR_Drop_prior_study/XICCAD/configs/test/began_iccad_all/stats_384x384.json',dataset_name='began_iccad_all')
+    
+    print("IR Drop 통계:")
+    if config.ir_drop:
+        print(f"  평균: {config.ir_drop.mean:.8f}")
+        print(f"  표준편차: {config.ir_drop.std:.8f}")
+        print(f"  최소값: {config.ir_drop.min:.8f}")
+        print(f"  최대값: {config.ir_drop.max:.8f}")
+    else:
+        print("  데이터 없음.")
+    
+    print("\nCurrent 통계:")
+    if config.current:
+        print(f"  평균: {config.current.mean:.8f}")
+        print(f"  표준편차: {config.current.std:.8f}")
+        print(f"  최소값: {config.current.min:.8f}")
+        print(f"  최대값: {config.current.max:.8f}")
+    else:
+        print("  데이터 없음.")
+    
+    print("\nPad 통계:")
+    if config.pad:
+        print(f"  평균: {config.pad.mean:.8f}")
+        print(f"  표준편차: {config.pad.std:.8f}")
+        print(f"  최소값: {config.pad.min:.8f}")
+        print(f"  최대값: {config.pad.max:.8f}")
+    else:
+        print("  데이터 없음.")
+    
+    print("\nResistance 전체 통계:")
+    if config.resistances and config.resistances.total:
+        print(f"  평균: {config.resistances.total.mean:.8f}")
+        print(f"  표준편차: {config.resistances.total.std:.8f}")
+        print(f"  최소값: {config.resistances.total.min:.8f}")
+        print(f"  최대값: {config.resistances.total.max:.8f}")
+    else:
+        print("  데이터 없음.")
+    
+    print("\nResistance Layer별 통계:")
+    if config.resistances and config.resistances.layers:
+        for layer, stat in config.resistances.layers.items():
+            print(f"Layer {layer}:")
+            print(f"  평균: {stat.mean:.8f}")
+            print(f"  표준편차: {stat.std:.8f}")
+            print(f"  최소값: {stat.min:.8f}")
+            print(f"  최대값: {stat.max:.8f}")
+    else:
+        print("  데이터 없음.")
+    
+    print("\nConductance 통계:")
+    if config.conductance:
+        for key, stat in config.conductance.items():
+            print(f"{key}:")
+            if stat:
+                print(f"  평균: {stat.mean:.8f}")
+                print(f"  표준편차: {stat.std:.8f}")
+                print(f"  최소값: {stat.min:.8f}")
+                print(f"  최대값: {stat.max:.8f}")
+            else:
+                print("  데이터 없음.")
+    for ch, sc in config.comprehensive_feature.items():
+        if sc:
+            print(f'  Channel {ch}: mean={sc.mean:.6f}, std={sc.std:.6f}, min={sc.min:.6f}, max={sc.max:.6f}')
+        else:
+            print(f'  Channel {ch}: None')
+
+    else:
+        print("  데이터 없음.")

tools/ir_dataset.py

@@ -0,0 +1,627 @@
+import os
+import cv2
+import pandas as pd
+import numpy as np
+from torch.utils.data import Subset
+from sklearn.model_selection import train_test_split
+import torch
+from torch.utils.data import Dataset
+import glob
+import torch.nn.functional as F
+import albumentations as A
+from albumentations.pytorch import ToTensorV2
+import json
+
+def get_config_key(layer):
+    """
+    Map layer name to config key: 'm1'->'m1', 'm14'->'via14'
+    """
+    num = layer[1:]
+    return f"via{num}" if len(num) >= 2 else layer
+
+class IRDropDataset(Dataset):
+    interpolation_map = {
+        'nearest': cv2.INTER_NEAREST,
+        'bilinear': cv2.INTER_LINEAR,
+        'bicubic': cv2.INTER_CUBIC,
+        'area': cv2.INTER_AREA,
+        'lanczos': cv2.INTER_LANCZOS4
+    }
+
+    def __init__(self,
+                 root_path, selected_folders, target_layers,
+                 img_size=384, post_fix_path='', train=True,
+                 in_ch=None, use_raw=False, return_case=False, seed=1234,
+                 input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                 # --- 피처 사용 여부를 결정하는 플래그들 ---
+                 use_current=False,                      # 1
+                 use_pad_distance=False,                 # 1
+                 use_pdn_density=False,                  # 1
+                 use_resistance=False,                   # 12
+                 use_comprehensive_feature=False,       # 23
+                 use_moran=False,                       # 1
+                 use_geary=False,                       # 1
+                 use_gstar=False,                       # 1
+                 # ------------------------------------
+                 interpolation='bicubic',
+                 asap7=False):
+
+        # 기본 속성 설정
+        self.root_path = root_path
+        self.selected_folders = selected_folders
+        self.target_layers = target_layers if use_resistance else []
+        self.img_size = img_size
+        self.post_fix = post_fix_path
+        self.train = train
+        self.use_raw = use_raw
+        self.return_case = return_case
+        self.input_norm_type = input_norm_type
+        self.target_norm_type = target_norm_type
+        self.conf = norm_config
+        self.asap7 = asap7
+        self.interpolation = self.interpolation_map[interpolation]
+
+        # --- 1. 중앙 집중식 피처 설정 ---
+        self.feature_config = {
+            'current': {'use': use_current, 'pattern': '*current*.npy', 'norm_key': 'current', 'channels': 1},
+            'eff_dist': {'use': use_pad_distance, 'pattern': '*eff_dist*.npy', 'norm_key': 'pad', 'channels': 1},
+            'pdn_density': {'use': use_pdn_density, 'pattern': '*pdn_density*.npy', 'norm_key': 'pdn_density', 'channels': 1},
+            'resistance': {'use': use_resistance, 'pattern': 'layer_data/*{}_resistance*.npy', 'channels': len(self.target_layers)},
+            # ===== (추가) 새로운 피처 설정 =====
+            'moran': {'use': use_moran, 'pattern': f'layer_data/*moran_{self.img_size}_{self.img_size}.npy', 'norm_key': 'moran', 'channels': 1},
+            'geary': {'use': use_geary, 'pattern': f'layer_data/*geary_{self.img_size}_{self.img_size}.npy', 'norm_key': 'geary', 'channels': 1},
+            'gstar': {'use': use_gstar, 'pattern': f'layer_data/*gstar_{self.img_size}_{self.img_size}.npy', 'norm_key': 'gstar', 'channels': 1},
+            # ------------------------------------
+            'comp_feature': {'use': use_comprehensive_feature, 'pattern': f'layer_data/*comprehensive_feature_{self.img_size}*.npy', 'channels': 23},
+        }
+
+        if self.asap7:
+            self.feature_config['eff_dist']['use'] = False
+            self.feature_config['pdn_density']['use'] = False
+        
+        # --- 2. 입력 채널 수 동적 계산 및 검증 ---
+        calculated_in_ch = sum(config['channels'] for config in self.feature_config.values() if config['use'])
+        
+        if in_ch is not None and in_ch != calculated_in_ch:
+            raise ValueError(
+                f"Input channel mismatch! User provided in_ch={in_ch}, but calculated channels from "
+                f"'use_{{feature}}' flags is {calculated_in_ch}."
+            )
+        self.in_ch = calculated_in_ch
+        
+        self.target_pattern = '*voltage*.npy' if self.asap7 else '*ir_drop*.npy'
+        
+        self.transform = A.Compose([
+            A.OneOf([
+                A.HorizontalFlip(p=1), A.VerticalFlip(p=1),
+                A.Rotate(limit=(90, 90), p=1), A.Rotate(limit=(180, 180), p=1),
+                A.Rotate(limit=(270, 270), p=1), A.NoOp(p=1)
+            ], p=1) if self.train else A.NoOp(p=1),
+            ToTensorV2()
+        ], is_check_shapes=False,seed=seed)
+        
+        self.data_files = self._find_files()
+
+    def _find_files(self):
+        file_lists = {key: [] for key, conf in self.feature_config.items() if conf['use']}
+        file_lists['target'] = []
+        if self.feature_config['resistance']['use']:
+            file_lists['resistance'] = {ly: [] for ly in self.target_layers}
+
+        for fld in self.selected_folders:
+            base = os.path.join(self.root_path, fld, self.post_fix)
+            if not os.path.isdir(base): continue
+            
+            file_lists['target'] += glob.glob(os.path.join(base, self.target_pattern))
+            
+            for key, config in self.feature_config.items():
+                if not config['use']: continue
+                
+                pattern = config['pattern']
+                if key == 'resistance':
+                    for ly in self.target_layers:
+                        ly_pattern = pattern.format(ly)
+                        file_lists['resistance'][ly] += glob.glob(os.path.join(base, ly_pattern))
+                else:
+                    file_lists[key] += glob.glob(os.path.join(base, pattern))
+
+        for key, item in file_lists.items():
+            if isinstance(item, list): item.sort()
+            elif isinstance(item, dict):
+                for sub_item in item.values(): sub_item.sort()
+
+        n = len(file_lists['target'])
+        if n == 0:
+            print(f"Warning: No target files found in provided folders: {self.selected_folders}")
+            return []
+
+        for key, item in file_lists.items():
+            if not self.feature_config.get(key, {}).get('use', True): continue
+            
+            if key == 'resistance':
+                for ly, files in item.items():
+                    if len(files) != n: raise ValueError(f"Mismatch in file counts for resistance layer '{ly}'. Expected {n}, got {len(files)}!")
+            elif len(item) != n:
+                 raise ValueError(f"Mismatch in file counts for feature '{key}'. Expected {n}, got {len(item)}!")
+
+        data_entries = []
+        for i in range(n):
+            entry = {'target': file_lists['target'][i]}
+            for key, config in self.feature_config.items():
+                if not config['use']: continue
+                if key == 'resistance':
+                    entry[key] = {ly: file_lists[key][ly][i] for ly in self.target_layers}
+                else:
+                    entry[key] = file_lists[key][i]
+            data_entries.append(entry)
+            
+        return data_entries
+
+    def _load_data_from_disk(self, idx):
+        f_paths = self.data_files[idx]
+        channels_to_stack = []
+        
+        # 물리적/기본 피처 로드
+        for key in ['current', 'eff_dist', 'pdn_density', 'resistance']:
+             if self.feature_config[key]['use']:
+                if key == 'resistance':
+                    for ly in self.target_layers:
+                        channels_to_stack.append((np.load(f_paths[key][ly]), get_config_key(ly)))
+                else:
+                    channels_to_stack.append((np.load(f_paths[key]), self.feature_config[key]['norm_key']))
+        
+        for key in ['moran', 'geary', 'gstar']:
+            if self.feature_config[key]['use']:
+                #  print(np.load(f_paths[key]).shape) # 1, H, W
+                 channels_to_stack.append((np.load(f_paths[key])[0], self.feature_config[key]['norm_key']))
+        # ------------------------------------------
+
+        if self.feature_config['comp_feature']['use']:
+            comp_data = np.load(f_paths['comp_feature'])
+            for c in range(comp_data.shape[-1]):
+                channels_to_stack.append((comp_data[..., c], f'comp_{c}'))
+
+        processed_channels = []
+        for data, norm_key in channels_to_stack:
+            resized_data = cv2.resize(data, (self.img_size, self.img_size), interpolation=self.interpolation)
+            normalized_data = self.normalize_input(resized_data, norm_key)
+            processed_channels.append(normalized_data)
+            
+        input_data = np.stack(processed_channels, axis=-1)
+        target_data = np.load(f_paths['target'])
+        
+        return input_data, target_data
+
+    def __getitem__(self, idx):
+        inp, tgt = self._load_data_from_disk(idx)
+        
+        if not self.use_raw:
+            ir_resized = cv2.resize(tgt, (self.img_size, self.img_size), interpolation=self.interpolation)
+            target = self.normalize_target(ir_resized)
+            transformed = self.transform(image=inp, mask=target)
+            y = transformed['mask'].unsqueeze(0).float()
+        else:
+            target = tgt
+            transformed = self.transform(image=inp)
+            y = torch.as_tensor(target).unsqueeze(0).float()
+            
+        x = transformed['image'].float()
+        
+        if self.return_case:
+            case_path = self.data_files[idx]['target']
+            tc_name = next((p for p in case_path.split('/') if 'case' in p), os.path.basename(case_path))
+            return x, y, tc_name
+            
+        return x, y
+
+    def __len__(self):
+        return len(self.data_files)
+
+    def normalize_input(self, data, key):
+        t = self.input_norm_type
+        out = data.astype(np.float32)
+        conf = self.conf
+        if conf is None: return out
+
+        mean, std, max_val = None, None, None
+        
+        if key == 'current':
+            mean, std, max_val = conf.current.mean, conf.current.std, conf.current.max
+        elif key == 'pad':
+            mean, std, max_val = conf.pad.mean, conf.pad.std, conf.pad.max
+        elif key == 'pdn_density':
+            mean, std, max_val = conf.pdn_density.mean, conf.pdn_density.std, conf.pdn_density.max
+        elif key.startswith('via') or key.startswith('m'):
+            if hasattr(conf, 'resistances') and conf.resistances and key in conf.resistances.layers:
+                layer_conf = conf.resistances.layers[key]
+                if layer_conf: mean, std, max_val = layer_conf.mean, layer_conf.std, layer_conf.max
+        # ===== (추가) 새로운 피처 정규화 로직 =====
+        elif key in ['moran', 'geary', 'gstar']:
+            if hasattr(conf, key):
+                feature_conf_dict = getattr(conf, key)
+                # 통계 파일 구조가 {'0': {'mean': ...}} 형태이므로 '0' 키로 접근
+                if '0' in feature_conf_dict and feature_conf_dict['0']:
+                    stat_conf = feature_conf_dict['0']
+                    mean, std, max_val = stat_conf.mean, stat_conf.std, stat_conf.max
+        # ------------------------------------------
+        elif key.startswith('comp_'):
+            idx = key.split('_')[1]
+            if hasattr(conf, 'comprehensive_feature') and idx in conf.comprehensive_feature:
+                comp_conf = conf.comprehensive_feature[idx]
+                if comp_conf: mean, std, max_val = comp_conf.mean, comp_conf.std, comp_conf.max
+
+        if t in ['global_max', 'g_max']:
+            if max_val and max_val > 0: out /= max_val
+        elif t in ['max', 'sample_max']:
+            m = out.max()
+            if m != 0: out /= m
+        elif t == 'min_max':
+            mi, ma = out.min(), out.max()
+            if ma != mi: out = (out - mi) / (ma - mi)
+            else: out = out - mi
+        elif t == 'z_score':
+            if mean is not None and std is not None and std > 0:
+                out = (out - mean) / std
+        return out
+
+    def normalize_target(self, tgt):
+        t = self.target_norm_type
+        out = tgt.astype(np.float32)
+        if self.conf is None or not hasattr(self.conf, 'ir_drop') or self.conf.ir_drop is None: return out
+        
+        if t in ['global_max','g_max']:
+            if self.conf.ir_drop.max > 0: out /= self.conf.ir_drop.max
+        elif t in ['max','sample_max']:
+            m = out.max()
+            if m != 0: out /= m
+        elif t=='min_max':
+            mi, ma = out.min(), out.max()
+            if ma != mi: out = (out-mi)/(ma-mi)
+            else: out = out-mi
+        elif t=='z_score':
+            mean, std = self.conf.ir_drop.mean, self.conf.ir_drop.std
+            if std and std>0: out = (out - mean) / std
+        elif t in ['raw','1000']:
+            out *= 1e3
+        return out
+        
+    def get_stat_from_conf(self, feature, stat_type='max', layer_key=None):
+        conf = self.conf
+        if feature=='ir_drop': return getattr(conf.ir_drop, stat_type, None)
+        if feature=='current': return getattr(conf.current, stat_type, None)
+        if feature in ['pad','pad_distance']: return getattr(conf.pad, stat_type, None)
+        if feature=='pdn_density': return getattr(conf.pdn_density, stat_type, None)
+        if feature=='resistance' and layer_key:
+            return getattr(conf.resistances.layers.get(layer_key), stat_type, None)
+        return None
+
+    def inverse_torch(self, x, norm_type, t_min=None, t_max=None):
+        if norm_type in ['global_max', 'g_max']:
+            max_val = self.get_stat_from_conf('ir_drop', 'max')
+            return x * max_val if max_val is not None else x
+        elif norm_type in ['global_max_log', 'g_max_log']:
+            max_val = self.get_stat_from_conf('ir_drop', 'max')
+            return (torch.exp(x) - 1.3) * max_val if max_val is not None else x
+        elif norm_type in ['global_max_log_div', 'g_max_log_div']:
+            max_val = self.get_stat_from_conf('ir_drop', 'max')
+            eps = 1e-6
+            return torch.exp(torch.log(torch.tensor(max_val + eps,device=x.device)) / (x + eps)) - eps if max_val is not None else x
+        elif norm_type in ['z_score']:
+            mean_val = self.get_stat_from_conf('ir_drop', 'mean')
+            std_val = self.get_stat_from_conf('ir_drop', 'std')
+            return x * std_val + mean_val if std_val is not None else x
+        elif norm_type in ['min_max', 'sample_min_max']:
+            return x  * (t_max - t_min) + t_min if t_min is not None and t_max is not None else x
+        elif norm_type in ['raw', '1000']:
+            return x *1e-3
+        else:
+            print('Inverse normalization not implemented for norm type:', norm_type)
+            return x
+
+#################################################################################################################
+def tensor_to_numpy(t: torch.Tensor) -> np.ndarray:
+    return t.detach().cpu().numpy()
+
+def numpy_to_tensor(n: np.ndarray) -> torch.Tensor:
+    return torch.from_numpy(n).float()
+
+def resize_tensor_cv2(tensor: torch.Tensor, target_size: tuple) -> torch.Tensor:
+    """
+    Resize each (C, H, W) in tensor using cv2.INTER_LANCZOS4
+    target_size: (H_out, W_out)
+    """
+    np_tensor = tensor_to_numpy(tensor)
+    resized = []
+    for img in np_tensor:  # img: (C, H, W)
+        resized_channels = []
+        for c in img:
+            resized_c = cv2.resize(c, (target_size[1], target_size[0]), interpolation=cv2.INTER_LANCZOS4)
+            resized_channels.append(resized_c)
+        resized.append(np.stack(resized_channels, axis=0))
+    resized_np = np.stack(resized, axis=0)  # (B, C, H, W)
+    return numpy_to_tensor(resized_np).to(tensor.device)
+################################################################################################################
+
+
+def split_train_val(td,vd, train_ratio=0.8, random_state=42):
+    dataset_size = len(td)
+    
+    indices = list(range(dataset_size))
+    
+    train_size = int(train_ratio * dataset_size)
+    train_indices, valid_indices = train_test_split(indices, train_size=train_size, random_state=random_state)
+    
+    train_dataset = Subset(td, train_indices)
+    valid_dataset = Subset(vd, valid_indices)
+
+    return train_dataset, valid_dataset
+
+#################################################################################################################
+
+def build_dataset_began_iccad_fake(root_path='', img_size=384, train=True,
+                                    in_ch=25, use_raw=False,return_case=False,
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   use_pdn_density=False,use_comprehensive_feature=False,
+                                   selected_folders=[
+                                        '/data/BeGAN-circuit-benchmarks/nangate45/set1_numpy/data',
+                                        '/data/BeGAN-circuit-benchmarks/nangate45/set2_numpy/data',
+                                        '/data/ICCAD_2023/fake-circuit-data_20230623/fake-circuit-data-npy'
+                                    ],**kwargs):
+    train_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=True,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=False,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature,
+        **kwargs
+    )
+
+    val_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=False,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature,
+        **kwargs
+    )
+    print("Dataset length:", len(train_dataset))
+    return split_train_val(train_dataset,val_dataset)
+
+def build_dataset_began(root_path='', img_size=384, train=True,
+                                    in_ch=12, use_raw=False,return_case=False,
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   use_pdn_density=False,use_comprehensive_feature=False,
+                                   selected_folders=[
+                                        '/data/BeGAN-circuit-benchmarks/nangate45/set1_numpy/data',
+                                        '/data/BeGAN-circuit-benchmarks/nangate45/set2_numpy/data',
+                                    ],**kwargs):
+    val_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=False,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature
+    )
+    print("Dataset length:", len(val_dataset))
+    return val_dataset
+
+def build_dataset_iccad_real(root_path='/data/ICCAD_2023/real-circuit-data_20230615', img_size=384, train=True,
+                                    in_ch=25, use_raw=False, return_case = False,interpolation='bicubic',
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   use_pdn_density=False,use_comprehensive_feature=False,**kwargs):
+    selected_folders = os.listdir(root_path)
+    dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=train,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,  
+        return_case = return_case,
+        use_pdn_density=use_pdn_density,
+        use_pad_distance=kwargs.get('use_pad_distance',False),
+        use_comprehensive_feature=use_comprehensive_feature,
+        interpolation=interpolation
+    )
+    print("Dataset length of iccad-real :", len(dataset))
+    return dataset
+
+def build_dataset_iccad_hidden(root_path='/data/ICCAD_2023/hidden-real-circuit-data', img_size=384, train=False,
+                                    in_ch=12, use_raw=False, return_case=False,
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   interpolation='area',
+                                   use_pdn_density=False,use_comprehensive_feature=False,**kwargs):
+    selected_folders = os.listdir(root_path)
+    dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=False,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,  
+        return_case = return_case,
+        use_pdn_density=use_pdn_density,
+        use_pad_distance=kwargs.get('use_pad_distance',False),
+        use_comprehensive_feature=use_comprehensive_feature,
+        interpolation=interpolation
+    )
+    print("Dataset length of iccad-hidden:", len(dataset))
+    return dataset
+
+def build_dataset_iccad_fake(root_path='', img_size=384, train=True,
+                                    in_ch=25, use_raw=False,return_case=False,
+                                    target_layers=['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   use_pdn_density=False, use_comprehensive_feature=False,**kwargs):
+    train_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=[
+            '/data/ICCAD_2023/fake-circuit-data_20230623/fake-circuit-data-npy'
+        ],
+        img_size=img_size,
+        train=True,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=False,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature
+    )
+
+    val_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=[
+            '/data/ICCAD_2023/fake-circuit-data_20230623/fake-circuit-data-npy'
+        ],
+        img_size=img_size,
+        train=False,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config  ,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature
+    )
+    print("Dataset length:", len(train_dataset))
+    return split_train_val(train_dataset,val_dataset)
+
+
+def build_dataset_began_iccad_fake_real(root_path='', img_size=384, train=True,
+                                    in_ch=25, use_raw=False, use_raw_target=False,return_case=False,
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='z_score', target_norm_type='raw', norm_config=None,
+                                   interpolation='bicubic',
+                                   use_pdn_density=False,use_comprehensive_feature=False,**kwargs):
+    train_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=[
+            '/data/BeGAN-circuit-benchmarks/nangate45/set1_numpy/data',
+            '/data/BeGAN-circuit-benchmarks/nangate45/set2_numpy/data',
+            '/data/ICCAD_2023/fake-circuit-data_20230623/fake-circuit-data-npy'
+        ],
+        img_size=img_size,
+        train=train,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw_target,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature,
+        interpolation=interpolation
+    )
+
+    root_path='/data/ICCAD_2023/real-circuit-data_20230615'
+    selected_folders = os.listdir(root_path)
+    val_dataset = IRDropDataset(
+        root_path=root_path,
+        selected_folders=selected_folders,
+        img_size=img_size,
+        train=False,
+        target_layers=target_layers,
+        in_ch=in_ch,
+        use_raw=use_raw,
+        input_norm_type=input_norm_type,
+        target_norm_type=target_norm_type,
+        norm_config=norm_config,  
+        return_case = return_case,
+        use_pdn_density=use_pdn_density,
+        use_comprehensive_feature=use_comprehensive_feature,
+        interpolation=interpolation
+    )
+    print("Dataset length of iccad-real :", len(val_dataset))
+    print("Dataset length of began-iccad-fake :", len(train_dataset))
+    return train_dataset, val_dataset
+
+def build_dataset_began_asap7(root_path='/data/BeGAN-circuit-benchmarks/asap7' , img_size=512, train=True,
+                                    in_ch=12, use_raw=False, use_raw_target=False,return_case=False,
+                                    target_layers= ['m1', 'm4', 'm7', 'm8', 'm9', 'm14', 'm47', 'm78', 'm89'],
+                                   input_norm_type='global_max', target_norm_type='global_max', norm_config=None,
+                                   use_pdn_density=False,use_comprehensive_feature=False):
+    target_layers = ['m2', 'm5', 'm6', 'm7', 'm8', 'm25', 'm56', 'm67', 'm78']
+    dataset = IRDropDataset(
+                root_path=root_path,
+                selected_folders=['BeGAN'],
+                img_size=img_size,
+                train=True,
+                target_layers=target_layers,
+                in_ch=in_ch,
+                use_raw=use_raw_target,
+                input_norm_type=input_norm_type,
+                target_norm_type=target_norm_type,
+                norm_config=norm_config,
+                use_comprehensive_feature=use_comprehensive_feature,
+                asap7=True,
+            )
+    return dataset
+
+if __name__ == '__main__':
+    import sys
+    sys.path.append('/IR_Drop_prior_study/XICCAD')
+    from config import *
+    config_path = "/IR_Drop_prior_study/XICCAD/configs/cfirst/began_iccad_fake/stats_1um.json"
+    with open(config_path, "r") as f:
+        json_data = json.load(f)
+    norm_cfg = map_json_to_config(json_data)
+    def test_began_iccad():
+        ds,_ = build_dataset_began_iccad_fake(
+                                    img_size=512, train=True,
+                                    in_ch=29, use_raw=False,
+                                    input_norm_type='g_max',     
+                                    target_norm_type='g_max',     
+                                    norm_config=norm_cfg,
+                                    target_layers=[],
+                                    use_current=True,                      # 1
+                                    use_pad_distance=True,                 # 1
+                                    use_pdn_density=True,                  # 1
+                                    use_resistance=False,                   # 12
+                                    use_comprehensive_feature=True,       # 23
+                                    use_moran=True,                       # 1
+                                    use_geary=True,                       # 1
+                                    use_gstar=True,                       # 1
+                                    )
+        # ds = build_dataset_began_iccad_fake()
+        for i in range(ds.__len__()):
+            sample_input, sample_target = ds[i]
+            print("Input shape:", sample_input.shape)
+            print("Target shape:", sample_target.shape)
+            if i == 10: break
+    test_began_iccad()

tools/make_samples.py

@@ -0,0 +1,147 @@
+# tools/prepare_samples.py
+"""
+예제:
+    cd waca_unet_space
+    python tools/prepare_samples.py --root /data/ICCAD_2023/hidden-real-circuit-data \
+        --configs_path configs/began_iccad_fake \
+        --dataset iccad_hidden \
+        --indices 0 1 2 3 4
+
+- build_dataset_iccad_hidden / build_dataset_iccad_real 을 이용해서
+  (input, target, casename)을 가져온 뒤, input만 samples/ 폴더에 저장.
+- input은 IRDropDataset에서 반환하는 (C,H,W) 텐서(정규화 완료)를 그대로 npy로 저장.
+"""
+import os
+import argparse
+import numpy as np
+import torch
+
+from config import get_config
+from ir_dataset import (
+    build_dataset_iccad_hidden,
+    build_dataset_iccad_real,
+)
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument(
+        "--root",
+        type=str,
+        help="ICCAD hidden/real root path. 예: /data/ICCAD_2023/hidden-real-circuit-data or /data/ICCAD_2023/real-circuit-data",
+        default='/data/ICCAD_2023/hidden-real-circuit-data',
+    )
+    p.add_argument(
+        "--dataset",
+        type=str,
+        choices=["iccad_hidden", "iccad_real"],
+        default="iccad_real",
+    )
+    p.add_argument(
+        "--img_size",
+        type=int,
+        default=384,
+    )
+    p.add_argument(
+        "--in_ch",
+        type=int,
+        default=25,
+    )
+    p.add_argument(
+        "--configs_path",
+        type=str,
+        default="/workspace/IR_Drop_prior_study/XICCAD/configs/cfirst/began_iccad_fake/stats_1um.json",
+        help="stats_1um.json 이 들어있는 폴더",
+    )
+    p.add_argument(
+        "--unit",
+        type=str,
+        default="1um",
+    )
+    p.add_argument(
+        "--indices",
+        type=int,
+        nargs="+",
+        default=[0, 1, 2, 3, 4],
+        help="예제 샘플로 뽑을 dataset 인덱스들",
+    )
+    p.add_argument(
+        "--out_dir",
+        type=str,
+        default="samples",
+        help="npy를 저장할 디렉토리",
+    )
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    # 학습 때 쓰던 통계 config 로드 (당신의 get_config 시그니처에 맞게 조정)
+    norm_config = get_config(
+        args.unit,
+        configs_path=args.configs_path,
+        dataset_name="began_iccad_fake",
+    )
+
+    common_kwargs = dict(
+        img_size=args.img_size,
+        in_ch=args.in_ch,
+        train=False,
+        use_raw=False,              # 학습 때와 동일하게 z-score 등으로 정규화된 입력 사용
+        input_norm_type="z_score",
+        target_norm_type="raw",
+        target_layers=[],           # 전체 종합 IR-drop (이미 npy에 통합된 경우)
+        use_pdn_density=True,
+        use_pad_distance=True,
+        use_comprehensive_feature=True,
+        norm_config=norm_config,
+        return_case=True,           # (x, y, casename) 반환
+        interpolation="lanczos",
+    )
+
+    if args.dataset == "iccad_hidden":
+        dataset = build_dataset_iccad_hidden(
+            root_path=args.root,
+            **common_kwargs,
+        )
+    else:
+        dataset = build_dataset_iccad_real(
+            root_path=args.root,
+            **common_kwargs,
+        )
+
+    # build_dataset_* 가 (train,val) 튜플을 반환하는 경우 대응
+    if isinstance(dataset, (tuple, list)) and len(dataset) == 2:
+        dataset = dataset[1]  # val set을 예제로 사용하거나, 필요에 따라 수정
+
+    print(f"Dataset length: {len(dataset)}")
+
+    for idx in args.indices:
+        if idx >= len(dataset):
+            print(f"[WARN] index {idx} is out of range, skip.")
+            continue
+
+        sample = dataset[idx]
+        if len(sample) == 3:
+            x, y, casename = sample
+        else:
+            x, y = sample
+            casename = f"idx{idx}"
+
+        if isinstance(x, torch.Tensor):
+            x_np = x.detach().cpu().numpy()
+        else:
+            x_np = np.asarray(x)
+
+        out_name = f"{casename}_input.npy"
+        out_path = os.path.join(args.out_dir, out_name)
+        np.save(out_path, x_np)
+        print(f"Saved: {out_path} (shape={x_np.shape})")
+
+    print("Done.")
+
+
+if __name__ == "__main__":
+    main()

tools/samples/testcase10_input.npy

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

tools/samples/testcase13_input.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04064bde7d4bafbcaffdeb8e040eedca5a542d087a83e57cddf3d41fcd6c1cbe
+size 14745728

tools/samples/testcase14_input.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5bad9477a3ab46e1980159f777627ac9dd8617af2e89e843969fa6011476b613
+size 14745728

tools/samples/testcase15_input.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:019f54b8d4ffd73a39445192869822a365e84b48ecdb1b55cc6c44f655a22d70
+size 14745728

tools/samples/testcase16_input.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84ffeaf88986476046f0bb77dd6daaea77729164eb18d75f2a66345066c2b4b1
+size 14745728