diff --git a/PyTorch/build-in/Classification/SwinS3/readme.md b/PyTorch/build-in/Classification/SwinS3/readme.md
new file mode 100644
index 000000000..19755e528
--- /dev/null
+++ b/PyTorch/build-in/Classification/SwinS3/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 获取数据集
+
+Res2Net 训练使用 **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.txt
+
+```
+
+
+
+### 2.4 启动训练
+
+1. 在构建好的环境中，进入模型训练脚本所在目录。
+
+2. 运行训练。该模型支持单机单卡训练。
+执行以下命令启动训练（使用 CIFAR-100 数据集，Batch Size 为 128）：
+```bash
+python weloTrainStep.py \
+        --name train \
+        --arch swins3 \
+        --print_freq 1 \
+        --steps 100 \
+        --dataset cifar100 \
+        --datapath ../data \
+        --batch_size  \
+        --epochs 100
+
+```
diff --git a/PyTorch/build-in/Classification/SwinS3/requirement.txt b/PyTorch/build-in/Classification/SwinS3/requirement.txt
new file mode 100644
index 000000000..23ac8e3c4
--- /dev/null
+++ b/PyTorch/build-in/Classification/SwinS3/requirement.txt
@@ -0,0 +1,72 @@
+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
+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
+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
+model-index==0.1.11
+mpmath==1.3.0
+networkx==3.4.2
+numpy
+opendatalab==0.0.10
+openxlab==0.1.3
+ordered-set==4.1.0
+oss2==2.17.0
+pandas==2.3.3
+pillow==11.1.0
+platformdirs==4.5.1
+pycocotools==2.0.11
+pycryptodome==3.23.0
+Pygments==2.19.2
+pyparsing==3.2.5
+python-dateutil==2.9.0.post0
+pytz==2023.4
+requests==2.28.2
+rich==13.4.2
+safetensors==0.7.0
+scipy==1.15.3
+shapely==2.1.2
+shellingham==1.5.4
+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
+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/SwinS3/swin.py b/PyTorch/build-in/Classification/SwinS3/swin.py
new file mode 100644
index 000000000..4aedc345a
--- /dev/null
+++ b/PyTorch/build-in/Classification/SwinS3/swin.py
@@ -0,0 +1,628 @@
+import torch
+import torch.nn as nn
+import torch.utils.checkpoint as checkpoint
+from timm.models.layers import DropPath, to_2tuple, trunc_normal_
+
+
+class Mlp(nn.Module):
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop(x)
+        x = self.fc2(x)
+        x = self.drop(x)
+        return x
+
+
+def window_partition(x, window_size):
+    """
+    Args:
+        x: (B, H, W, C)
+        window_size (int): window size
+
+    Returns:
+        windows: (num_windows*B, window_size, window_size, C)
+    """
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size, H, W):
+    """
+    Args:
+        windows: (num_windows*B, window_size, window_size, C)
+        window_size (int): Window size
+        H (int): Height of image
+        W (int): Width of image
+
+    Returns:
+        x: (B, H, W, C)
+    """
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class WindowAttention(nn.Module):
+    r""" Window based multi-head self attention (W-MSA) module with relative position bias.
+    It supports both of shifted and non-shifted window.
+
+    Args:
+        dim (int): Number of input channels.
+        window_size (tuple[int]): The height and width of the window.
+        num_heads (int): Number of attention heads.
+        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
+        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
+        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
+    """
+
+    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # Wh, Ww
+        self.num_heads = num_heads
+        head_dim = 32
+        self.scale = qk_scale or head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
+        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qkv = nn.Linear(dim, num_heads * 32 * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask=None):
+        """
+        Args:
+            x: input features with shape of (num_windows*B, N, C)
+            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
+        """
+        B_, N, C = x.shape
+        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
+
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f'dim={self.dim}, window_size={self.window_size}, num_heads={self.num_heads}'
+
+    def flops(self, N):
+        # calculate flops for 1 window with token length of N
+        flops = 0
+        # qkv = self.qkv(x)
+        flops += N * self.dim * 3 * self.dim
+        # attn = (q @ k.transpose(-2, -1))
+        flops += self.num_heads * N * (self.dim // self.num_heads) * N
+        #  x = (attn @ v)
+        flops += self.num_heads * N * N * (self.dim // self.num_heads)
+        # x = self.proj(x)
+        flops += N * self.dim * self.dim
+        return flops
+
+
+class SwinTransformerBlock(nn.Module):
+    r""" Swin Transformer Block.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resulotion.
+        num_heads (int): Number of attention heads.
+        window_size (int): Window size.
+        shift_size (int): Shift size for SW-MSA.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float, optional): Stochastic depth rate. Default: 0.0
+        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, dim, input_resolution, num_heads, window_size=7, shift_size=0,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.num_heads = num_heads
+        self.window_size = window_size
+        self.shift_size = shift_size
+        self.mlp_ratio = mlp_ratio
+        if min(self.input_resolution) <= self.window_size:
+            # if window size is larger than input resolution, we don't partition windows
+            self.shift_size = 0
+            self.window_size = min(self.input_resolution)
+        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
+            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+        if self.shift_size > 0:
+            # calculate attention mask for SW-MSA
+            H, W = self.input_resolution
+            img_mask = torch.zeros((1, H, W, 1))  # 1 H W 1
+            h_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size, -self.shift_size),
+                        slice(-self.shift_size, None))
+            w_slices = (slice(0, -self.window_size),
+                        slice(-self.window_size, -self.shift_size),
+                        slice(-self.shift_size, None))
+            cnt = 0
+            for h in h_slices:
+                for w in w_slices:
+                    img_mask[:, h, w, :] = cnt
+                    cnt += 1
+
+            mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
+            mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
+            attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
+            attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+        else:
+            attn_mask = None
+
+        self.register_buffer("attn_mask", attn_mask)
+
+    def forward(self, x):
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+
+        # cyclic shift
+        if self.shift_size > 0:
+            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
+        else:
+            shifted_x = x
+
+        # partition windows
+        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
+        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
+
+        # W-MSA/SW-MSA
+        attn_windows = self.attn(x_windows, mask=self.attn_mask)  # nW*B, window_size*window_size, C
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
+        shifted_x = window_reverse(attn_windows, self.window_size, H, W)  # B H' W' C
+
+        # reverse cyclic shift
+        if self.shift_size > 0:
+            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
+        else:
+            x = shifted_x
+        x = x.view(B, H * W, C)
+
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(x)))
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, num_heads={self.num_heads}, " \
+               f"window_size={self.window_size}, shift_size={self.shift_size}, mlp_ratio={self.mlp_ratio}"
+
+    def flops(self):
+        flops = 0
+        H, W = self.input_resolution
+        # norm1
+        flops += self.dim * H * W
+        # W-MSA/SW-MSA
+        nW = H * W / self.window_size / self.window_size
+        flops += nW * self.attn.flops(self.window_size * self.window_size)
+        # mlp
+        flops += 2 * H * W * self.dim * self.dim * self.mlp_ratio
+        # norm2
+        flops += self.dim * H * W
+        return flops
+
+
+class PatchMerging(nn.Module):
+    r""" Patch Merging Layer.
+
+    Args:
+        input_resolution (tuple[int]): Resolution of input feature.
+        dim (int): Number of input channels.
+        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
+    """
+
+    def __init__(self, input_resolution, dim, out_dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, out_dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+
+    def forward(self, x):
+        """
+        x: B, H*W, C
+        """
+        H, W = self.input_resolution
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+        assert H % 2 == 0 and W % 2 == 0, f"x size ({H}*{W}) are not even."
+
+        x = x.view(B, H, W, C)
+
+        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
+        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
+        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
+        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
+        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
+        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
+
+        x = self.norm(x)
+        x = self.reduction(x)
+
+        return x
+
+    def extra_repr(self) -> str:
+        return f"input_resolution={self.input_resolution}, dim={self.dim}"
+
+    def flops(self):
+        H, W = self.input_resolution
+        flops = H * W * self.dim
+        flops += (H // 2) * (W // 2) * 4 * self.dim * 2 * self.dim
+        return flops
+
+
+class BasicLayer(nn.Module):
+    """ A basic Swin Transformer layer for one stage.
+
+    Args:
+        dim (int): Number of input channels.
+        input_resolution (tuple[int]): Input resolution.
+        depth (int): Number of blocks.
+        num_heads (int): Number of attention heads.
+        window_size (int): Local window size.
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
+        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
+        drop (float, optional): Dropout rate. Default: 0.0
+        attn_drop (float, optional): Attention dropout rate. Default: 0.0
+        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
+        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
+        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
+    """
+
+    def __init__(self, dim, out_dim, input_resolution, depth, num_heads, window_size,
+                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0.,
+                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):
+
+        super().__init__()
+        self.dim = dim
+        self.input_resolution = input_resolution
+        self.depth = depth
+        self.use_checkpoint = use_checkpoint
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            SwinTransformerBlock(dim=dim, input_resolution=input_resolution,
+                                 num_heads=num_heads,    # 修改：去掉 [i]，直接使用传入的 int
+                                 window_size=window_size, # 修改：去掉 [i]
+                                 shift_size=0 if (i % 2 == 0) else window_size // 2, # 修改：去掉 [i]
+                                 mlp_ratio=mlp_ratio,     # 修改：去掉 [i]
+                                 qkv_bias=qkv_bias, qk_scale=qk_scale,
+                                 drop=drop, attn_drop=attn_drop,
+                                 # drop_path 是一个列表，所以这里保留逻辑
+                                 drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                                 norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(input_resolution, dim=dim, out_dim=out_dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def forward(self, x):
+        for blk in self.blocks:
+            if self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x)
+            else:
+                x = blk(x)
+        if self.downsample is not None:
+            x = self.downsample(x)
+        return x
+
+    def extra_repr(self) -> str:
+        return f"dim={self.dim}, input_resolution={self.input_resolution}, depth={self.depth}"
+
+    def flops(self):
+        flops = 0
+        for blk in self.blocks:
+            flops += blk.flops()
+        if self.downsample is not None:
+            flops += self.downsample.flops()
+        return flops
+
+
+class PatchEmbed(nn.Module):
+    r""" Image to Patch Embedding
+
+    Args:
+        img_size (int): Image size.  Default: 224.
+        patch_size (int): Patch token size. Default: 4.
+        in_chans (int): Number of input image channels. Default: 3.
+        embed_dim (int): Number of linear projection output channels. Default: 96.
+        norm_layer (nn.Module, optional): Normalization layer. Default: None
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        img_size = to_2tuple(img_size)
+        patch_size = to_2tuple(patch_size)
+        patches_resolution = [img_size[0] // patch_size[0], img_size[1] // patch_size[1]]
+        self.img_size = img_size
+        self.patch_size = patch_size
+        self.patches_resolution = patches_resolution
+        self.num_patches = patches_resolution[0] * patches_resolution[1]
+
+        self.in_chans = in_chans
+        self.embed_dim = embed_dim
+
+        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
+        if norm_layer is not None:
+            self.norm = norm_layer(embed_dim)
+        else:
+            self.norm = None
+
+    def forward(self, x):
+        B, C, H, W = x.shape
+        # FIXME look at relaxing size constraints
+        assert H == self.img_size[0] and W == self.img_size[1], \
+            f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})."
+        x = self.proj(x).flatten(2).transpose(1, 2)  # B Ph*Pw C
+        if self.norm is not None:
+            x = self.norm(x)
+        return x
+
+    def flops(self):
+        Ho, Wo = self.patches_resolution
+        flops = Ho * Wo * self.embed_dim * self.in_chans * (self.patch_size[0] * self.patch_size[1])
+        if self.norm is not None:
+            flops += Ho * Wo * self.embed_dim
+        return flops
+
+
+class SSSTransformer(nn.Module):
+    r"""
+
+    Args:
+        img_size (int | tuple(int)): Input image size. Default 224
+        patch_size (int | tuple(int)): Patch size. Default: 4
+        in_chans (int): Number of input image channels. Default: 3
+        num_classes (int): Number of classes for classification head. Default: 1000
+        embed_dim (int): Patch embedding dimension. Default: 96
+        depths (tuple(int)): Depth of each Swin Transformer layer.
+        num_heads (tuple(int)): Number of attention heads in different layers.
+        window_size (int): Window size. Default: 7
+        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4
+        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
+        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set. Default: None
+        drop_rate (float): Dropout rate. Default: 0
+        attn_drop_rate (float): Attention dropout rate. Default: 0
+        drop_path_rate (float): Stochastic depth rate. Default: 0.1
+        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
+        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False
+        patch_norm (bool): If True, add normalization after patch embedding. Default: True
+        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False
+    """
+
+    def __init__(self, img_size=224, patch_size=4, in_chans=3, num_classes=1000,
+                 embed_dim=[96, 192, 384, 768], depths=[2, 2, 6, 2], num_heads=[3, 6, 12, 24],
+                 window_size=[7, 7, 7, 7], mlp_ratio=[4., 4., 4., 4.], qkv_bias=True, qk_scale=None,
+                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
+                 norm_layer=nn.LayerNorm, ape=False, patch_norm=True,
+                 use_checkpoint=False, **kwargs):
+        super().__init__()
+
+        self.num_classes = num_classes
+        self.num_layers = len(depths)
+        self.embed_dim = embed_dim
+        self.ape = ape
+        self.patch_norm = patch_norm
+        self.num_features = int(embed_dim[-1])
+        self.mlp_ratio = mlp_ratio
+
+        # split image into non-overlapping patches
+        self.patch_embed = PatchEmbed(
+            img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim[0],
+            norm_layer=norm_layer if self.patch_norm else None)
+        num_patches = self.patch_embed.num_patches
+        patches_resolution = self.patch_embed.patches_resolution
+        self.patches_resolution = patches_resolution
+
+        # absolute position embedding
+        if self.ape:
+            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, num_patches, embed_dim))
+            trunc_normal_(self.absolute_pos_embed, std=.02)
+
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # stochastic depth
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
+
+        # build layers
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            layer = BasicLayer(dim=int(embed_dim[i_layer]),
+                               out_dim=int(embed_dim[i_layer+1]) if (i_layer < self.num_layers - 1) else None,
+                               input_resolution=(patches_resolution[0] // (2 ** i_layer),
+                                                 patches_resolution[1] // (2 ** i_layer)),
+                               depth=depths[i_layer],
+                               num_heads=num_heads[i_layer],
+                               window_size=window_size[i_layer],
+                               mlp_ratio=self.mlp_ratio[i_layer],
+                               qkv_bias=qkv_bias, qk_scale=qk_scale,
+                               drop=drop_rate, attn_drop=attn_drop_rate,
+                               drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                               norm_layer=norm_layer,
+                               downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
+                               use_checkpoint=use_checkpoint)
+            self.layers.append(layer)
+
+        self.norm = norm_layer(self.num_features)
+        self.avgpool = nn.AdaptiveAvgPool1d(1)
+        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
+
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    @torch.jit.ignore
+    def no_weight_decay(self):
+        return {'absolute_pos_embed'}
+
+    @torch.jit.ignore
+    def no_weight_decay_keywords(self):
+        return {'relative_position_bias_table'}
+
+    def forward_features(self, x):
+        x = self.patch_embed(x)
+        if self.ape:
+            x = x + self.absolute_pos_embed
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x = layer(x)
+
+        x = self.norm(x)  # B L C
+        x = self.avgpool(x.transpose(1, 2))  # B C 1
+        x = torch.flatten(x, 1)
+        return x
+
+    def forward(self, x):
+        x = self.forward_features(x)
+        x = self.head(x)
+        return x
+
+    def flops(self):
+        flops = 0
+        flops += self.patch_embed.flops()
+        for i, layer in enumerate(self.layers):
+            flops += layer.flops()
+        flops += self.num_features * self.patches_resolution[0] * self.patches_resolution[1] // (2 ** self.num_layers)
+        flops += self.num_features * self.num_classes
+        return flops
+
+def Model(num_classes=100):
+    """
+    创建一个 SSSTransformer 模型实例 (默认配置对应 Swin-Tiny)
+    用于 ImageNet 训练。
+    
+    Args:
+        num_classes (int): 分类数量，默认 100 (ImageNet-100) 或 1000.
+    """
+    model = SSSTransformer(
+        img_size=224,
+        patch_size=4,
+        in_chans=3,
+        num_classes=num_classes,
+        # 以下参数对应 Swin-Tiny 配置
+        embed_dim=[96, 192, 384, 768],
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=[7, 7, 7, 7],
+        mlp_ratio=[4., 4., 4., 4.],
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.2, # Swin-Tiny 在 ImageNet 上通常使用 0.2 的 drop_path
+        ape=False,
+        patch_norm=True,
+        use_checkpoint=False 
+    )
+    return model
+
+# 使用示例（测试用）
+if __name__ == "__main__":
+    # 创建模型
+    net = Model(num_classes=1000)
+    print(f"Model created successfully.")
+    
+    # 创建一个伪造的输入张量 (Batch_Size, Channels, Height, Width)
+    dummy_input = torch.randn(1, 3, 224, 224)
+    
+    # 前向传播
+    output = net(dummy_input)
+    print(f"Input shape: {dummy_input.shape}")
+    print(f"Output shape: {output.shape}") # 应该是 [1, 1000]
+    
+    # 计算 FLOPs (需要调用类中定义的 flops 方法)
+    try:
+        print(f"Model FLOPs: {net.flops() / 1e9:.2f} G")
+    except Exception as e:
+        print(f"FLOPs calculation error: {e}")
\ No newline at end of file
diff --git a/PyTorch/build-in/Classification/SwinS3/weloTrainStep.py b/PyTorch/build-in/Classification/SwinS3/weloTrainStep.py
new file mode 100644
index 000000000..13297c11b
--- /dev/null
+++ b/PyTorch/build-in/Classification/SwinS3/weloTrainStep.py
@@ -0,0 +1,692 @@
+#!/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.1, 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()
+
+        # 每当累积步满足 grad_accum_steps 就 step
+        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)
+        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']
+            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):
+            if (dist.get_rank() if dist.is_initialized() else 0) == 0:
+                print(f"[Info] 达到 max_global_steps={max_global_steps}，将在 epoch 内提前停止。")
+            break
+
+    # --- flush remaining grads if needed (handle gradient accumulation leftovers) ---
+    processed_batches = global_step - global_step_start  # 实际处理的 batch 数
+    if args.grad_accum_steps > 1 and (processed_batches % args.grad_accum_steps) != 0:
+        # only step if there are gradients
+        grads_present = any((p.grad is not None and p.requires_grad) for p in model.parameters())
+        if grads_present:
+            if args.amp:
+                try:
+                    scaler.step(optimizer)
+                    scaler.update()
+                except Exception as e:
+                    # 防御性：若 scaler.step 因某些原因失败，尝试普通 step（只在极端情况下）
+                    print("[Warning] scaler.step 失败，尝试普通 optimizer.step():", e)
+                    optimizer.step()
+            else:
+                optimizer.step()
+            optimizer.zero_grad()
+            if scheduler is not None and args.scheduler_step_per_batch:
+                scheduler.step()
+            if (dist.get_rank() if dist.is_initialized() else 0) == 0:
+                print(f"[Info] flushed remaining gradients after early stop (processed_batches={processed_batches}, grad_accum={args.grad_accum_steps}).")
+
+    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, max_batches=None):
+    """
+    Validate on the val_loader.
+    If max_batches is not None, only process up to that many batches (useful for quick checks).
+    Returns an OrderedDict with loss/acc1/acc5 (averaged over processed samples).
+    """
+    losses = AverageMeter('Loss')
+    top1 = AverageMeter('Acc@1')
+    top5 = AverageMeter('Acc@5')
+
+    model.eval()
+    processed_batches = 0
+    processed_samples = 0
+    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))
+            batch_n = images.size(0)
+            losses.update(loss.item(), batch_n)
+            top1.update(acc1.item(), batch_n)
+            top5.update(acc5.item(), batch_n)
+
+            processed_batches += 1
+            processed_samples += batch_n
+
+            if (max_batches is not None) and (processed_batches >= max_batches):
+                break
+
+    # 如果没处理任何样本，避免除0（不太可能，但防御性）
+    if processed_samples == 0:
+        return OrderedDict([('loss', 0.0), ('acc1', 0.0), ('acc5', 0.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 的模式且已经达到上限，标记需要在做一次验证后退出
+        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}），将在完成验证后退出训练。")
+            # 我们不 return 立刻退出；后面的 validate / 保存逻辑会执行一次，然后 main 返回/结束
+            end_due_to_steps = True
+        else:
+            end_due_to_steps = False
+
+        # 验证并记录 epoch 级别日志（如果在 step 模式下很可能在中间某个 epoch 提前结束，但我们仍做一次 validate）
+        val_log = validate(args, model, val_loader, criterion, device, args.batch_size)
+        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')
+
+        # 如果是因为 steps 模式达到上限，则在完成 validation / 保存后退出训练
+        if end_due_to_steps:
+            if rank == 0:
+                print(f"[Main] 已在 steps 模式下完成最后一次验证并保存，训练结束（global_step={global_step}）。")
+            break
+
+        # 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