diff --git a/PyTorch/build-in/Classification/SWSL/readme.md b/PyTorch/build-in/Classification/SWSL/readme.md
new file mode 100644
index 000000000..ad9ed2797
--- /dev/null
+++ b/PyTorch/build-in/Classification/SWSL/readme.md
@@ -0,0 +1,65 @@
+```markdown
+## 1. 模型链接
+- 原始仓库链接：
+https://github.com/huggingface/pytorch-image-models?tab=readme-ov-file#models
+
+## 2. 快速开始
+
+使用本模型执行训练的主要流程如下：
+
+1. **基础环境安装**：介绍训练前需要完成的基础环境检查和安装。
+2. **获取数据集**：介绍如何获取训练所需的数据集。
+3. **构建环境**：介绍如何构建模型运行所需要的环境。
+4. **启动训练**：介绍如何运行训练。
+
+### 2.1 基础环境安装
+
+请参考主仓库的基础环境安装章节，完成训练前的基础环境检查和安装（如驱动、固件等）。
+
+### 2.2 准备数据集
+
+#### 2.2.1 获取数据集
+
+训练使用 **CIFAR-100** 数据集。该数据集为开源数据集，包含 100 个类别的 60000 张彩色图像。
+
+#### 2.2.2 处理数据集
+
+请确保数据集已下载并解压。根据训练脚本的默认配置，建议将数据集存放在模型目录的上级 `data` 目录中（即 `../data`），或者根据实际路径修改训练命令中的 `--datapath` 参数。
+
+### 2.3 构建环境
+
+所使用的环境下需包含 PyTorch 框架虚拟环境。
+
+1. 执行以下命令，启动虚拟环境（根据实际环境名称修改）：
+
+   ```bash
+   conda activate torch_env_py310
+
+```
+
+2. 安装 Python 依赖。确保已安装项目所需的依赖包：
+```bash
+pip install -r requirements_exact.txt
+
+```
+
+
+
+### 2.4 启动训练
+
+1. 在构建好的环境中，进入模型训练脚本所在目录。
+
+2. 运行训练。该模型支持单机单卡训练。
+执行以下命令启动训练（使用 CIFAR-100 数据集，Batch Size 为 128）：
+```bash
+python weloTrainStep.py \
+        --name train \
+        --arch swsl \
+        --print_freq 1 \
+        --steps 100 \
+        --dataset cifar100 \
+        --datapath ../data \
+        --batch_size 16 \
+        --epochs 100
+
+```
diff --git a/PyTorch/build-in/Classification/SWSL/requirements.txt b/PyTorch/build-in/Classification/SWSL/requirements.txt
new file mode 100644
index 000000000..7394b3319
--- /dev/null
+++ b/PyTorch/build-in/Classification/SWSL/requirements.txt
@@ -0,0 +1,89 @@
+addict==2.4.0
+aliyun-python-sdk-core==2.16.0
+aliyun-python-sdk-kms==2.16.5
+anyio==4.11.0
+astunparse==1.6.3
+certifi==2024.12.14
+cffi==2.0.0
+charset-normalizer==3.4.1
+click==8.3.1
+colorama==0.4.6
+contourpy==1.3.2
+crcmod==1.7
+cryptography==46.0.3
+cycler==0.12.1
+einops==0.8.1
+exceptiongroup==1.3.1
+filelock==3.14.0
+fonttools==4.60.1
+fsspec==2024.12.0
+future @ file:///croot/future_1730902796226/work
+git-filter-repo==2.47.0
+h11==0.16.0
+hf-xet==1.2.0
+httpcore==1.0.9
+httpx==0.28.1
+huggingface_hub==1.1.5
+idna==3.10
+inplace-abn @ git+https://github.com/mapillary/inplace_abn.git@b50bfe9c7cd7116a3ab091a352b48d6ba5ee701c
+Jinja2==3.1.5
+jmespath==0.10.0
+joblib==1.5.2
+kiwisolver==1.4.9
+Markdown==3.10
+markdown-it-py==4.0.0
+MarkupSafe==3.0.2
+matplotlib==3.10.7
+mdurl==0.1.2
+mmdet==3.3.0
+mmengine==0.10.7
+model-index==0.1.11
+mpmath==1.3.0
+networkx==3.4.2
+numpy==1.23.5
+opencv-python==4.12.0.88
+opendatalab==0.0.10
+openmim==0.3.9
+openxlab==0.1.3
+ordered-set==4.1.0
+oss2==2.17.0
+packaging @ file:///croot/packaging_1734472117206/work
+pandas==2.3.3
+pillow==11.1.0
+platformdirs==4.5.1
+pycocotools==2.0.11
+pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work
+pycryptodome==3.23.0
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2023.4
+PyYAML @ file:///croot/pyyaml_1728657952215/work
+requests==2.28.2
+rich==13.4.2
+safetensors==0.7.0
+scikit-learn==1.7.2
+scipy==1.15.3
+shapely==2.1.2
+shellingham==1.5.4
+six @ file:///tmp/build/80754af9/six_1644875935023/work
+sniffio==1.3.1
+sympy==1.13.3
+tabulate==0.9.0
+termcolor==3.2.0
+terminaltables==3.1.10
+threadpoolctl==3.6.0
+timm==1.0.22
+tomli==2.3.0
+torch @ file:///apps/torch-2.4.0a0%2Bgit4451b0e-cp310-cp310-linux_x86_64.whl#sha256=2e472c916044cac5a1a0e0d8b0e12bb943d8522b24ff826c8014dd444dccd378
+torch_sdaa @ file:///apps/torch_sdaa-2.0.0-cp310-cp310-linux_x86_64.whl#sha256=5aa57889b002e1231fbf806642e1353bfa016297bc25178396e89adc2b1f92e7
+torchaudio @ file:///apps/torchaudio-2.0.2%2Bda3eb8d-cp310-cp310-linux_x86_64.whl#sha256=46525c02fb7eaa8dafea860428de3d01e437ba8d6ff2cc228d7c71975ac4054b
+torchdata @ file:///apps/torchdata-0.6.1%2Be1feeb2-py3-none-any.whl#sha256=aa2dc1a7732ea68adfad186978049bf68cc1afdbbdd1e17a8024227ab770e433
+torchtext @ file:///apps/torchtext-0.15.2a0%2B4571036-cp310-cp310-linux_x86_64.whl#sha256=7e42c684ba366f97b59ec37488bf95e416cce3892b6589200d2b3ad159ee5788
+torchvision @ file:///apps/torchvision-0.15.1a0%2B42759b1-cp310-cp310-linux_x86_64.whl#sha256=4b904db2d50102415536bc764bbc31c669b90b1b014f90964e9eccaadb2fd9eb
+tqdm==4.65.2
+typer-slim==0.20.0
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==1.26.20
+yapf==0.43.0
diff --git a/PyTorch/build-in/Classification/SWSL/swslnet.py b/PyTorch/build-in/Classification/SWSL/swslnet.py
new file mode 100644
index 000000000..ad8978fe0
--- /dev/null
+++ b/PyTorch/build-in/Classification/SWSL/swslnet.py
@@ -0,0 +1,181 @@
+"""resnet in pytorch
+[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun.
+    Deep Residual Learning for Image Recognition
+    https://arxiv.org/abs/1512.03385v1
+"""
+
+# reference
+# https://github.com/weiaicunzai/pytorch-cifar100 Thank you.
+import torch
+import torch.nn as nn
+
+
+class BasicBlock(nn.Module):
+    """Basic Block for resnet 18 and resnet 34
+    """
+
+    # BasicBlock and BottleNeck block
+    # have different output size
+    # we use class attribute expansion
+    # to distinct
+    expansion = 1
+
+    def __init__(self, in_channels, out_channels, stride=1):
+        super().__init__()
+
+        # residual function
+        self.residual_function = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels * BasicBlock.expansion, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels * BasicBlock.expansion)
+        )
+
+        # shortcut
+        self.shortcut = nn.Sequential()
+
+        # the shortcut output dimension is not the same with residual function
+        # use 1*1 convolution to match the dimension
+        if stride != 1 or in_channels != BasicBlock.expansion * out_channels:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels * BasicBlock.expansion, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(out_channels * BasicBlock.expansion)
+            )
+
+    def forward(self, x):
+        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))
+
+
+class BottleNeck(nn.Module):
+    """Residual block for resnet over 50 layers
+    """
+    expansion = 4
+
+    def __init__(self, in_channels, out_channels, stride=1):
+        super().__init__()
+        self.residual_function = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels, stride=stride, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels * BottleNeck.expansion, kernel_size=1, bias=False),
+            nn.BatchNorm2d(out_channels * BottleNeck.expansion),
+        )
+
+        self.shortcut = nn.Sequential()
+
+        if stride != 1 or in_channels != out_channels * BottleNeck.expansion:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_channels, out_channels * BottleNeck.expansion, stride=stride, kernel_size=1, bias=False),
+                nn.BatchNorm2d(out_channels * BottleNeck.expansion)
+            )
+
+    def forward(self, x):
+        return nn.ReLU(inplace=True)(self.residual_function(x) + self.shortcut(x))
+
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, num_block, num_classes=100):
+        super().__init__()
+
+        self.in_channels = 64
+
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(3, 64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64),
+            nn.ReLU(inplace=True))
+        # we use a different inputsize than the original paper
+        # so conv2_x's stride is 1
+        self.conv2_x = self._make_layer(block, 64, num_block[0], 1)
+        self.conv3_x = self._make_layer(block, 128, num_block[1], 2)
+        self.conv4_x = self._make_layer(block, 256, num_block[2], 2)
+        self.conv5_x = self._make_layer(block, 512, num_block[3], 2)
+        self.avg_pool = nn.AdaptiveAvgPool2d((1, 1))
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+    def _make_layer(self, block, out_channels, num_blocks, stride):
+        """make resnet layers(by layer i didnt mean this 'layer' was the
+        same as a neuron netowork layer, ex. conv layer), one layer may
+        contain more than one residual block
+        Args:
+            block: block type, basic block or bottle neck block
+            out_channels: output depth channel number of this layer
+            num_blocks: how many blocks per layer
+            stride: the stride of the first block of this layer
+
+        Return:
+            return a resnet layer
+        """
+
+        # we have num_block blocks per layer, the first block
+        # could be 1 or 2, other blocks would always be 1
+        strides = [stride] + [1] * (num_blocks - 1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_channels, out_channels, stride))
+            self.in_channels = out_channels * block.expansion
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        output = self.conv1(x)
+        output = self.conv2_x(output)
+        output = self.conv3_x(output)
+        output = self.conv4_x(output)
+        output = self.conv5_x(output)
+        output = self.avg_pool(output)
+        output = output.view(output.size(0), -1)
+        output = self.fc(output)
+
+        return output
+
+
+def resnet18(num_classes):
+    """ return a ResNet 18 object
+    """
+    return ResNet(BasicBlock, [2, 2, 2, 2],num_classes=num_classes)
+
+
+def resnet34(num_classes):
+    """ return a ResNet 34 object
+    """
+    return ResNet(BasicBlock, [3, 4, 6, 3],num_classes=num_classes)
+
+
+def resnet50(num_classes):
+    """ return a ResNet 50 object
+    """
+    return ResNet(BottleNeck, [3, 4, 6, 3],num_classes=num_classes)
+
+
+def resnet101(num_classes):
+    """ return a ResNet 101 object
+    """
+    return ResNet(BottleNeck, [3, 4, 23, 3],num_classes=num_classes)
+
+
+def resnet152(num_classes):
+    """ return a ResNet 152 object
+    """
+    return ResNet(BottleNeck, [3, 8, 36, 3],num_classes=num_classes)
+
+
+def Model(num_classes=100, model_type='resnet50'):
+    """简洁工厂接口，返回指定 ResNet 模型"""
+    model_map = {
+        'resnet18': resnet18,
+        'resnet34': resnet34,
+        'resnet50': resnet50,
+        'resnet101': resnet101,
+        'resnet152': resnet152,
+    }
+
+    if model_type not in model_map:
+        raise ValueError(f"Unknown model_type: {model_type}")
+
+    # 直接实例化并覆盖 num_classes
+    return model_map[model_type](num_classes=num_classes)
\ No newline at end of file
diff --git a/PyTorch/build-in/Classification/SWSL/weloTrainStep.py b/PyTorch/build-in/Classification/SWSL/weloTrainStep.py
new file mode 100644
index 000000000..b1f5a3944
--- /dev/null
+++ b/PyTorch/build-in/Classification/SWSL/weloTrainStep.py
@@ -0,0 +1,647 @@
+#!/usr/bin/env python3
+# coding: utf-8
+
+import os
+import random
+import sys
+import time
+import json
+import argparse
+from collections import OrderedDict
+from pathlib import Path
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+import importlib
+
+os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"     # 强烈推荐在 shell/最顶端设置
+os.environ["PYTHONHASHSEED"] = "12345"
+os.environ["OMP_NUM_THREADS"] = "1"
+os.environ["MKL_NUM_THREADS"] = "1"
+
+def ensure_cublas_workspace(config=":4096:8"):
+    """
+    尝试为 cuBLAS 设置可复现 workspace。强烈建议在主脚本入口处（import torch 之前）
+    通过 export 设置该 env。此函数会在运行时设置，但如果 torch 已经被 import，
+    则可能为时已晚——函数会打印提醒。
+    """
+    already = os.environ.get("CUBLAS_WORKSPACE_CONFIG")
+    if already:
+        print(f"[seed_utils] CUBLAS_WORKSPACE_CONFIG 已存在：{already}")
+    else:
+        os.environ["CUBLAS_WORKSPACE_CONFIG"] = config
+        print(f"[seed_utils] 已设置 CUBLAS_WORKSPACE_CONFIG={config} （注意：请在 import torch 前设置以保证生效）")
+
+def set_global_seed(seed: int = 42, set_threads: bool = True):
+    """
+    统一随机性设置。注意：若希望完全发挥效果，请在主脚本入口（import torch 之前）
+    先调用 ensure_cublas_workspace(...) 或在 shell 中 export CUBLAS_WORKSPACE_CONFIG。
+    """
+    ensure_cublas_workspace()  # 会设置 env 并提醒
+    os.environ["PYTHONHASHSEED"] = str(seed)
+
+    if set_threads:
+        os.environ["OMP_NUM_THREADS"] = "1"
+        os.environ["MKL_NUM_THREADS"] = "1"
+
+    random.seed(seed)
+    np.random.seed(seed)
+
+    # 现在导入 torch（晚导入以便前面 env 生效）
+    import torch
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+    # 强制确定性（如果存在不确定性算子，PyTorch 会报错并提示）
+    try:
+        torch.use_deterministic_algorithms(True)
+    except Exception as e:
+        print("[seed_utils] 设置 deterministic 模式时出错：", e)
+        print("[seed_utils] 请确认 CUBLAS_WORKSPACE_CONFIG 已在 import torch 之前设置。")
+
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+    if set_threads:
+        torch.set_num_threads(1)
+        torch.set_num_interop_threads(1)
+
+    print(f"[seed_utils] 全局 seed 已设置为 {seed}")
+
+set_global_seed(2025) 
+
+"""
+通用训练模版（优先从本地导入 Model -> 支持 DDP / 单卡，AMP，resume，日志，checkpoint）
+保存为 train_template_localmodel.py
+"""
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import torch.backends.cudnn as cudnn
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+import torchvision.models as tv_models
+
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import DataLoader
+from torch.utils.data.distributed import DistributedSampler
+
+from torch.sdaa import amp
+# from torch.cuda import amp
+
+
+# ----------------------------
+# Helper utilities (self-contained)
+# ----------------------------
+class AverageMeter(object):
+    def __init__(self, name='Meter', fmt=':.4f'):
+        self.name = name
+        self.fmt = fmt
+        self.reset()
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+    def update(self, val, n=1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / max(1, self.count)
+    def __str__(self):
+        fmtstr = '{name} {val' + self.fmt + '} (avg {avg' + self.fmt + '})'
+        return fmtstr.format(name=self.name, val=self.val, avg=self.avg)
+
+def accuracy(output, target, topk=(1,)):
+    """Computes the precision@k for the specified values of k
+    返回一个 list，每个元素是 tensor（百分比形式）
+    """
+    with torch.no_grad():
+        maxk = max(topk)
+        batch_size = target.size(0)
+
+        # output: (N, C) -> pred: (maxk, N)
+        _, pred = output.topk(maxk, 1, True, True)
+        pred = pred.t()  # (maxk, N)
+        correct = pred.eq(target.view(1, -1).expand_as(pred))  # (maxk, N) bool
+
+        res = []
+        for k in topk:
+            # 把前 k 行展平后求和（返回 0-dim tensor），随后换算为百分比
+            correct_k = correct[:k].reshape(-1).float().sum()  # 注意：不传 keepdim
+            # 乘以 100.0 / batch_size，保持返回 tensor（和之前代码兼容）
+            res.append(correct_k.mul_(100.0 / batch_size))
+        return res
+
+def save_checkpoint(state, is_best, save_dir, filename='checkpoint.pth'):
+    save_path = os.path.join(save_dir, filename)
+    torch.save(state, save_path)
+    if is_best:
+        best_path = os.path.join(save_dir, 'model_best.pth')
+        torch.save(state, best_path)
+
+def set_seed(seed, deterministic=False):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    if deterministic:
+        cudnn.deterministic = True
+        cudnn.benchmark = False
+    else:
+        cudnn.deterministic = False
+        cudnn.benchmark = True
+
+# ----------------------------
+# Argument parser
+# ----------------------------
+def parse_args():
+    parser = argparse.ArgumentParser(description='Generic PyTorch training template (DDP/AMP) with LocalModel priority')
+    parser.add_argument('--name', default='run', type=str, help='experiment name (log/checkpoints dir)')
+    parser.add_argument('--seed', default=42, type=int, help='random seed')
+    parser.add_argument('--arch', default='None', type=str, help='model name')
+    parser.add_argument('--deterministic', action='store_true', help='set cudnn deterministic (may be slower)')
+    parser.add_argument('--dataset', default='cifar10', choices=['cifar10','cifar100','imagenet','custom'], help='which dataset')
+    parser.add_argument('--datapath', default='./data', type=str, help='dataset root / imagenet root / custom root')
+    parser.add_argument('--imagenet_dir', default='./imagenet', type=str, help='if dataset=imagenet, path to imagenet root')
+    parser.add_argument('--custom_eval_dir', default=None, help='if dataset=custom, provide val dir')
+    parser.add_argument('--num_workers', default=4, type=int, help='dataloader workers per process')
+    parser.add_argument('--epochs', default=200, type=int)
+    parser.add_argument('--steps', default=0, type=int, help='max steps to run (if >0, training will stop when global_step reaches this).')
+    parser.add_argument('--batch_size', default=128, type=int)
+    parser.add_argument('--model_name', default='resnet18', help='torchvision model name or python path e.g. mypkg.mymodule.Model (used if no local Model)')
+    parser.add_argument('--num_classes', default=None, type=int, help='override num classes (auto-detect for common sets)')
+    parser.add_argument('--pretrained', action='store_true', help='use torchvision pretrained weights when available')
+    parser.add_argument('--optimizer', default='sgd', choices=['sgd','adam','adamw'], help='optimizer')
+    parser.add_argument('--lr', '--learning_rate', default=0.01, type=float)
+    parser.add_argument('--momentum', default=0.9, type=float)
+    parser.add_argument('--weight_decay', default=5e-4, type=float)
+    parser.add_argument('--nesterov', action='store_true')
+    parser.add_argument('--scheduler', default='multistep', choices=['multistep','step','cosine','none'], help='lr scheduler')
+    parser.add_argument('--milestones', default='100,150', type=str, help='milestones for multistep (comma sep)')
+    parser.add_argument('--step_size', default=30, type=int, help='step size for StepLR or cosine max epochs')
+    parser.add_argument('--gamma', default=0.1, type=float)
+    parser.add_argument('--scheduler_step_per_batch', action='store_true', help='call scheduler.step() per batch (for some schedulers)')
+    parser.add_argument('--resume', default='', type=str, help='path to checkpoint to resume from')
+    parser.add_argument('--start_epoch', default=0, type=int)
+    parser.add_argument('--print_freq', default=100, type=int)
+    parser.add_argument('--save_freq', default=10, type=int, help='save checkpoint every N epochs (rank0 only)')
+    parser.add_argument('--amp', action='store_true', default = True,help='use automatic mixed precision (AMP)')
+    parser.add_argument('--grad_accum_steps', default=1, type=int, help='gradient accumulation steps')
+    parser.add_argument('--local_rank', default=None, type=int, help='local rank passed by torchrun (if any). Use -1 or None for non-distributed')
+    parser.add_argument('--cutmix_prob', default=0.0, type=float)
+    parser.add_argument('--beta', default=1.0, type=float)
+    parser.add_argument('--seed_sampler', default=False, action='store_true', help='set sampler epoch seeds to make deterministic distributed shuffling')
+    args = parser.parse_args()
+    args.milestones = [int(x) for x in args.milestones.split(',')] if args.milestones else []
+    return args
+
+# ----------------------------
+# build model (优先 LocalModel)
+# ----------------------------
+def build_model_with_local_priority(args, device=None):
+    """
+    用参数 args.arch 作为模块名导入 Model()
+    如果模块不存在或没有 Model 类，则报错停止。
+    """
+    try:
+        # 动态导入模块，比如 args.arch = "rexnet"
+        mod = importlib.import_module(args.arch)
+        Model = getattr(mod, "Model")   # 从模块中获取 Model 类
+    except Exception as e:
+        raise RuntimeError(
+            f"无法导入模型模块 '{args.arch}' 或未找到类 Model。"
+            f"\n错误信息：{e}"
+        )
+    
+    # 解析数据集类别数
+    if args.dataset == 'cifar10':
+        num_classes = 10
+    elif args.dataset == 'cifar100':
+        num_classes = 100
+    else:
+        print(f"[ERROR] 不支持的数据集类型：{args.dataset}，无法确定类别数。程序终止。")
+        sys.exit(1)
+
+
+    # 实例化
+    try:
+        model = Model(num_classes)
+    except Exception as e:
+        raise RuntimeError(
+            f"Model() 实例化失败，请检查模型构造函数。\n错误信息：{e}"
+        )
+
+    return model
+
+# ----------------------------
+# Data loader factory
+# ----------------------------
+def build_dataloaders(args, rank, world_size):
+    if args.dataset == 'cifar10' or args.dataset == 'cifar100':
+        mean = (0.4914, 0.4822, 0.4465)
+        std = (0.2470, 0.2435, 0.2616) if args.dataset == 'cifar10' else (0.2023, 0.1994, 0.2010)
+        # train_transform = transforms.Compose([
+        #     transforms.RandomCrop(32, padding=4),
+        #     transforms.RandomHorizontalFlip(),
+        #     transforms.ToTensor(),
+        #     transforms.Normalize(mean, std),
+        # ])
+        # test_transform = transforms.Compose([
+        #     transforms.ToTensor(),
+        #     transforms.Normalize(mean, std),
+        # ])
+
+        train_transform = transforms.Compose([    # 2025/12/3 从visformer模型开始
+        transforms.Resize(256),                 # 先放大到 256
+        transforms.RandomCrop(224),            # 再随机裁剪为 224（更符合 ImageNet 风格增强）
+        transforms.RandomHorizontalFlip(),
+        transforms.ToTensor(),
+        transforms.Normalize(mean, std),
+        ])
+        test_transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean, std),
+        ])
+        root = args.datapath
+        if args.dataset == 'cifar10':
+            train_set = datasets.CIFAR10(root=root, train=True, download=False, transform=train_transform)
+            val_set = datasets.CIFAR10(root=root, train=False, download=False, transform=test_transform)
+            num_classes = 10
+        else:
+            train_set = datasets.CIFAR100(root=root, train=True, download=False, transform=train_transform)
+            val_set = datasets.CIFAR100(root=root, train=False, download=False, transform=test_transform)
+            num_classes = 100
+
+    elif args.dataset == 'imagenet':
+        train_dir = os.path.join(args.imagenet_dir, 'train')
+        val_dir = os.path.join(args.imagenet_dir, 'val')
+        train_transform = transforms.Compose([
+            transforms.RandomResizedCrop(224),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+            transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225)),
+        ])
+        test_transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize((0.485,0.456,0.406), (0.229,0.224,0.225)),
+        ])
+        train_set = datasets.ImageFolder(train_dir, train_transform)
+        val_set = datasets.ImageFolder(val_dir, test_transform)
+        num_classes = args.num_classes or 1000
+
+    elif args.dataset == 'custom':
+        train_dir = os.path.join(args.datapath, 'train')
+        val_dir = args.custom_eval_dir or os.path.join(args.datapath, 'val')
+        train_transform = transforms.Compose([
+            transforms.RandomResizedCrop(224),
+            transforms.RandomHorizontalFlip(),
+            transforms.ToTensor(),
+        ])
+        test_transform = transforms.Compose([
+            transforms.Resize(256),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+        ])
+        train_set = datasets.ImageFolder(train_dir, train_transform)
+        val_set = datasets.ImageFolder(val_dir, test_transform)
+        num_classes = len(train_set.classes)
+    else:
+        raise ValueError("Unknown dataset")
+
+    if dist.is_initialized() and world_size > 1:
+        train_sampler = DistributedSampler(train_set, num_replicas=world_size, rank=rank, shuffle=True)
+    else:
+        train_sampler = None
+
+    train_loader = DataLoader(train_set,
+                              batch_size=args.batch_size,
+                              shuffle=(train_sampler is None),
+                              num_workers=args.num_workers,
+                              pin_memory=True,
+                              sampler=train_sampler,
+                              drop_last=False)
+    val_loader = DataLoader(val_set,
+                            batch_size=args.batch_size,
+                            shuffle=False,
+                            num_workers=args.num_workers,
+                            pin_memory=True)
+
+    return train_loader, val_loader, num_classes, train_sampler
+
+# ----------------------------
+# Train & validate
+# ----------------------------
+def train_one_epoch(args, epoch, model, criterion, optimizer, train_loader, device, scaler, scheduler=None, train_sampler=None, global_step_start=0, max_global_steps=None):
+    """
+    现在支持：若 max_global_steps 非 None，则当 global_step 达到该值时提前退出
+    返回: epoch_summary_dict, step_logs_list, global_step_end
+    step_logs_list: list of dicts with per-step info (for logging to CSV if需要)
+    """
+    batch_time = AverageMeter('Time')
+    data_time = AverageMeter('Data')
+    losses = AverageMeter('Loss')
+    top1 = AverageMeter('Acc@1')
+    top5 = AverageMeter('Acc@5')
+
+    model.train()
+    end = time.time()
+    optimizer.zero_grad()
+
+    iters = len(train_loader)
+    step_logs = []
+    global_step = global_step_start
+
+    for i, (images, targets) in enumerate(train_loader):
+        # check global steps limit
+        if (max_global_steps is not None) and (global_step >= max_global_steps):
+            break
+
+        data_time.update(time.time() - end)
+        images = images.to(device, non_blocking=True)
+        targets = targets.to(device, non_blocking=True)
+
+        if args.amp:
+            with amp.autocast():
+                outputs = model(images)
+                loss = criterion(outputs, targets) / args.grad_accum_steps
+        else:
+            outputs = model(images)
+            loss = criterion(outputs, targets) / args.grad_accum_steps
+
+        if args.amp:
+            scaler.scale(loss).backward()
+        else:
+            loss.backward()
+
+        if (i + 1) % args.grad_accum_steps == 0:
+            if args.amp:
+                scaler.step(optimizer)
+                scaler.update()
+            else:
+                optimizer.step()
+            optimizer.zero_grad()
+            if scheduler is not None and args.scheduler_step_per_batch:
+                scheduler.step()
+
+        with torch.no_grad():
+            acc1, acc5 = accuracy(outputs, targets, topk=(1,5))
+        losses.update(loss.item() * args.grad_accum_steps, images.size(0))
+        top1.update(acc1.item(), images.size(0))
+        top5.update(acc5.item(), images.size(0))
+
+        batch_time.update(time.time() - end)
+        end = time.time()
+
+        # increment global step AFTER processing this batch
+        global_step += 1
+
+        # per-step print (controlled by print_freq)
+        # 输出格式调整为：Epoch[23]:step[1/32] step_train_loss 3.0075 acc1 25.95 acc5 54.46
+        # 使用 i+1 / iters 更贴近人类可读的“第几步 / 总步数（该 epoch 内）”
+        if ((global_step % args.print_freq == 0) or (i == iters - 1)) and ((dist.get_rank() if dist.is_initialized() else 0) == 0):
+            lr = optimizer.param_groups[0]['lr']
+            # note: losses.val is 当前 batch 的 loss（经过 grad_accum 处理后还原），losses.avg 是到目前为止的 epoch 平均
+            print(f"Epoch[{epoch}]:step[{i+1}/{iters}] step_train_loss {losses.val:.4f} acc1 {top1.val:.2f} acc5 {top5.val:.2f}")
+
+        # collect per-step log
+        step_logs.append({
+            'epoch': epoch,
+            'batch_idx': i,
+            'global_step': global_step,
+            'lr': optimizer.param_groups[0]['lr'],
+            'loss': losses.val,
+            'loss_avg': losses.avg,
+            'acc1': top1.val,
+            'acc1_avg': top1.avg,
+            'acc5': top5.val,
+            'acc5_avg': top5.avg,
+            'time': batch_time.val
+        })
+
+        # if reached max_global_steps inside epoch, break (handled at loop start next iter)
+        if (max_global_steps is not None) and (global_step >= max_global_steps):
+            # optional message
+            if (dist.get_rank() if dist.is_initialized() else 0) == 0:
+                print(f"[Info] 达到 max_global_steps={max_global_steps}，将在 epoch 内提前停止。")
+            break
+
+    if scheduler is not None and not args.scheduler_step_per_batch:
+        scheduler.step()
+
+    return OrderedDict([('loss', losses.avg), ('acc1', top1.avg), ('acc5', top5.avg)]), step_logs, global_step
+
+def validate(args, model, val_loader, criterion, device):
+    losses = AverageMeter('Loss')
+    top1 = AverageMeter('Acc@1')
+    top5 = AverageMeter('Acc@5')
+
+    model.eval()
+    with torch.no_grad():
+        for i, (images, targets) in enumerate(tqdm(val_loader)):
+            images = images.to(device, non_blocking=True)
+            targets = targets.to(device, non_blocking=True)
+            outputs = model(images)
+            loss = criterion(outputs, targets)
+            acc1, acc5 = accuracy(outputs, targets, topk=(1,5))
+            losses.update(loss.item(), images.size(0))
+            top1.update(acc1.item(), images.size(0))
+            top5.update(acc5.item(), images.size(0))
+    return OrderedDict([('loss', losses.avg), ('acc1', top1.avg), ('acc5', top5.avg)])
+
+# ----------------------------
+# Main
+# ----------------------------
+def main():
+    args = parse_args()
+
+    # handle local_rank from env if not provided
+    local_rank_env = os.environ.get('LOCAL_RANK', None)
+    if args.local_rank is None and local_rank_env is not None:
+        args.local_rank = int(local_rank_env)
+
+    distributed = (args.local_rank is not None and args.local_rank != -1)
+    if distributed:
+        dist.init_process_group(backend='nccl', init_method='env://')
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+    else:
+        rank = 0
+        world_size = 1
+
+    if distributed:
+        torch.cuda.set_device(args.local_rank)
+        device = torch.device('cuda', args.local_rank)
+    else:
+        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    set_seed(args.seed + (rank if distributed else 0), deterministic=args.deterministic)
+
+    save_dir = os.path.join('models', args.name)
+    if rank == 0:
+        os.makedirs(save_dir, exist_ok=True)
+        with open(os.path.join(save_dir, 'args.json'), 'w') as f:
+            json.dump(vars(args), f, indent=2)
+    if distributed:
+        dist.barrier()
+
+    train_loader, val_loader, auto_num_classes, train_sampler = build_dataloaders(args, rank, world_size)
+    if args.num_classes is None:
+        args.num_classes = auto_num_classes
+
+    # 使用本地 Model 优先（LocalModel 已在文件顶部尝试导入）
+    model = build_model_with_local_priority(args, device)
+    model.to(device)
+
+    if distributed:
+        model = DDP(model, device_ids=[args.local_rank], output_device=args.local_rank, find_unused_parameters=True)
+
+    criterion = nn.CrossEntropyLoss().to(device)
+    params = [p for p in model.parameters() if p.requires_grad]
+    if args.optimizer == 'sgd':
+        optimizer = optim.SGD(params, lr=args.lr, momentum=args.momentum,
+                              weight_decay=args.weight_decay, nesterov=args.nesterov)
+    elif args.optimizer == 'adam':
+        optimizer = optim.Adam(params, lr=args.lr, weight_decay=args.weight_decay)
+    elif args.optimizer == 'adamw':
+        optimizer = optim.AdamW(params, lr=args.lr, weight_decay=args.weight_decay)
+    else:
+        raise ValueError('Unknown optimizer')
+
+    scheduler = None
+    if args.scheduler == 'multistep':
+        scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=args.milestones, gamma=args.gamma)
+    elif args.scheduler == 'step':
+        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=args.step_size, gamma=args.gamma)
+    elif args.scheduler == 'cosine':
+        scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
+    elif args.scheduler == 'none':
+        scheduler = None
+
+    scaler = amp.GradScaler() if args.amp else None
+
+    start_epoch = args.start_epoch
+    best_acc = 0.0
+    if args.resume:
+        if os.path.isfile(args.resume):
+            ckpt = torch.load(args.resume, map_location='cpu')
+            model_state = ckpt.get('state_dict', ckpt)
+            if isinstance(model, DDP):
+                model.module.load_state_dict(model_state)
+            else:
+                model.load_state_dict(model_state)
+            if 'optimizer' in ckpt:
+                optimizer.load_state_dict(ckpt['optimizer'])
+            start_epoch = ckpt.get('epoch', start_epoch)
+            best_acc = ckpt.get('best_acc', best_acc)
+            print(f"=> resumed from {args.resume}, start_epoch={start_epoch}")
+        else:
+            print(f"=> resume path {args.resume} not found")
+
+    log_columns = ['epoch', 'lr', 'loss', 'acc1', 'acc5', 'val_loss', 'val_acc1', 'val_acc5']
+    log_df = pd.DataFrame(columns=log_columns)
+    # step-level log
+    step_log_columns = ['epoch', 'batch_idx', 'global_step', 'lr', 'loss', 'loss_avg', 'acc1', 'acc1_avg', 'acc5', 'acc5_avg', 'time']
+    step_log_df = pd.DataFrame(columns=step_log_columns)
+
+    total_epochs = args.epochs
+    # global_step计数器（训练过程中跨epoch持续）
+    global_step = 0
+
+    epoch = start_epoch
+    # loop until either epoch criteria or step criteria met
+    while True:
+        if train_sampler is not None:
+            if args.seed_sampler:
+                train_sampler.set_epoch(epoch + args.seed)
+            else:
+                train_sampler.set_epoch(epoch)
+
+        if rank == 0:
+            print(f"==== Epoch {epoch}/{total_epochs - 1} ====")
+
+        # 如果传入了 args.steps (>0)，则把剩余允许的 step 数传给 train_one_epoch，
+        # 否则 max_global_steps=None（按整 epoch 执行完）
+        if args.steps and args.steps > 0:
+            max_global_steps = args.steps
+        else:
+            max_global_steps = None
+
+        train_log, step_logs, global_step = train_one_epoch(
+            args, epoch, model, criterion, optimizer, train_loader, device, scaler,
+            scheduler, train_sampler, global_step_start=global_step, max_global_steps=max_global_steps
+        )
+
+        # 如果启用了按 steps 的模式且已经达到上限，直接退出 main（跳过 validate）
+        if max_global_steps is not None and global_step >= max_global_steps:
+            if rank == 0:
+                print(f"[Main] 达到 max_global_steps={max_global_steps}（global_step={global_step}），提前退出训练（跳过验证）。")
+            # 直接返回 main()，不再执行后续 validate / 保存逻辑
+            return
+
+        # 验证并记录 epoch 级别日志（如果在 step 模式下很可能在中间某个 epoch 提前结束，但我们仍做一次 validate）
+        val_log = validate(args, model, val_loader, criterion, device)
+        current_lr = optimizer.param_groups[0]['lr']
+
+        if rank == 0:
+            # epoch summary print, 格式与示例对齐
+            print(f"Epoch[{epoch}]: epoch_train_loss {train_log['loss']:.4f} acc1 {train_log['acc1']:.2f} acc5 {train_log['acc5']:.2f} | "
+                  f"val_loss {val_log['loss']:.4f} acc1 {val_log['acc1']:.2f} acc5 {val_log['acc5']:.2f} lr {current_lr:.6f}")
+            row = {
+                'epoch': epoch,
+                'lr': current_lr,
+                'loss': train_log['loss'],
+                'acc1': train_log['acc1'],
+                'acc5': train_log['acc5'],
+                'val_loss': val_log['loss'],
+                'val_acc1': val_log['acc1'],
+                'val_acc5': val_log['acc5'],
+            }
+            new_row_df = pd.DataFrame([row])
+            log_df = pd.concat([log_df, new_row_df], ignore_index=True)
+            log_df.to_csv(os.path.join(save_dir, 'log.csv'), index=False)
+
+            is_best = val_log['acc1'] > best_acc
+            if is_best:
+                best_acc = val_log['acc1']
+            if (epoch % args.save_freq == 0) or is_best or ( (max_global_steps is None) and (epoch == total_epochs - 1) ) :
+                state = {
+                    'epoch': epoch,
+                    'state_dict': model.module.state_dict() if isinstance(model, DDP) else model.state_dict(),
+                    'best_acc': best_acc,
+                    'optimizer': optimizer.state_dict(),
+                    'args': vars(args)
+                }
+                save_checkpoint(state, is_best, save_dir, filename=f'checkpoint_epoch_{epoch}.pth')
+
+        # increment epoch
+        epoch += 1
+
+        # stopping conditions:
+        # 1) if steps mode enabled and reached steps -> stop
+        if args.steps and args.steps > 0:
+            if global_step >= args.steps:
+                if rank == 0:
+                    print(f"[Main] 已达到指定 steps={args.steps}（global_step={global_step}），训练结束。")
+                break
+
+        # 2) if steps not used, stop when epoch >= epochs
+        else:
+            if epoch >= total_epochs:
+                if rank == 0:
+                    print(f"[Main] 已达到指定 epochs={total_epochs}（epoch={epoch}），训练结束。")
+                break
+
+    if dist.is_initialized():
+        dist.barrier()
+    if rank == 0:
+        print("Training finished. Best val acc1: {:.2f}".format(best_acc))
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file