Add files using upload-large-folder tool

CorrNet_Plus/CorrNet_Plus_CSLR/README.md

@@ -0,0 +1,162 @@
+# CorrNet+_CSLR
+This repo holds codes of the paper: CorrNet+: Sign Language Recognition and Translation via Spatial-Temporal Correlation, which is an extension of our previous work (CVPR 2023) [[paper]](https://arxiv.org/abs/2303.03202)
+
+This sub-repo holds the code for supporting the continuous sign language recognition task with CorrNet+.
+
+(**Update on 2025/01/28**) We release a demo for Continuous sign language recognition that supports multi-images and video inputs! You can watch the demo video to watch its effects, or deploy a demo locally to test its performance. 
+
+https://github.com/user-attachments/assets/a7354510-e5e0-44af-b283-39707f625a9b
+
+<div align=center>
+The web demo video
+</div>
+
+## Prerequisites
+
+- This project is implemented in Pytorch (better >=1.13 to be compatible with ctcdecode or these may exist errors). Thus please install Pytorch first.
+
+- ctcdecode==0.4 [[parlance/ctcdecode]](https://github.com/parlance/ctcdecode)，for beam search decode.
+
+- [Optional] sclite [[kaldi-asr/kaldi]](https://github.com/kaldi-asr/kaldi), install kaldi tool to get sclite for evaluation. After installation, create a soft link toward the sclite: 
+  `mkdir ./software`
+  `ln -s PATH_TO_KALDI/tools/sctk-2.4.10/bin/sclite ./software/sclite`
+
+   You may use the python version evaluation tool for convenience (by setting 'evaluate_tool' as 'python' in line 16 of ./configs/baseline.yaml), but sclite can provide more detailed statistics.
+
+- You can install other required modules by conducting 
+   `pip install -r requirements.txt`
+
+## Implementation
+The implementation for the CorrNet+ is given in [./modules/resnet.py](https://github.com/hulianyuyy/CorrNet_Plus/CorrNet_Plus_CSLR/modules/resnet.py).  
+
+It's then equipped with after each stage in ResNet in line 195 [./modules/resnet.py](https://github.com/hulianyuyy/CorrNet_Plus/CorrNet_Plus_CSLR/modules/resnet.py).
+
+We later found that the Identification Module with only spatial decomposition could perform on par with what we report in the paper (spatial-temporal decomposition) and is slighter faster, and thus implement it as such.
+
+## Data Preparation
+You can choose any one of following datasets to verify the effectiveness of CorrNet+.
+
+### PHOENIX2014 dataset
+1. Download the RWTH-PHOENIX-Weather 2014 Dataset [[download link]](https://www-i6.informatik.rwth-aachen.de/~koller/RWTH-PHOENIX/). Our experiments based on phoenix-2014.v3.tar.gz.
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET/phoenix2014-release ./dataset/phoenix2014`
+
+3. The original image sequence is 210x260, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess.py --process-image --multiprocessing
+   ```
+
+### PHOENIX2014-T dataset
+1. Download the RWTH-PHOENIX-Weather 2014 Dataset [[download link]](https://www-i6.informatik.rwth-aachen.de/~koller/RWTH-PHOENIX-2014-T/)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET/PHOENIX-2014-T-release-v3/PHOENIX-2014-T ./dataset/phoenix2014-T`
+
+3. The original image sequence is 210x260, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-T.py --process-image --multiprocessing
+   ```
+
+if you get an error like ```IndexError: list index out of range``` on the PHOENIX2014-T dataset, you may refer to [this issue](https://github.com/hulianyuyy/CorrNet/issues/10#issuecomment-1660363025) to tackle the problem.
+### CSL dataset
+
+1. Request the CSL Dataset from this website [[download link]](https://ustc-slr.github.io/openresources/cslr-dataset-2015/index.html)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET ./dataset/CSL`
+
+3. The original image sequence is 1280x720, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-CSL.py --process-image --multiprocessing
+   ``` 
+
+### CSL-Daily dataset
+
+1. Request the CSL-Daily Dataset from this website [[download link]](http://home.ustc.edu.cn/~zhouh156/dataset/csl-daily/)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET ./dataset/CSL-Daily`
+
+3. The original image sequence is 1280x720, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-CSL-Daily.py --process-image --multiprocessing
+   ``` 
+
+## Inference
+
+### PHOENIX2014 dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                             |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 18.0%      | 18.2%       | [[Baidu]](https://pan.baidu.com/s/1vlCMSuqZiZkvidg4wrDlZQ?pwd=w5w9) <br />[[Google Drive]](https://drive.google.com/file/d/1jcRv4Gl98mvS4mmLH5dBU_-iN3qGq8Si/view?usp=sharing) |
+
+
+### PHOENIX2014-T dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                             |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 17.2%      | 19.1%       | [[Baidu]](https://pan.baidu.com/s/1PcQtWOhiTEq9RFgBZ2hWhQ?pwd=nm3c) <br />[[Google Drive]](https://drive.google.com/file/d/1uBaKoB2JaB3ydYXmpn1tv0mBZ7cAF8J9/view?usp=sharing) |
+
+### CSL-Daily dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                            |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 28.6%      | 28.2%       | [[Baidu]](https://pan.baidu.com/s/1SbulBImqn78FEYFZV5Oz1w?pwd=mx8m) <br />[[Google Drive]](https://drive.google.com/file/d/1Ve_uzEB1teTmebuQ1XAMFQ0UV0EVEGyM/view?usp=sharing) |
+
+
+​	To evaluate the pretrained model, choose the dataset from phoenix2014/phoenix2014-T/CSL/CSL-Daily in line 3 in ./config/baseline.yaml first, and run the command below：   
+`python main.py --config ./config/baseline.yaml --device your_device --load-weights path_to_weight.pt --phase test`
+
+## Training
+
+The priorities of configuration files are: command line > config file > default values of argparse. To train the SLR model, run the command below:
+
+`python main.py --config ./config/baseline.yaml --device your_device`
+
+Note that you can choose the target dataset from phoenix2014/phoenix2014-T/CSL/CSL-Daily in line 3 in ./config/baseline.yaml.
+
+## Visualizations
+For Grad-CAM visualization of spatial weight maps, you can replace the resnet.py under "./modules" with the resnet.py under "./weight_map_generation", and then run ```python generate_weight_map.py``` with your own hyperparameters. 
+
+For Grad-CAM visualization of correlation maps, you can replace the resnet.py under "./modules" with the resnet.py under "./corr_map_generation", and then run ```python generate_corr_map.py``` with your own hyperparameters.
+
+### Test with one video input
+Except performing inference on datasets, we provide a `test_one_video.py` to perform inference with only one video input. An example command is 
+
+`python test_one_video.py --model_path /path_to_pretrained_weights --video_path /path_to_your_video --device your_device`
+
+The `video_path` can be the path to a video file or a dir contains extracted images from a video.
+
+Acceptable paramters:
+- `model_path`, the path to pretrained weights.
+- `video_path`, the path to a video file or a dir contains extracted images from a video.
+- `device`, which device to run inference, default=0.
+- `language`, the target sign language, default='phoenix', choices=['phoenix', 'csl'].
+- `max_frames_num`, the max input frames sampled from an input video, default=360.
+
+### Demo
+We provide a demo to allow deploying continuous sign language recognition models locally to test its effects. The demo page is shown as follows.
+<div align=center>
+<img width="800" src="./demo.jpg"/>
+<h4> The page of our demo</h4>
+</div>
+The demo video can be found in the top of this page. An example command is 
+
+`python demo.py --model_path /path_to_pretrained_weights --device your_device`
+
+Acceptable paramters:
+- `model_path`, the path to pretrained weights.
+- `device`, which device to run inference, default=0.
+- `language`, the target sign language, default='phoenix', choices=['phoenix', 'csl'].
+- `max_frames_num`, the max input frames sampled from an input video, default=360.
+
+After running the command, you can visit `http://0.0.0.0:7862` to play with the demo. You can also change it into an public URL by setting `share=True` in line 176 in `demo.py`.

CorrNet_Plus/CorrNet_Plus_CSLR/configs/CSL-Daily.yaml

@@ -0,0 +1,4 @@
+dataset_root: ./dataset/CSL-Daily
+dict_path: ./preprocess/CSL-Daily/gloss_dict.npy
+evaluation_dir: ./evaluation/slr_eval
+evaluation_prefix: CSL-Daily-groundtruth

CorrNet_Plus/CorrNet_Plus_CSLR/configs/phoenix2014-T.yaml

@@ -0,0 +1,4 @@
+dataset_root: ./dataset/phoenix2014-T
+dict_path: ./preprocess/phoenix2014-T/gloss_dict.npy
+evaluation_dir: ./evaluation/slr_eval
+evaluation_prefix: phoenix2014-T-groundtruth

CorrNet_Plus/CorrNet_Plus_CSLR/corr_map_generation/resnet.py

@@ -0,0 +1,350 @@
+import torch
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+import cv2
+import numpy as np
+import os
+__all__ = [
+    'ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+    'resnet152', 'resnet200'
+]
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None, clusters=1):
+        super().__init__()
+        #self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+        self.clusters = clusters
+        self.query = nn.Parameter(torch.rand(self.clusters, 1, embed_dim), requires_grad=True)
+
+    def forward(self, x):
+        N, C, T, H, W= x.shape
+        x = x.flatten(start_dim=3).permute(3, 0, 2, 1).reshape(-1, N*T, C).contiguous()  # NCTHW -> (HW)(NT)C
+        #x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)(NT)C
+        #x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)(NT)C
+        x, _ = F.multi_head_attention_forward(
+            #query=x[:1], key=x, value=x,
+            query=self.query.repeat(1,N*T,1), key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.view(self.clusters,N,T,C).contiguous().permute(1,3,2,0) #PNTC->NCTP
+
+class UnfoldTemporalWindows(nn.Module):
+    def __init__(self, window_size=9, window_stride=1, window_dilation=1):
+        super().__init__()
+        self.window_size = window_size
+        self.window_stride = window_stride
+        self.window_dilation = window_dilation
+
+        self.padding = (window_size + (window_size-1) * (window_dilation-1) - 1) // 2
+        self.unfold = nn.Unfold(kernel_size=(self.window_size, 1),
+                                dilation=(self.window_dilation, 1),
+                                stride=(self.window_stride, 1),
+                                padding=(self.padding, 0))
+
+    def forward(self, x):
+        # Input shape: (N,C,T,H,W), out: (N,C,T,V*window_size)
+        N, C, T, H, W = x.shape
+        x = x.view(N, C, T, H*W)
+        x = self.unfold(x)  #(N, C*Window_Size, T, H*W)
+        # Permute extra channels from window size to the graph dimension; -1 for number of windows
+        x = x.view(N, C, self.window_size, T, H, W).permute(0,1,3,2,4,5).reshape(N, C, T, self.window_size, H, W).contiguous()# NCTSHW
+        return x
+
+class Temporal_weighting(nn.Module):
+    def __init__(self, input_size ):
+        super().__init__()
+        hidden_size = input_size//16
+        self.conv_transform = nn.Conv1d(input_size, hidden_size, kernel_size=1, stride=1, padding=0)
+        self.conv_back = nn.Conv1d(hidden_size, input_size, kernel_size=1, stride=1, padding=0)
+        self.num = 3
+        self.conv_enhance = nn.ModuleList([
+            nn.Conv1d(hidden_size, hidden_size, kernel_size=3, stride=1, padding=int(i+1), groups=hidden_size, dilation=int(i+1)) for i in range(self.num)
+        ])
+        self.weights = nn.Parameter(torch.ones(self.num) / self.num, requires_grad=True)
+        self.alpha = nn.Parameter(torch.zeros(1), requires_grad=True)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        out = self.conv_transform(x.mean(-1).mean(-1))
+        aggregated_out = 0
+        for i in range(self.num):
+            aggregated_out += self.conv_enhance[i](out) * self.weights[i]
+        out = self.conv_back(aggregated_out)
+        return x*(F.sigmoid(out.unsqueeze(-1).unsqueeze(-1))-0.5) * self.alpha
+
+class Get_Correlation(nn.Module):
+    def __init__(self, channels, neighbors=3):
+        super().__init__()
+        reduction_channel = channels//16
+
+        self.down_conv2 = nn.Conv3d(channels, channels, kernel_size=1, bias=False)
+        self.neighbors = neighbors
+        self.clusters = 1
+        self.weights2 = nn.Parameter(torch.ones(self.neighbors*2) / (self.neighbors*2), requires_grad=True)
+        self.unfold = UnfoldTemporalWindows(2*self.neighbors+1)
+        self.weights3 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.weights4 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.attpool = AttentionPool2d(spacial_dim=None, embed_dim=channels, num_heads=1, clusters=self.clusters)
+        self.mlp = nn.Sequential(nn.Conv3d(channels, reduction_channel, kernel_size=1),
+                                 nn.GELU(),
+                                nn.Conv3d(reduction_channel, channels, kernel_size=1),)
+
+        # For generating aggregated_x with multi-scale conv
+        self.down_conv = nn.Conv3d(channels, reduction_channel, kernel_size=1, bias=False)
+        self.spatial_aggregation1 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,1,1), groups=reduction_channel)
+        self.spatial_aggregation2 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,2,2), dilation=(1,2,2), groups=reduction_channel)
+        self.spatial_aggregation3 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,3,3), dilation=(1,3,3), groups=reduction_channel)
+        self.weights = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.conv_back = nn.Conv3d(reduction_channel, channels, kernel_size=1, bias=False)
+
+    def forward(self, x, return_affinity=False):
+        N, C, T, H, W = x.shape
+        def clustering(query, key):
+            affinities = torch.einsum('bctp,bctl->btpl', query, key)
+            return torch.einsum('bctl,btpl->bctp', key, F.sigmoid(affinities)-0.5), affinities
+
+        x_mean = x.mean(3, keepdim=True).mean(4, keepdim=False)
+        x_max = x.max(-1, keepdim=False)[0].max(-1, keepdim=True)[0]
+        x_att = self.attpool(x) #NCTP
+        x2 = self.down_conv2(x)
+        upfold = self.unfold(x2)
+        upfold = (torch.concat([upfold[:,:,:,:self.neighbors], upfold[:,:,:,self.neighbors+1:]],3)* self.weights2.view(1, 1, 1, -1, 1, 1)).view(N, C, T, -1) #NCT(SHW)
+        x_mean = x_mean*self.weights4[0] + x_max*self.weights4[1] + x_att*self.weights4[2]
+        x_mean, affinities = clustering(x_mean, upfold)
+        features = x_mean.view(N, C, T, self.clusters, 1)
+
+        x_down = self.down_conv(x)
+        aggregated_x = self.spatial_aggregation1(x_down)*self.weights[0] + self.spatial_aggregation2(x_down)*self.weights[1] \
+                    + self.spatial_aggregation3(x_down)*self.weights[2]
+        aggregated_x = self.conv_back(aggregated_x)
+        
+        features = features * (F.sigmoid(aggregated_x)-0.5)
+        if not return_affinity:
+            return features
+        else:
+            return features, affinities[0,:,0].view(-1, 2*self.neighbors, H, W)  #T(2*neighbors)HW 
+
+def conv3x3(in_planes, out_planes, stride=1):
+    # 3x3x3 convolution with padding
+    return nn.Conv3d(
+        in_planes,
+        out_planes,
+        kernel_size=(1,3,3),
+        stride=(1,stride,stride),
+        padding=(0,1,1),
+        bias=False)
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv3d(3, 64, kernel_size=(1,7,7), stride=(1,2,2), padding=(0,3,3),
+                               bias=False)
+        self.bn1 = nn.BatchNorm3d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1))
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.corr2 = Get_Correlation(self.inplanes, neighbors=1)
+        self.temporal_weight2 = Temporal_weighting(self.inplanes)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.corr3 = Get_Correlation(self.inplanes, neighbors=3)
+        self.temporal_weight3 = Temporal_weighting(self.inplanes)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.corr4 = Get_Correlation(self.inplanes, neighbors=5)
+        self.temporal_weight4 = Temporal_weighting(self.inplanes)
+        self.alpha = nn.Parameter(torch.zeros(3), requires_grad=True)
+        self.avgpool = nn.AvgPool2d(7, stride=1)
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+        
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d) or isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv3d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=(1,stride,stride), bias=False),
+                nn.BatchNorm3d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x, dataset):
+        N, C, T, H, W = x.size()
+        vid = x
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x) 
+        x = x + self.corr2(x) * self.alpha[0]
+        x = x + self.temporal_weight2(x)
+        x = self.layer3(x)
+
+        print(f'self.alpha: {self.alpha}')
+        update_feature, affinities = self.corr3(x, return_affinity=True)  #bcthw, shw
+        x = x + update_feature * self.alpha[1]
+        show_corr_img(vid[0].permute(1,0,2,3), affinities, out_dir=f'./corr_map_layer3', clear_folder=True, dataset=dataset) #tchw, t(2*neighbors)hw
+
+        x = x + self.temporal_weight3(x)
+        x = self.layer4(x)
+        x = x + self.corr4(x) * self.alpha[2]
+        x = x + self.temporal_weight4(x)
+        
+        x = x.transpose(1,2).contiguous()
+        x = x.view((-1,)+x.size()[2:]) #bt,c,h,w
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1) #bt,c
+        x = self.fc(x) #bt,c
+
+        return x
+
+def show_corr_img(img, affinities, out_dir='./corr_map', clear_folder=False, dataset='phoenix2014'):  # img: chw, feature_map: chw, grads: chw3
+    affinities = affinities.cpu().data.numpy()
+    if clear_folder:
+        if not os.path.exists(out_dir):
+            os.makedirs(out_dir)
+        else:
+            import shutil
+            shutil.rmtree(out_dir)
+            os.makedirs(out_dir)
+
+    predefined_padding = 6 # Note that there are 6 paddings in advance in the left/right
+    T, S, H, W = affinities.shape	
+    neighbors = S//2	
+    for t in range(predefined_padding, T-predefined_padding+1):
+        current_dir = out_dir + '/' + f'timestep_{t-predefined_padding}'
+        os.makedirs(current_dir)
+        for i in range(S):
+            if 'phoenix' in dataset:
+                out_cam = affinities[t,i]  # only set as negative when alpha is positive for the layer
+            else:
+                out_cam = -affinities[t,i] 
+            out_cam = out_cam - np.min(out_cam)
+            out_cam = out_cam / (1e-7 + out_cam.max())
+            out_cam = cv2.resize(out_cam, (img.shape[2], img.shape[3]))
+            out_cam = (255 * out_cam).astype(np.uint8)
+            heatmap = cv2.applyColorMap(out_cam, cv2.COLORMAP_JET)
+            # img[neighbors] is the current image
+            if i<neighbors:
+                cam_img = np.float32(heatmap) / 255 + (img[t-(neighbors-i)]/2+0.5).permute(1,2,0).cpu().data.numpy()
+            else:
+                cam_img = np.float32(heatmap) / 255 + (img[t+(i-neighbors)+1]/2+0.5).permute(1,2,0).cpu().data.numpy()
+            cam_img = cam_img/np.max(cam_img)
+            cam_img = np.uint8(255 * cam_img)
+            # img[neighbors] is the current image
+            if i<neighbors:
+                cv2.imwrite(f'{current_dir}/corr_map_{i}.jpg', cam_img)
+            else:
+                cv2.imwrite(f'{current_dir}/corr_map_{i+1}.jpg', cam_img)
+        current_img = (img[t]/2+0.5).permute(1,2,0).cpu().data.numpy()
+        current_img = current_img/np.max(current_img)
+        current_img = np.uint8(255 * current_img)
+        #interval = img.shape[2]//H
+        #current_img[i*interval:(i+1)*interval, j*interval:(j+1)*interval,:] = np.array([0,0,255])  #red
+        cv2.imwrite(f'{current_dir}/corr_map_{neighbors}_current.jpg', current_img)
+
+def resnet18(**kwargs):
+    """Constructs a ResNet-18 based model.
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    checkpoint = model_zoo.load_url(model_urls['resnet18'], map_location=torch.device('cpu'))
+    layer_name = list(checkpoint.keys())
+    for ln in layer_name :
+        if 'conv' in ln or 'downsample.0.weight' in ln:
+            checkpoint[ln] = checkpoint[ln].unsqueeze(2)  
+    model.load_state_dict(checkpoint, strict=False)
+    del checkpoint
+    import gc
+    gc.collect()
+    return model
+
+
+def resnet34(**kwargs):
+    """Constructs a ResNet-34 model.
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    return model
+
+def test():
+    net = resnet18()
+    y = net(torch.randn(1,3,224,224))
+    print(y.size())
+
+#test()

CorrNet_Plus/CorrNet_Plus_CSLR/dataset/dataloader_video.py

@@ -0,0 +1,197 @@
+import os
+import cv2
+import sys
+import pdb
+import six
+import glob
+import time
+import torch
+import random
+import pandas
+import warnings
+
+warnings.simplefilter(action='ignore', category=FutureWarning)
+
+import numpy as np
+# import pyarrow as pa
+from PIL import Image
+import torch.utils.data as data
+import matplotlib.pyplot as plt
+from utils import video_augmentation
+from torch.utils.data.sampler import Sampler
+
+sys.path.append("..")
+global kernel_sizes 
+
+class BaseFeeder(data.Dataset):
+    def __init__(self, prefix, gloss_dict, dataset='phoenix2014', drop_ratio=1, num_gloss=-1, mode="train", transform_mode=True,
+                 datatype="lmdb", frame_interval=1, image_scale=1.0, kernel_size=1, input_size=224):
+        self.mode = mode
+        self.ng = num_gloss
+        self.prefix = prefix
+        self.dict = gloss_dict
+        self.data_type = datatype
+        self.dataset = dataset
+        self.input_size = input_size
+        global kernel_sizes 
+        kernel_sizes = kernel_size
+        self.frame_interval = frame_interval # not implemented for read_features()
+        self.image_scale = image_scale # not implemented for read_features()
+        self.feat_prefix = f"{prefix}/features/fullFrame-256x256px/{mode}"
+        self.transform_mode = "train" if transform_mode else "test"
+        self.inputs_list = np.load(f"./preprocess/{dataset}/{mode}_info.npy", allow_pickle=True).item()
+        # self.inputs_list = np.load(f"{prefix}/annotations/manual/{mode}.corpus.npy", allow_pickle=True).item()
+        # self.inputs_list = np.load(f"{prefix}/annotations/manual/{mode}.corpus.npy", allow_pickle=True).item()
+        # self.inputs_list = dict([*filter(lambda x: isinstance(x[0], str) or x[0] < 10, self.inputs_list.items())])
+        print(mode, len(self))
+        self.data_aug = self.transform()
+        print("")
+
+    def __getitem__(self, idx):
+        if self.data_type == "video":
+            input_data, label, fi = self.read_video(idx)
+            input_data, label = self.normalize(input_data, label)
+            # input_data, label = self.normalize(input_data, label, fi['fileid'])
+            return input_data, torch.LongTensor(label), self.inputs_list[idx]['original_info']
+        elif self.data_type == "lmdb":
+            input_data, label, fi = self.read_lmdb(idx)
+            input_data, label = self.normalize(input_data, label)
+            return input_data, torch.LongTensor(label), self.inputs_list[idx]['original_info']
+        else:
+            input_data, label = self.read_features(idx)
+            return input_data, label, self.inputs_list[idx]['original_info']
+
+    def read_video(self, index):
+        # load file info
+        fi = self.inputs_list[index]
+        if 'phoenix' in self.dataset:
+            img_folder = os.path.join(self.prefix, "features/fullFrame-256x256px/" + fi['folder'])  
+        elif self.dataset == 'CSL':
+            img_folder = os.path.join(self.prefix, "features/fullFrame-256x256px/" + fi['folder'] + "/*.jpg")
+        elif self.dataset == 'CSL-Daily':
+            img_folder = os.path.join(self.prefix, fi['folder'])
+        img_list = sorted(glob.glob(img_folder))
+        img_list = img_list[int(torch.randint(0, self.frame_interval, [1]))::self.frame_interval]
+        label_list = []
+        for phase in fi['label'].split(" "):
+            if phase == '':
+                continue
+            if phase in self.dict.keys():
+                label_list.append(self.dict[phase][0])
+        return [cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB) for img_path in img_list], label_list, fi
+
+    def read_features(self, index):
+        # load file info
+        fi = self.inputs_list[index]
+        data = np.load(f"./features/{self.mode}/{fi['fileid']}_features.npy", allow_pickle=True).item()
+        return data['features'], data['label']
+
+    def normalize(self, video, label, file_id=None):
+        video, label = self.data_aug(video, label, file_id)
+        video = video.float() / 127.5 - 1
+        return video, label
+
+    def transform(self):
+        if self.transform_mode == "train":
+            print("Apply training transform.")
+            return video_augmentation.Compose([
+                # video_augmentation.CenterCrop(224),
+                # video_augmentation.WERAugment('/lustre/wangtao/current_exp/exp/baseline/boundary.npy'),
+                video_augmentation.RandomCrop(self.input_size),
+                video_augmentation.RandomHorizontalFlip(0.5),
+                video_augmentation.Resize(self.image_scale),
+                video_augmentation.ToTensor(),
+                video_augmentation.TemporalRescale(0.2, self.frame_interval),
+            ])
+        else:
+            print("Apply testing transform.")
+            return video_augmentation.Compose([
+                video_augmentation.CenterCrop(self.input_size),
+                video_augmentation.Resize(self.image_scale),
+                video_augmentation.ToTensor(),
+            ])
+
+    def byte_to_img(self, byteflow):
+        unpacked = pa.deserialize(byteflow)
+        imgbuf = unpacked[0]
+        buf = six.BytesIO()
+        buf.write(imgbuf)
+        buf.seek(0)
+        img = Image.open(buf).convert('RGB')
+        return img
+
+    @staticmethod
+    def collate_fn(batch):
+        batch = [item for item in sorted(batch, key=lambda x: len(x[0]), reverse=True)]
+        video, label, info = list(zip(*batch))
+        
+        left_pad = 0
+        last_stride = 1
+        total_stride = 1
+        global kernel_sizes 
+        for layer_idx, ks in enumerate(kernel_sizes):
+            if ks[0] == 'K':
+                left_pad = left_pad * last_stride 
+                left_pad += int((int(ks[1])-1)/2)
+            elif ks[0] == 'P':
+                last_stride = int(ks[1])
+                total_stride = total_stride * last_stride
+        if len(video[0].shape) > 3:
+            max_len = len(video[0])
+            video_length = torch.LongTensor([np.ceil(len(vid) / total_stride) * total_stride + 2*left_pad for vid in video])
+            right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+            max_len = max_len + left_pad + right_pad
+            padded_video = [torch.cat(
+                (
+                    vid[0][None].expand(left_pad, -1, -1, -1),
+                    vid,
+                    vid[-1][None].expand(max_len - len(vid) - left_pad, -1, -1, -1),
+                )
+                , dim=0)
+                for vid in video]
+            padded_video = torch.stack(padded_video)
+        else:
+            max_len = len(video[0])
+            video_length = torch.LongTensor([len(vid) for vid in video])
+            padded_video = [torch.cat(
+                (
+                    vid,
+                    vid[-1][None].expand(max_len - len(vid), -1),
+                )
+                , dim=0)
+                for vid in video]
+            padded_video = torch.stack(padded_video).permute(0, 2, 1)
+        label_length = torch.LongTensor([len(lab) for lab in label])
+        if max(label_length) == 0:
+            return padded_video, video_length, [], [], info
+        else:
+            padded_label = []
+            for lab in label:
+                padded_label.extend(lab)
+            padded_label = torch.LongTensor(padded_label)
+            return padded_video, video_length, padded_label, label_length, info
+
+    def __len__(self):
+        return len(self.inputs_list) - 1
+
+    def record_time(self):
+        self.cur_time = time.time()
+        return self.cur_time
+
+    def split_time(self):
+        split_time = time.time() - self.cur_time
+        self.record_time()
+        return split_time
+
+
+if __name__ == "__main__":
+    feeder = BaseFeeder()
+    dataloader = torch.utils.data.DataLoader(
+        dataset=feeder,
+        batch_size=1,
+        shuffle=True,
+        drop_last=True,
+        num_workers=0,
+    )
+    for data in dataloader:
+        pdb.set_trace()

CorrNet_Plus/CorrNet_Plus_CSLR/demo.py

@@ -0,0 +1,176 @@
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+from PIL import Image
+import argparse
+
+import numpy as np
+VIDEO_FORMATS = [".mp4", ".avi", ".mov", ".mkv"]
+os.environ['GRADIO_TEMP_DIR'] = 'gradio_temp'
+import gradio as gr
+import os
+import warnings
+from decord import VideoReader, cpu
+warnings.filterwarnings("ignore")
+
+def is_image_by_extension(file_path):
+    _, file_extension = os.path.splitext(file_path)
+
+    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp']
+
+    return file_extension.lower() in image_extensions
+
+def load_video(video_path, max_frames_num=360):
+    if type(video_path) == str:
+        vr = VideoReader(video_path, ctx=cpu(0))
+    elif type(video_path) == list:
+        vr = VideoReader(video_path[0], ctx=cpu(0))
+    else:
+        raise ValueError(f"Not support video input : {type(video_path)}")
+    total_frame_num = len(vr)
+    if total_frame_num> max_frames_num:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, max_frames_num, dtype=int)
+    else:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, dtype=int)
+    frame_idx = uniform_sampled_frames.tolist()
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    return [cv2.cvtColor(tmp, cv2.COLOR_BGR2RGB) for tmp in spare_frames]  # (frames, height, width, channels)
+
+def run_inference(inputs):
+    """
+    Run inference on one input sample.
+
+    Args:
+        args: Command-line arguments.
+    """
+    img_list = []
+    if isinstance(inputs, list):  # Multi-image case
+        for x in inputs:
+            if is_image_by_extension(x):
+                img_list.append(cv2.cvtColor(cv2.imread(x), cv2.COLOR_BGR2RGB) )
+
+    elif os.path.splitext(inputs)[-1] in VIDEO_FORMATS: # Video case
+        try:
+            img_list = load_video(inputs, args.max_frames_num)  # frames [height, width, channels]
+        except Exception as e:
+            raise ValueError(f"Error {e} in loading video")
+    else:
+        raise ValueError("Video path is incorrect!")
+
+    transform = video_augmentation.Compose([
+                    video_augmentation.CenterCrop(224),
+                    video_augmentation.Resize(1.0),
+                    video_augmentation.ToTensor(),
+                ])
+    vid, label = transform(img_list, None, None)
+    vid = vid.float() / 127.5 - 1
+    vid = vid.unsqueeze(0)
+
+    left_pad = 0
+    last_stride = 1
+    total_stride = 1
+    kernel_sizes = ['K5', "P2", 'K5', "P2"]
+    for layer_idx, ks in enumerate(kernel_sizes):
+        if ks[0] == 'K':
+            left_pad = left_pad * last_stride 
+            left_pad += int((int(ks[1])-1)/2)
+        elif ks[0] == 'P':
+            last_stride = int(ks[1])
+            total_stride = total_stride * last_stride
+
+    max_len = vid.size(1)
+    video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+    right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+    max_len = max_len + left_pad + right_pad
+    vid = torch.cat(
+        (
+            vid[0,0][None].expand(left_pad, -1, -1, -1),
+            vid[0],
+            vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+        )
+        , dim=0).unsqueeze(0)
+
+    vid = device.data_to_device(vid)
+    vid_lgt = device.data_to_device(video_length)
+    ret_dict = model(vid, vid_lgt, label=None, label_lgt=None)
+    return ret_dict['recognized_sents'] # [[('ICH', 0), ('LUFT', 1), ('WETTER', 2), ('GERADE', 3), ('loc-SUEDWEST', 4), ('TEMPERATUR', 5), ('__PU__', 6), ('KUEHL', 7), ('SUED', 8), ('WARM', 9), ('ICH', 10), ('IX', 11)]]
+
+
+def parse_args():
+    """
+    Parse command-line arguments.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_path", type=str, help="The path to pretrained weights")
+    parser.add_argument("--device", type=int, default=0)
+    parser.add_argument("--language", type=str, default='phoenix', choices=['phoenix', 'csl'])
+    parser.add_argument("--max_frames_num", type=int, default=360)
+    
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Load tokenizer, model and image processor
+    model_path = os.path.expanduser(args.model_path)
+    
+    device_id = args.device  # specify which gpu to use
+    if args.language == 'phoenix':
+        dataset = 'phoenix2014' 
+    elif args.language == 'csl':
+        dataset = 'CSL-Daily' 
+    else:
+        raise ValueError("Please select target language from ['phoenix', 'csl'] in your command")
+
+    model_weights = args.model_path
+
+    # Load data and apply transformation
+    dict_path = f'./preprocess/{dataset}/gloss_dict.npy'  # Use the gloss dict of phoenix14 dataset 
+    gloss_dict = np.load(dict_path, allow_pickle=True).item()
+
+    device = utils.GpuDataParallel()
+    device.set_device(device_id)
+    # Define model and load state-dict
+    model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+                loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+    state_dict = torch.load(model_weights)['model_state_dict']
+    state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+    model.load_state_dict(state_dict, strict=True)
+    model = model.to(device.output_device)
+    model.cuda()
+
+    model.eval()
+
+    def identity(x):
+        return x
+
+    with gr.Blocks(title='Continuous sign language recognition') as demo: 
+        gr.Markdown("<center><font size=5>Continuous sign language recognition</center></font>")
+        gr.Markdown("**Upload multiple images or a video** to get the recognized glossess.")
+        with gr.Tab('Multi-Images'):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    multiple_image_show = gr.Gallery(label="Show the input images", height=200)
+                    Multi_image_input = gr.UploadButton(label="Click to upload multiple images", file_types = ['.png','.jpg','.jpeg', '.bmp'], file_count = "multiple")
+                    multiple_image_button = gr.Button("Run")  
+                with gr.Column(scale=1):
+                    multiple_image_output = gr.Textbox(label="Output")
+        with gr.Tab('Video'):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    Video_input = gr.Video(sources=["upload"], label="Upload a video file")
+                    video_button = gr.Button("Run")  
+                with gr.Column(scale=1):
+                    video_output = gr.Textbox(label="Output")
+        multiple_image_button.click(identity, inputs=[Multi_image_input], outputs=multiple_image_show)
+        multiple_image_button.click(run_inference, inputs=Multi_image_input, outputs=multiple_image_output)
+        video_button.click(run_inference, inputs=Video_input, outputs=video_output)
+        
+    demo.launch(share=False,server_name="0.0.0.0", server_port=7862)

CorrNet_Plus/CorrNet_Plus_CSLR/generate_corr_map.py

@@ -0,0 +1,88 @@
+#Ref: https://blog.csdn.net/weixin_41735859/article/details/106474768
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+
+gpu_id = 0 # The GPU to use
+dataset = 'phoenix2014' # support [phoenix2014, phoenix2014-T, CSL-Daily]
+prefix = './dataset/phoenix2014/phoenix-2014-multisigner' # ['./dataset/CSL-Daily', './dataset/phoenix2014-T', './dataset/phoenix2014/phoenix-2014-multisigner']
+dict_path = f'./preprocess/{dataset}/gloss_dict.npy'
+model_weights = 'path_to_model.pt'
+select_id = 539 # The video selected to show. 539 for 31October_2009_Saturday_tagesschau_default-8, 0 for 01April_2010_Thursday_heute_default-1, 1 for 01August_2011_Monday_heute_default-6, 2 for 01December_2011_Thursday_heute_default-3
+#name = '01April_2010_Thursday_heute_default-1'
+
+# Load data and apply transformation
+gloss_dict = np.load(dict_path, allow_pickle=True).item()
+inputs_list = np.load(f"./preprocess/{dataset}/dev_info.npy", allow_pickle=True).item()
+name = inputs_list[select_id]['fileid']
+print(f'Generating correlation maps for {name}')
+img_folder = os.path.join(prefix, "features/fullFrame-256x256px/" + inputs_list[select_id]['folder']) if 'phoenix' in dataset else os.path.join(prefix, inputs_list[select_id]['folder'])
+img_list = sorted(glob.glob(img_folder))
+img_list = [cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB) for img_path in img_list]
+label_list = []
+for phase in inputs_list[select_id]['label'].split(" "):
+    if phase == '':
+        continue
+    if phase in gloss_dict.keys():
+        label_list.append(gloss_dict[phase][0])
+transform = video_augmentation.Compose([
+                video_augmentation.CenterCrop(224),
+                video_augmentation.Resize(1.0),
+                video_augmentation.ToTensor(),
+            ])
+vid, label = transform(img_list, label_list, None)
+vid = vid.float() / 127.5 - 1
+vid = vid.unsqueeze(0)
+
+left_pad = 0
+last_stride = 1
+total_stride = 1
+kernel_sizes = ['K5', "P2", 'K5', "P2"]
+for layer_idx, ks in enumerate(kernel_sizes):
+    if ks[0] == 'K':
+        left_pad = left_pad * last_stride 
+        left_pad += int((int(ks[1])-1)/2)
+    elif ks[0] == 'P':
+        last_stride = int(ks[1])
+        total_stride = total_stride * last_stride
+
+max_len = vid.size(1)
+video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+max_len = max_len + left_pad + right_pad
+vid = torch.cat(
+    (
+        vid[0,0][None].expand(left_pad, -1, -1, -1),
+        vid[0],
+        vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+    )
+    , dim=0).unsqueeze(0)
+
+fmap_block = list()
+#grad_block = list()
+
+device = utils.GpuDataParallel()
+device.set_device(gpu_id)
+# Define model and load state-dict
+model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+            loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+state_dict = torch.load(model_weights)['model_state_dict']
+state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+model.load_state_dict(state_dict, strict=True)
+model = model.to(device.output_device)
+model.cuda()
+
+model.eval()
+
+print(vid.shape)
+vid = device.data_to_device(vid)
+vid_lgt = device.data_to_device(video_length)
+label = device.data_to_device([torch.LongTensor(label)])
+label_lgt = device.data_to_device(torch.LongTensor([len(label_list)]))
+ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt, dataset=dataset)

CorrNet_Plus/CorrNet_Plus_CSLR/generate_weight_map.py

@@ -0,0 +1,136 @@
+#Ref: https://blog.csdn.net/weixin_41735859/article/details/106474768
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+
+gpu_id = 0 # The GPU to use
+dataset = 'phoenix2014'  # support [phoenix2014, phoenix2014-T, CSL-Daily]
+prefix = './dataset/phoenix2014/phoenix-2014-multisigner'  # ['./dataset/CSL-Daily', './dataset/phoenix2014-T', './dataset/phoenix2014/phoenix-2014-multisigner']
+dict_path = f'./preprocess/{dataset}/gloss_dict.npy'
+model_weights = 'path_to_model.pt'
+select_id = 2 # The video selected to show. 539 for 31October_2009_Saturday_tagesschau_default-8, 0 for 01April_2010_Thursday_heute_default-1, 1 for 01August_2011_Monday_heute_default-6, 2 for 01December_2011_Thursday_heute_default-3
+#name = '01April_2010_Thursday_heute_default-1'
+
+# Load data and apply transformation
+gloss_dict = np.load(dict_path, allow_pickle=True).item()
+inputs_list = np.load(f"./preprocess/{dataset}/dev_info.npy", allow_pickle=True).item()
+name = inputs_list[select_id]['fileid']
+print(f'Generating CAM for {name}')
+img_folder = os.path.join(prefix, "features/fullFrame-256x256px/" + inputs_list[select_id]['folder']) if 'phoenix' in dataset else os.path.join(prefix, inputs_list[select_id]['folder'])
+img_list = sorted(glob.glob(img_folder))
+img_list = [cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB) for img_path in img_list]
+label_list = []
+for phase in inputs_list[select_id]['label'].split(" "):
+    if phase == '':
+        continue
+    if phase in gloss_dict.keys():
+        label_list.append(gloss_dict[phase][0])
+transform = video_augmentation.Compose([
+                video_augmentation.CenterCrop(224),
+                video_augmentation.Resize(1.0),
+                video_augmentation.ToTensor(),
+            ])
+vid, label = transform(img_list, label_list, None)
+vid = vid.float() / 127.5 - 1
+vid = vid.unsqueeze(0)
+
+left_pad = 0
+last_stride = 1
+total_stride = 1
+kernel_sizes = ['K5', "P2", 'K5', "P2"]
+for layer_idx, ks in enumerate(kernel_sizes):
+    if ks[0] == 'K':
+        left_pad = left_pad * last_stride 
+        left_pad += int((int(ks[1])-1)/2)
+    elif ks[0] == 'P':
+        last_stride = int(ks[1])
+        total_stride = total_stride * last_stride
+
+max_len = vid.size(1)
+video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+max_len = max_len + left_pad + right_pad
+vid = torch.cat(
+    (
+        vid[0,0][None].expand(left_pad, -1, -1, -1),
+        vid[0],
+        vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+    )
+    , dim=0).unsqueeze(0)
+
+fmap_block = list()
+
+device = utils.GpuDataParallel()
+device.set_device(gpu_id)
+# Define model and load state-dict
+model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+            loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+state_dict = torch.load(model_weights)['model_state_dict']
+state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+model.load_state_dict(state_dict, strict=True)
+model = model.to(device.output_device)
+model.cuda()
+
+model.train()
+
+def forward_hook(module, input, output):
+    fmap_block.append(output)       #N, C, T, H, ,W 
+if 'phoenix' in dataset:
+    model.conv2d.corr2.conv_back.register_forward_hook(forward_hook)	
+else:
+    model.conv2d.corr3.conv_back.register_forward_hook(forward_hook)  # For CSL-Daily
+#model.conv2d.layer4[-1].conv1.register_backward_hook(backward_hook)
+
+def cam_show_img(img, feature_map, grads, out_dir):  # img: ntchw, feature_map: ncthw, grads: ncthw
+    N, C, T, H, W = feature_map.shape
+    cam = np.zeros(feature_map.shape[2:], dtype=np.float32)	# thw
+    grads = grads[0,:].reshape([C, T, -1])					
+    weights = np.mean(grads, axis=-1)	
+    for i in range(C):						
+        for j in range(T):
+            cam[j] += weights[i,j] * feature_map[0, i, j, :, :]		
+    cam = np.maximum(cam, 0)					
+
+    if not os.path.exists(out_dir):
+        os.makedirs(out_dir)
+    else:
+        import shutil
+        shutil.rmtree(out_dir)
+        os.makedirs(out_dir)
+    for i in range(T):
+        out_cam = cam[i]
+        out_cam = out_cam - np.min(out_cam)
+        out_cam = out_cam / (1e-7 + out_cam.max())
+        out_cam = cv2.resize(out_cam, (img.shape[3], img.shape[4]))
+        out_cam = (255 * out_cam).astype(np.uint8)
+        heatmap = cv2.applyColorMap(out_cam, cv2.COLORMAP_JET)
+        cam_img = np.float32(heatmap) / 255 + (img[0,i]/2+0.5).permute(1,2,0).cpu().data.numpy()
+        cam_img = cam_img/np.max(cam_img)
+        cam_img = np.uint8(255 * cam_img)
+        path_cam_img = os.path.join(out_dir, f"cam_{i}.jpg")
+        cv2.imwrite(path_cam_img, cam_img)
+    print('Generate cam.jpg')
+
+print(vid.shape)
+vid = device.data_to_device(vid)
+vid_lgt = device.data_to_device(video_length)
+label = device.data_to_device([torch.LongTensor(label)])
+label_lgt = device.data_to_device(torch.LongTensor([len(label_list)]))
+ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt)
+
+model.zero_grad()
+for i in range(ret_dict['sequence_logits'].size(0)):
+    idx = np.argmax(ret_dict['sequence_logits'].cpu().data.numpy()[i,0])  #TBC
+    class_loss = ret_dict['sequence_logits'][i, 0, idx]
+    class_loss.backward(retain_graph=True)
+# 生成cam
+grads_val = torch.load('./weight_map.pth').cpu().data.numpy()
+fmap = fmap_block[0].cpu().data.numpy()
+# 保存cam图片
+cam_show_img(vid, fmap, grads_val, out_dir='./agg_map')

CorrNet_Plus/CorrNet_Plus_CSLR/main.py

@@ -0,0 +1,301 @@
+import os
+
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+import pdb
+import sys
+import cv2
+import yaml
+import torch
+import random
+import importlib
+import faulthandler
+import numpy as np
+import torch.nn as nn
+import shutil
+import inspect
+import time
+from collections import OrderedDict
+
+faulthandler.enable()
+import utils
+from modules.sync_batchnorm import convert_model
+from seq_scripts import seq_train, seq_eval, seq_feature_generation
+from torch.cuda.amp import autocast as autocast
+
+class Processor():
+    def __init__(self, arg):
+        self.arg = arg
+        if os.path.exists(self.arg.work_dir):
+            answer = input('Current dir exists, do you want to remove and refresh it?\n')
+            if answer in ['yes','y','ok','1']:
+                print('Dir removed !')
+                shutil.rmtree(self.arg.work_dir)
+                os.makedirs(self.arg.work_dir)
+            else:
+                print('Dir Not removed !')
+        else:
+            os.makedirs(self.arg.work_dir)
+        shutil.copy2(__file__, self.arg.work_dir)
+        shutil.copy2('./configs/baseline.yaml', self.arg.work_dir)
+        shutil.copy2('./modules/tconv.py', self.arg.work_dir)
+        shutil.copy2('./modules/resnet.py', self.arg.work_dir)
+        self.recoder = utils.Recorder(self.arg.work_dir, self.arg.print_log, self.arg.log_interval)
+        self.save_arg()
+        if self.arg.random_fix:
+            self.rng = utils.RandomState(seed=self.arg.random_seed)
+        self.device = utils.GpuDataParallel()
+        self.recoder = utils.Recorder(self.arg.work_dir, self.arg.print_log, self.arg.log_interval)
+        self.dataset = {}
+        self.data_loader = {}
+        self.gloss_dict = np.load(self.arg.dataset_info['dict_path'], allow_pickle=True).item()
+        self.arg.model_args['num_classes'] = len(self.gloss_dict) + 1
+        self.model, self.optimizer = self.loading()
+
+    def start(self):
+        if self.arg.phase == 'train':
+            best_dev = 100.0
+            best_epoch = 0
+            total_time = 0
+            epoch_time = 0
+            self.recoder.print_log('Parameters:\n{}\n'.format(str(vars(self.arg))))
+            seq_model_list = []
+            for epoch in range(self.arg.optimizer_args['start_epoch'], self.arg.num_epoch):
+                save_model = epoch % self.arg.save_interval == 0
+                eval_model = epoch % self.arg.eval_interval == 0
+                epoch_time = time.time()
+                # train end2end model
+                seq_train(self.data_loader['train'], self.model, self.optimizer,
+                          self.device, epoch, self.recoder)
+                if eval_model:
+                    dev_wer = seq_eval(self.arg, self.data_loader['dev'], self.model, self.device,
+                                       'dev', epoch, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+                    self.recoder.print_log("Dev WER: {:05.2f}%".format(dev_wer))
+                if dev_wer < best_dev:
+                    best_dev = dev_wer
+                    best_epoch = epoch
+                    model_path = "{}_best_model.pt".format(self.arg.work_dir)
+                    self.save_model(epoch, model_path)
+                    self.recoder.print_log('Save best model')
+                self.recoder.print_log('Best_dev: {:05.2f}, Epoch : {}'.format(best_dev, best_epoch))
+                if save_model:
+                    model_path = "{}dev_{:05.2f}_epoch{}_model.pt".format(self.arg.work_dir, dev_wer, epoch)
+                    seq_model_list.append(model_path)
+                    print("seq_model_list", seq_model_list)
+                    self.save_model(epoch, model_path)
+                epoch_time = time.time() - epoch_time
+                total_time += epoch_time
+                torch.cuda.empty_cache()
+                self.recoder.print_log('Epoch {} costs {} mins {} seconds'.format(epoch, int(epoch_time)//60, int(epoch_time)%60))
+            self.recoder.print_log('Training costs {} hours {} mins {} seconds'.format(int(total_time)//60//60, int(total_time)//60%60, int(total_time)%60))
+        elif self.arg.phase == 'test':
+            if self.arg.load_weights is None and self.arg.load_checkpoints is None:
+                print('Please appoint --weights.')
+            self.recoder.print_log('Model:   {}.'.format(self.arg.model))
+            self.recoder.print_log('Weights: {}.'.format(self.arg.load_weights))
+            # train_wer = seq_eval(self.arg, self.data_loader["train_eval"], self.model, self.device,
+            #                      "train", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            dev_wer = seq_eval(self.arg, self.data_loader["dev"], self.model, self.device,
+                               "dev", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            test_wer = seq_eval(self.arg, self.data_loader["test"], self.model, self.device,
+                                "test", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            self.recoder.print_log('Evaluation Done.\n')
+        elif self.arg.phase == "features":
+            for mode in ["train", "dev", "test"]:
+                seq_feature_generation(
+                    self.data_loader[mode + "_eval" if mode == "train" else mode],
+                    self.model, self.device, mode, self.arg.work_dir, self.recoder
+                )
+        elif self.arg.phase == 'finetune':
+            best_dev = 100.0
+            best_epoch = 0
+            total_time = 0
+            epoch_time = 0
+            self.recoder.print_log('Parameters:\n{}\n'.format(str(vars(self.arg))))
+            seq_model_list = []
+            for name, m in self.model.conv2d.named_modules():
+                m.requires_grad = False
+            for name, m in self.model.conv1d.named_modules():
+                if 'fc' not in name:
+                    m.requires_grad = False
+            for name, m in self.model.temporal_model.named_modules():
+                m.requires_grad = False
+            from slr_network import NormLinear
+            self.model.classifier = NormLinear(1024, len(self.gloss_dict) + 1).cuda()
+            self.model.conv1d.fc = self.model.classifier
+
+            for epoch in range(self.arg.optimizer_args['start_epoch'], self.arg.num_epoch):
+                save_model = epoch % self.arg.save_interval == 0
+                eval_model = epoch % self.arg.eval_interval == 0
+                epoch_time = time.time()
+                # train end2end model
+                seq_train(self.data_loader['train'], self.model, self.optimizer,
+                          self.device, epoch, self.recoder)
+                if eval_model:
+                    dev_wer = seq_eval(self.arg, self.data_loader['dev'], self.model, self.device,
+                                       'dev', epoch, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+                    self.recoder.print_log("Dev WER: {:05.2f}%".format(dev_wer))
+                if dev_wer < best_dev:
+                    best_dev = dev_wer
+                    best_epoch = epoch
+                    model_path = "{}_best_model.pt".format(self.arg.work_dir)
+                    self.save_model(epoch, model_path)
+                    self.recoder.print_log('Save best model')
+                self.recoder.print_log('Best_dev: {:05.2f}, Epoch : {}'.format(best_dev, best_epoch))
+                if save_model:
+                    model_path = "{}dev_{:05.2f}_epoch{}_model.pt".format(self.arg.work_dir, dev_wer, epoch)
+                    seq_model_list.append(model_path)
+                    print("seq_model_list", seq_model_list)
+                    self.save_model(epoch, model_path)
+                epoch_time = time.time() - epoch_time
+                total_time += epoch_time
+                torch.cuda.empty_cache()
+                self.recoder.print_log('Epoch {} costs {} mins {} seconds'.format(epoch, int(epoch_time)//60, int(epoch_time)%60))
+            self.recoder.print_log('Training costs {} hours {} mins {} seconds'.format(int(total_time)//60//60, int(total_time)//60%60, int(total_time)%60))
+
+    def save_arg(self):
+        arg_dict = vars(self.arg)
+        if not os.path.exists(self.arg.work_dir):
+            os.makedirs(self.arg.work_dir)
+        with open('{}/config.yaml'.format(self.arg.work_dir), 'w') as f:
+            yaml.dump(arg_dict, f)
+
+    def save_model(self, epoch, save_path):
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': self.model.state_dict(),
+            'optimizer_state_dict': self.optimizer.state_dict(),
+            'scheduler_state_dict': self.optimizer.scheduler.state_dict(),
+            'rng_state': self.rng.save_rng_state(),
+        }, save_path)
+
+    def loading(self):
+        self.device.set_device(self.arg.device)
+        print("Loading model")
+        model_class = import_class(self.arg.model)
+        model = model_class(
+            **self.arg.model_args,
+            gloss_dict=self.gloss_dict,
+            loss_weights=self.arg.loss_weights,
+        )
+        shutil.copy2(inspect.getfile(model_class), self.arg.work_dir)
+        optimizer = utils.Optimizer(model, self.arg.optimizer_args)
+
+        if self.arg.load_weights:
+            self.load_model_weights(model, self.arg.load_weights)
+        elif self.arg.load_checkpoints:
+            self.load_checkpoint_weights(model, optimizer)
+        model = self.model_to_device(model)
+        self.kernel_sizes = model.conv1d.kernel_size
+        print("Loading model finished.")
+        self.load_data()
+        return model, optimizer
+
+    def model_to_device(self, model):
+        model = model.to(self.device.output_device)
+        if len(self.device.gpu_list) > 1:
+            raise ValueError("AMP equipped with DataParallel has to manually write autocast() for each forward function, you can choose to do this by yourself")
+            #model.conv2d = nn.DataParallel(model.conv2d, device_ids=self.device.gpu_list, output_device=self.device.output_device)
+        model = convert_model(model)
+        model.cuda()
+        return model
+
+    def load_model_weights(self, model, weight_path):
+        state_dict = torch.load(weight_path)
+        if len(self.arg.ignore_weights):
+            for w in self.arg.ignore_weights:
+                if state_dict.pop(w, None) is not None:
+                    print('Successfully Remove Weights: {}.'.format(w))
+                else:
+                    print('Can Not Remove Weights: {}.'.format(w))
+        weights = self.modified_weights(state_dict['model_state_dict'], False)
+        # weights = self.modified_weights(state_dict['model_state_dict'])
+        model.load_state_dict(weights, strict=True)
+
+    @staticmethod
+    def modified_weights(state_dict, modified=False):
+        state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+        if not modified:
+            return state_dict
+        modified_dict = dict()
+        return modified_dict
+
+    def load_checkpoint_weights(self, model, optimizer):
+        self.load_model_weights(model, self.arg.load_checkpoints)
+        state_dict = torch.load(self.arg.load_checkpoints)
+
+        if len(torch.cuda.get_rng_state_all()) == len(state_dict['rng_state']['cuda']):
+            print("Loading random seeds...")
+            self.rng.set_rng_state(state_dict['rng_state'])
+        if "optimizer_state_dict" in state_dict.keys():
+            print("Loading optimizer parameters...")
+            optimizer.load_state_dict(state_dict["optimizer_state_dict"])
+            optimizer.to(self.device.output_device)
+        if "scheduler_state_dict" in state_dict.keys():
+            print("Loading scheduler parameters...")
+            optimizer.scheduler.load_state_dict(state_dict["scheduler_state_dict"])
+
+        self.arg.optimizer_args['start_epoch'] = state_dict["epoch"] + 1
+        self.recoder.print_log("Resuming from checkpoint: epoch {self.arg.optimizer_args['start_epoch']}")
+
+    def load_data(self):
+        print("Loading data")
+        self.feeder = import_class(self.arg.feeder)
+        shutil.copy2(inspect.getfile(self.feeder), self.arg.work_dir)
+        if self.arg.dataset == 'CSL':
+            dataset_list = zip(["train", "dev"], [True, False])
+        elif 'phoenix' in self.arg.dataset:
+            dataset_list = zip(["train", "dev", "test"], [True, False, False]) 
+        elif self.arg.dataset == 'CSL-Daily':
+            dataset_list = zip(["train", "dev", "test"], [True, False, False])
+        for idx, (mode, train_flag) in enumerate(dataset_list):
+            arg = self.arg.feeder_args
+            arg["prefix"] = self.arg.dataset_info['dataset_root']
+            arg["mode"] = mode.split("_")[0]
+            arg["transform_mode"] = train_flag
+            self.dataset[mode] = self.feeder(gloss_dict=self.gloss_dict, kernel_size= self.kernel_sizes, dataset=self.arg.dataset, **arg)
+            self.data_loader[mode] = self.build_dataloader(self.dataset[mode], mode, train_flag)
+        print("Loading data finished.")
+    def init_fn(self, worker_id):
+        np.random.seed(int(self.arg.random_seed)+worker_id)
+    def build_dataloader(self, dataset, mode, train_flag):
+        return torch.utils.data.DataLoader(
+            dataset,
+            batch_size=self.arg.batch_size if mode == "train" else self.arg.test_batch_size,
+            shuffle=train_flag,
+            drop_last=train_flag,
+            num_workers=self.arg.num_worker,  # if train_flag else 0
+            collate_fn=self.feeder.collate_fn,
+            pin_memory=True,
+            worker_init_fn=self.init_fn,
+        )
+
+
+def import_class(name):
+    components = name.rsplit('.', 1)
+    mod = importlib.import_module(components[0])
+    mod = getattr(mod, components[1])
+    return mod
+
+
+if __name__ == '__main__':
+    sparser = utils.get_parser()
+    p = sparser.parse_args()
+    # p.config = "baseline_iter.yaml"
+    if p.config is not None:
+        with open(p.config, 'r') as f:
+            try:
+                default_arg = yaml.load(f, Loader=yaml.FullLoader)
+            except AttributeError:
+                default_arg = yaml.load(f)
+        key = vars(p).keys()
+        for k in default_arg.keys():
+            if k not in key:
+                print('WRONG ARG: {}'.format(k))
+                assert (k in key)
+        sparser.set_defaults(**default_arg)
+    args = sparser.parse_args()
+    with open(f"./configs/{args.dataset}.yaml", 'r') as f:
+        args.dataset_info = yaml.load(f, Loader=yaml.FullLoader)
+    processor = Processor(args)
+    utils.pack_code("./", args.work_dir)
+    processor.start()

CorrNet_Plus/CorrNet_Plus_CSLR/modules/BiLSTM.py

@@ -0,0 +1,96 @@
+import pdb
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BiLSTMLayer(nn.Module):
+    def __init__(self, input_size, debug=False, hidden_size=512, num_layers=1, dropout=0.3,
+                 bidirectional=True, rnn_type='LSTM', num_classes=-1):
+        super(BiLSTMLayer, self).__init__()
+
+        self.dropout = dropout
+        self.num_layers = num_layers
+        self.input_size = input_size
+        self.bidirectional = bidirectional
+        self.num_directions = 2 if bidirectional else 1
+        self.hidden_size = int(hidden_size / self.num_directions)
+        self.rnn_type = rnn_type
+        self.debug = debug
+        self.rnn = getattr(nn, self.rnn_type)(
+            input_size=self.input_size,
+            hidden_size=self.hidden_size,
+            num_layers=self.num_layers,
+            dropout=self.dropout,
+            bidirectional=self.bidirectional)
+        # for name, param in self.rnn.named_parameters():
+        #     if name[:6] == 'weight':
+        #         nn.init.orthogonal_(param)
+
+    def forward(self, src_feats, src_lens, hidden=None):
+        """
+        Args:
+            - src_feats: (max_src_len, batch_size, D)
+            - src_lens: (batch_size)
+        Returns:
+            - outputs: (max_src_len, batch_size, hidden_size * num_directions)
+            - hidden : (num_layers, batch_size, hidden_size * num_directions)
+        """
+        # (max_src_len, batch_size, D)
+        packed_emb = nn.utils.rnn.pack_padded_sequence(src_feats, src_lens)
+
+        # rnn(gru) returns:
+        # - packed_outputs: shape same as packed_emb
+        # - hidden: (num_layers * num_directions, batch_size, hidden_size)
+        if hidden is not None and self.rnn_type == 'LSTM':
+            half = int(hidden.size(0) / 2)
+            hidden = (hidden[:half], hidden[half:])
+        packed_outputs, hidden = self.rnn(packed_emb, hidden)
+
+        # outputs: (max_src_len, batch_size, hidden_size * num_directions)
+        rnn_outputs, _ = nn.utils.rnn.pad_packed_sequence(packed_outputs)
+
+        if self.bidirectional:
+            # (num_layers * num_directions, batch_size, hidden_size)
+            # => (num_layers, batch_size, hidden_size * num_directions)
+            hidden = self._cat_directions(hidden)
+
+        if isinstance(hidden, tuple):
+            # cat hidden and cell states
+            hidden = torch.cat(hidden, 0)
+
+        return {
+            "predictions": rnn_outputs,
+            "hidden": hidden
+        }
+
+    def _cat_directions(self, hidden):
+        """ If the encoder is bidirectional, do the following transformation.
+            Ref: https://github.com/IBM/pytorch-seq2seq/blob/master/seq2seq/models/DecoderRNN.py#L176
+            -----------------------------------------------------------
+            In: (num_layers * num_directions, batch_size, hidden_size)
+            (ex: num_layers=2, num_directions=2)
+
+            layer 1: forward__hidden(1)
+            layer 1: backward_hidden(1)
+            layer 2: forward__hidden(2)
+            layer 2: backward_hidden(2)
+
+            -----------------------------------------------------------
+            Out: (num_layers, batch_size, hidden_size * num_directions)
+
+            layer 1: forward__hidden(1) backward_hidden(1)
+            layer 2: forward__hidden(2) backward_hidden(2)
+        """
+
+        def _cat(h):
+            return torch.cat([h[0:h.size(0):2], h[1:h.size(0):2]], 2)
+
+        if isinstance(hidden, tuple):
+            # LSTM hidden contains a tuple (hidden state, cell state)
+            hidden = tuple([_cat(h) for h in hidden])
+        else:
+            # GRU hidden
+            hidden = _cat(hidden)
+
+        return hidden

CorrNet_Plus/CorrNet_Plus_CSLR/modules/__init__.py

@@ -0,0 +1,2 @@
+from .BiLSTM import BiLSTMLayer
+from .tconv import TemporalConv

CorrNet_Plus/CorrNet_Plus_CSLR/modules/resnet.py

@@ -0,0 +1,295 @@
+import torch
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+__all__ = [
+    'ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+    'resnet152', 'resnet200'
+]
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None, clusters=1):
+        super().__init__()
+        #self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+        self.clusters = clusters
+        self.query = nn.Parameter(torch.rand(self.clusters, 1, embed_dim), requires_grad=True)
+
+    def forward(self, x):
+        N, C, T, H, W= x.shape
+        x = x.flatten(start_dim=3).permute(3, 0, 2, 1).reshape(-1, N*T, C).contiguous()  # NCTHW -> (HW)(NT)C
+        #x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)(NT)C
+        #x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)(NT)C
+        x, _ = F.multi_head_attention_forward(
+            #query=x[:1], key=x, value=x,
+            query=self.query.repeat(1,N*T,1), key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.view(self.clusters,N,T,C).contiguous().permute(1,3,2,0) #PNTC->NCTP
+
+class UnfoldTemporalWindows(nn.Module):
+    def __init__(self, window_size=9, window_stride=1, window_dilation=1):
+        super().__init__()
+        self.window_size = window_size
+        self.window_stride = window_stride
+        self.window_dilation = window_dilation
+
+        self.padding = (window_size + (window_size-1) * (window_dilation-1) - 1) // 2
+        self.unfold = nn.Unfold(kernel_size=(self.window_size, 1),
+                                dilation=(self.window_dilation, 1),
+                                stride=(self.window_stride, 1),
+                                padding=(self.padding, 0))
+
+    def forward(self, x):
+        # Input shape: (N,C,T,H,W), out: (N,C,T,V*window_size)
+        N, C, T, H, W = x.shape
+        x = x.view(N, C, T, H*W)
+        x = self.unfold(x)  #(N, C*Window_Size, T, H*W)
+        # Permute extra channels from window size to the graph dimension; -1 for number of windows
+        x = x.view(N, C, self.window_size, T, H, W).permute(0,1,3,2,4,5).reshape(N, C, T, self.window_size, H, W).contiguous()# NCTSHW
+        return x
+
+class Temporal_weighting(nn.Module):
+    def __init__(self, input_size ):
+        super().__init__()
+        hidden_size = input_size//16
+        self.conv_transform = nn.Conv1d(input_size, hidden_size, kernel_size=1, stride=1, padding=0)
+        self.conv_back = nn.Conv1d(hidden_size, input_size, kernel_size=1, stride=1, padding=0)
+        #self.conv_enhance = nn.Conv1d(hidden_size, hidden_size, kernel_size=9, stride=1, padding=4)
+        self.num = 3
+        self.conv_enhance = nn.ModuleList([
+            nn.Conv1d(hidden_size, hidden_size, kernel_size=3, stride=1, padding=int(i+1), groups=hidden_size, dilation=int(i+1)) for i in range(self.num)
+        ])
+        self.weights = nn.Parameter(torch.ones(self.num) / self.num, requires_grad=True)
+        self.alpha = nn.Parameter(torch.zeros(1), requires_grad=True)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        out = self.conv_transform(x.mean(-1).mean(-1))
+        aggregated_out = 0
+        for i in range(self.num):
+            aggregated_out += self.conv_enhance[i](out) * self.weights[i]
+        out = self.conv_back(aggregated_out)
+        return x*(F.sigmoid(out.unsqueeze(-1).unsqueeze(-1))-0.5) * self.alpha
+
+class Get_Correlation(nn.Module):
+    def __init__(self, channels, neighbors=3):
+        super().__init__()
+        reduction_channel = channels//16
+
+        self.down_conv2 = nn.Conv3d(channels, channels, kernel_size=1, bias=False)
+        self.neighbors = neighbors
+        self.clusters = 1
+        self.weights2 = nn.Parameter(torch.ones(self.neighbors*2) / (self.neighbors*2), requires_grad=True)
+        self.unfold = UnfoldTemporalWindows(2*self.neighbors+1)
+        self.weights3 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.weights4 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.attpool = AttentionPool2d(spacial_dim=None, embed_dim=channels, num_heads=1, clusters=self.clusters)
+        self.mlp = nn.Sequential(nn.Conv3d(channels, reduction_channel, kernel_size=1),
+                                 nn.GELU(),
+                                nn.Conv3d(reduction_channel, channels, kernel_size=1),)
+
+        # For generating aggregated_x with multi-scale conv
+        self.down_conv = nn.Conv3d(channels, reduction_channel, kernel_size=1, bias=False)
+        self.spatial_aggregation1 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,1,1), groups=reduction_channel)
+        self.spatial_aggregation2 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,2,2), dilation=(1,2,2), groups=reduction_channel)
+        self.spatial_aggregation3 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,3,3), dilation=(1,3,3), groups=reduction_channel)
+        self.weights = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.conv_back = nn.Conv3d(reduction_channel, channels, kernel_size=1, bias=False)
+
+    def forward(self, x):
+        N, C, T, H, W = x.shape
+        def clustering(query, key):
+            affinities = torch.einsum('bctp,bctl->btpl', query, key)
+            return torch.einsum('bctl,btpl->bctp', key, F.sigmoid(affinities)-0.5)
+        
+        x_mean = x.mean(3, keepdim=True).mean(4, keepdim=False)
+        x_max = x.max(-1, keepdim=False)[0].max(-1, keepdim=True)[0]
+        x_att = self.attpool(x) #NCTP
+        x2 = self.down_conv2(x)
+        upfold = self.unfold(x2)
+        upfold = (torch.concat([upfold[:,:,:,:self.neighbors], upfold[:,:,:,self.neighbors+1:]],3)* self.weights2.view(1, 1, 1, -1, 1, 1)).view(N, C, T, -1)
+        x_mean = x_mean*self.weights4[0] + x_max*self.weights4[1] + x_att*self.weights4[2]
+        x_mean = clustering(x_mean, upfold)
+        features = x_mean.view(N, C, T, self.clusters, 1)
+
+        x_down = self.down_conv(x)
+        aggregated_x = self.spatial_aggregation1(x_down)*self.weights[0] + self.spatial_aggregation2(x_down)*self.weights[1] \
+                    + self.spatial_aggregation3(x_down)*self.weights[2]
+        aggregated_x = self.conv_back(aggregated_x)
+        
+        features = features * (F.sigmoid(aggregated_x)-0.5)
+        return features
+        
+
+def conv3x3(in_planes, out_planes, stride=1):
+    # 3x3x3 convolution with padding
+    return nn.Conv3d(
+        in_planes,
+        out_planes,
+        kernel_size=(1,3,3),
+        stride=(1,stride,stride),
+        padding=(0,1,1),
+        bias=False)
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv3d(3, 64, kernel_size=(1,7,7), stride=(1,2,2), padding=(0,3,3),
+                               bias=False)
+        self.bn1 = nn.BatchNorm3d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1))
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.corr2 = Get_Correlation(self.inplanes, neighbors=1)
+        self.temporal_weight2 = Temporal_weighting(self.inplanes)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.corr3 = Get_Correlation(self.inplanes, neighbors=3)
+        self.temporal_weight3 = Temporal_weighting(self.inplanes)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.corr4 = Get_Correlation(self.inplanes, neighbors=5)
+        self.temporal_weight4 = Temporal_weighting(self.inplanes)
+        self.alpha = nn.Parameter(torch.zeros(3), requires_grad=True)
+        self.avgpool = nn.AvgPool2d(7, stride=1)
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+        
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d) or isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv3d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=(1,stride,stride), bias=False),
+                nn.BatchNorm3d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        N, C, T, H, W = x.size()
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x) 
+        x = x + self.corr2(x) * self.alpha[0]
+        x = x + self.temporal_weight2(x)
+        x = self.layer3(x)
+        x = x + self.corr3(x) * self.alpha[1]
+        x = x + self.temporal_weight3(x)
+        x = self.layer4(x)
+        x = x + self.corr4(x) * self.alpha[2]
+        x = x + self.temporal_weight4(x)
+    
+        x = x.transpose(1,2).contiguous()
+        x = x.view((-1,)+x.size()[2:]) #bt,c,h,w
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1) #bt,c
+        x = self.fc(x) #bt,c
+
+        return x
+
+def resnet18(**kwargs):
+    """Constructs a ResNet-18 based model.
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    checkpoint = model_zoo.load_url(model_urls['resnet18'], map_location=torch.device('cpu'))
+    layer_name = list(checkpoint.keys())
+    for ln in layer_name :
+        if 'conv' in ln or 'downsample.0.weight' in ln:
+            checkpoint[ln] = checkpoint[ln].unsqueeze(2)  
+    model.load_state_dict(checkpoint, strict=False)
+    del checkpoint
+    import gc
+    gc.collect()
+    return model
+
+
+def resnet34(**kwargs):
+    """Constructs a ResNet-34 model.
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    return model
+
+def test():
+    net = resnet18()
+    y = net(torch.randn(1,3,224,224))
+    print(y.size())
+
+#test()

CorrNet_Plus/CorrNet_Plus_CSLR/modules/tconv.py

@@ -0,0 +1,125 @@
+import pdb
+import torch
+import collections
+import torch.nn as nn
+import torch.nn.functional as F
+
+class Temporal_LiftPool(nn.Module):
+    def __init__(self, input_size, kernel_size=2):
+        super(Temporal_LiftPool, self).__init__()
+        self.kernel_size = kernel_size
+        self.predictor = nn.Sequential(
+            nn.Conv1d(input_size, input_size, kernel_size=3, stride=1, padding=1, groups=input_size), 
+            nn.ReLU(inplace=True),   
+            nn.Conv1d(input_size, input_size, kernel_size=1, stride=1, padding=0),
+            nn.Tanh(),    
+                                    )
+
+        self.updater = nn.Sequential(
+            nn.Conv1d(input_size, input_size, kernel_size=3, stride=1, padding=1, groups=input_size),
+            nn.ReLU(inplace=True),   
+            nn.Conv1d(input_size, input_size, kernel_size=1, stride=1, padding=0),
+            nn.Tanh(),    
+                                    )
+        self.predictor[2].weight.data.fill_(0.0)
+        self.updater[2].weight.data.fill_(0.0)
+        self.weight1 = Local_Weighting(input_size)
+        self.weight2 = Local_Weighting(input_size)
+
+    def forward(self, x):
+        B, C, T= x.size()
+        Xe = x[:,:,:T:self.kernel_size]
+        Xo = x[:,:,1:T:self.kernel_size]
+        d = Xo - self.predictor(Xe)
+        s = Xe + self.updater(d)
+        loss_u = torch.norm(s-Xo, p=2)
+        loss_p = torch.norm(d, p=2)
+        s = torch.cat((x[:,:,:0:self.kernel_size], s, x[:,:,T::self.kernel_size]),2)
+        return self.weight1(s)+self.weight2(d), loss_u, loss_p
+
+class Local_Weighting(nn.Module):
+    def __init__(self, input_size ):
+        super(Local_Weighting, self).__init__()
+        self.conv = nn.Conv1d(input_size, input_size, kernel_size=5, stride=1, padding=2)
+        self.insnorm = nn.InstanceNorm1d(input_size, affine=True)
+        self.conv.weight.data.fill_(0.0)
+
+    def forward(self, x):
+        out = self.conv(x)
+        return x + x*(F.sigmoid(self.insnorm(out))-0.5)
+
+class TemporalConv(nn.Module):
+    def __init__(self, input_size, hidden_size, conv_type=2, use_bn=False, num_classes=-1):
+        super(TemporalConv, self).__init__()
+        self.use_bn = use_bn
+        self.input_size = input_size
+        self.hidden_size = hidden_size
+        self.num_classes = num_classes
+        self.conv_type = conv_type
+
+        if self.conv_type == 0:
+            self.kernel_size = ['K3']
+        elif self.conv_type == 1:
+            self.kernel_size = ['K5', "P2"]
+            self.strides = [0]
+        elif self.conv_type == 2:
+            self.kernel_size = ['K5', "P2", 'K5', "P2"]
+            self.strides = [4,0]
+
+
+        self.temporal_conv = nn.ModuleList([])
+        #nums = 0
+        for layer_idx, ks in enumerate(self.kernel_size):
+            input_sz = self.input_size if layer_idx == 0 else self.hidden_size
+            if ks[0] == 'P':
+                #nums += 1
+                #if nums == 2:
+                #    self.temporal_conv.append(nn.MaxPool1d(kernel_size=int(ks[1]), ceil_mode=False))
+                #elif nums == 1:
+                self.temporal_conv.append(Temporal_LiftPool(input_size=input_sz, kernel_size=int(ks[1])))
+                #self.temporal_conv.append(nn.MaxPool1d(kernel_size=int(ks[1]), ceil_mode=False))
+                #self.temporal_conv.append(nn.AvgPool1d(kernel_size=int(ks[1]), ceil_mode=False))
+                
+            elif ks[0] == 'K':
+                self.temporal_conv.append(
+                    nn.Sequential(
+                    nn.Conv1d(input_sz, self.hidden_size, kernel_size=int(ks[1]), stride=1, padding=0),
+                    nn.BatchNorm1d(self.hidden_size),
+                    nn.ReLU(inplace=True),
+                    )
+                )
+
+        if self.num_classes != -1:
+            self.fc = nn.Linear(self.hidden_size, self.num_classes)
+
+    def update_lgt(self, feat_len):
+        for ks in self.kernel_size:
+            if ks[0] == 'P':
+                feat_len //= int(ks[1])
+            else:
+                feat_len -= int(ks[1]) - 1
+        return feat_len
+
+    def forward(self, frame_feat, lgt):
+        visual_feat = frame_feat
+        loss_LiftPool_u = 0
+        loss_LiftPool_p = 0
+        i = 0
+        for tempconv in self.temporal_conv:
+            if isinstance(tempconv, Temporal_LiftPool):
+                visual_feat, loss_u, loss_d = tempconv(visual_feat) #self.strides[i])
+                i +=1
+                loss_LiftPool_u += loss_u
+                loss_LiftPool_p += loss_d
+            else:
+                visual_feat = tempconv(visual_feat)
+        lgt = self.update_lgt(lgt)
+        logits = None if self.num_classes == -1 \
+            else self.fc(visual_feat.transpose(1, 2)).transpose(1, 2)
+        return {
+            "visual_feat": visual_feat.permute(2, 0, 1),
+            "conv_logits": logits.permute(2, 0, 1),
+            "feat_len": lgt.cpu(),
+            "loss_LiftPool_u": loss_LiftPool_u,
+            "loss_LiftPool_p": loss_LiftPool_p,
+        }

CorrNet_Plus/CorrNet_Plus_CSLR/preprocess/dataset_preprocess-CSL-Daily.py

@@ -0,0 +1,178 @@
+import re
+import os
+import cv2
+import pdb
+import glob
+import pandas
+import argparse
+import numpy as np
+from tqdm import tqdm
+from functools import partial
+from multiprocessing import Pool
+
+
+def csv2dict(dataset_root, anno_path):
+    with open(anno_path,'r', encoding='utf-8') as f:
+        inputs_list = f.readlines()
+    info_dict = dict()
+    #info_dict['prefix'] = dataset_root #+ "/fullFrame-210x260px"
+    print(f"Generate information dict from {anno_path}")
+    for file_idx, file_info in tqdm(enumerate(inputs_list[1:]), total=len(inputs_list)-1):  # Exclude first line
+        index, name, length, gloss, char, word, postag = file_info.strip().split("|")
+        info_dict[file_idx] = {
+            'fileid': name,
+            'folder': name+'/*.jpg',
+            'signer': 'unknown',
+            'label': gloss,
+            'num_frames': length,
+            'original_info': "|".join(file_info.split("|")[1:]),  #start from 'name', for model inference
+        }
+    return info_dict
+
+
+def generate_gt_stm(info, save_path):
+    with open(save_path, "w") as f:
+        for k, v in info.items():
+            if not isinstance(k, int):
+                continue
+            f.writelines(f"{v['fileid']} 1 {v['signer']} 0.0 1.79769e+308 {v['label']}\n")
+
+
+def sign_dict_update(total_dict, info):
+    for k, v in info.items():
+        if not isinstance(k, int):
+            continue
+        split_label = v['label'].split()
+        for gloss in split_label:
+            if gloss not in total_dict.keys():
+                total_dict[gloss] = 1
+            else:
+                total_dict[gloss] += 1
+    return total_dict
+
+
+def resize_img(img_path, dsize='210x260px'):
+    dsize = tuple(int(res) for res in re.findall("\d+", dsize))
+    img = cv2.imread(img_path)
+    if img is None:
+        print(f'image destroyed: {img_path}, please manually modify the numframes')
+        return None
+    img = cv2.resize(img, dsize, interpolation=cv2.INTER_LANCZOS4)
+    return img
+
+
+def resize_dataset(video_idx, dsize, info_dict, dataset_root, target_path):
+    info = info_dict[video_idx]
+    img_list = glob.glob(f"{dataset_root}/{info['folder']}")
+    if len(img_list) == len(glob.glob(f"{target_path}/{info['folder']}")):
+        return
+    for img_path in img_list:
+        rs_img = resize_img(img_path, dsize=dsize)
+        if rs_img is None:
+            info_dict[video_idx]['num_frames'] = info_dict[video_idx]['num_frames']-1
+            continue
+        rs_img_path = f"{target_path}/{info['fileid']}/{img_path.split('/')[-1]}"
+        rs_img_dir = os.path.dirname(rs_img_path)
+        if not os.path.exists(rs_img_dir):
+            os.makedirs(rs_img_dir)
+            cv2.imwrite(rs_img_path, rs_img)
+        else:
+            cv2.imwrite(rs_img_path, rs_img)
+
+
+def run_mp_cmd(processes, process_func, process_args):
+    with Pool(processes) as p:
+        outputs = list(tqdm(p.imap(process_func, process_args), total=len(process_args)))
+    return outputs
+
+
+def run_cmd(func, args):
+    return func(args)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Data process for Visual Alignment Constraint for Continuous Sign Language Recognition.')
+    parser.add_argument('--dataset', type=str, default='CSL-Daily',
+                        help='save prefix')
+    parser.add_argument('--dataset-root', type=str, default='/disk1/dataset/CSL-Daily/sentence/frames_512x512',
+                        help='path to the dataset')
+    parser.add_argument('--target-path', type=str, default='/disk1/dataset/CSL-Daily_256x256px',
+                        help='target path to the dataset')
+    parser.add_argument('--annotation-file', type=str, default='video_map.txt',
+                        help='annotation file')
+    parser.add_argument('--split-file', type=str, default='split_1.txt',
+                        help='split file')
+    parser.add_argument('--output-res', type=str, default='256x256px',
+                        help='resize resolution for image sequence')
+    parser.add_argument('--process-image', '-p', action='store_true', default=False,
+                        help='resize image')
+    parser.add_argument('--multiprocessing', '-m', action='store_true', default=False,
+                        help='whether adopts multiprocessing to accelate the preprocess')
+
+    args = parser.parse_args()
+    mode = ["train", "dev", "test"]
+    sign_dict = dict()
+    if not os.path.exists(f"./{args.dataset}"):
+        os.makedirs(f"./{args.dataset}")
+    
+    # generate information dict
+    information = csv2dict(args.dataset_root, f"./{args.dataset}/{args.annotation_file}")
+    video_index = np.arange(len(information))
+    if args.process_image:
+        print(f"Resize image to {args.output_res}")
+        if args.multiprocessing:
+            run_mp_cmd(100, partial(resize_dataset, dsize=args.output_res, info_dict=information, dataset_root=args.dataset_root, target_path=args.target_path), video_index)
+        else:
+            for idx in tqdm(video_index):
+                run_cmd(partial(resize_dataset, dsize=args.output_res, info_dict=information, dataset_root=args.dataset_root, target_path=args.target_path), idx)
+                #resize_dataset(idx, dsize=args.output_res, info_dict=information)
+    else:
+        print("Don't resize images")
+
+    with open(f"./{args.dataset}/{args.split_file}",'r', encoding='utf-8') as f:
+        files_list = f.readlines()  
+    train_files = []
+    dev_files = []
+    test_files = []
+    for file_idx, file_info in tqdm(enumerate(files_list[1:]), total=len(files_list)-1):  # Exclude first line
+        name, split = file_info.strip().split("|")  
+        if split == 'train':
+            train_files.append(name)
+        elif split == 'dev':
+            dev_files.append(name)
+        elif split == 'test':
+            test_files.append(name)
+    assert len(train_files) + len(dev_files) + len(test_files) == len(information)
+    information_pack = dict()
+    for md in mode:
+        information_pack[md] = dict()
+    train_id = 0
+    dev_id = 0
+    test_id = 0
+    for info_key, info_data in information.items():
+        if info_data['fileid'] in train_files:
+            information_pack['train'][train_id] = info_data
+            train_id += 1
+        elif info_data['fileid'] in dev_files:
+            information_pack['dev'][dev_id] = info_data
+            dev_id +=1
+        elif info_data['fileid'] in test_files:
+            information_pack['test'][test_id] = info_data
+            test_id +=1
+        else:
+            information_pack['train'][train_id] = info_data    #S000007_P0003_T00
+            train_id += 1
+    assert len(information_pack['train']) + len(information_pack['dev']) + len(information_pack['test']) == len(information)
+
+    for md in mode:
+        np.save(f"./{args.dataset}/{md}_info.npy", information_pack[md])
+        # generate groudtruth stm for evaluation
+        generate_gt_stm(information_pack[md], f"./{args.dataset}/{args.dataset}-groundtruth-{md}.stm")
+    # update the total gloss dict
+    sign_dict_update(sign_dict, information)
+    sign_dict = sorted(sign_dict.items(), key=lambda d: d[0])
+    save_dict = {}
+    for idx, (key, value) in enumerate(sign_dict):
+        save_dict[key] = [idx + 1, value]
+    np.save(f"./{args.dataset}/gloss_dict.npy", save_dict)

CorrNet_Plus/CorrNet_Plus_CSLR/preprocess/dataset_preprocess-CSL.py

@@ -0,0 +1,141 @@
+import re
+import os
+import cv2
+import pdb
+import glob
+import pandas
+import argparse
+import numpy as np
+from tqdm import tqdm
+from functools import partial
+from multiprocessing import Pool
+
+
+def csv2dict(dataset_root, anno_path):
+    with open(anno_path,'r', encoding='utf-8') as f:
+        inputs_list = f.readlines()
+    info_dict = dict()
+    #info_dict['prefix'] = dataset_root #+ "/fullFrame-210x260px"
+    print(f"Generate information dict from {anno_path}")
+    for file_idx, file_info in tqdm(enumerate(inputs_list), total=len(inputs_list)):
+        name, label = file_info.strip().split("|")
+        num_frames = len(glob.glob(f"{name}/*.jpg"))
+        info_dict[file_idx] = {
+            'fileid': name,
+            'folder': name.split('/')[-1],
+            'signer': 'unknown',
+            'label': label,
+            'num_frames': num_frames,
+            'original_info': file_info,
+        }
+    return info_dict
+
+
+def generate_gt_stm(info, save_path):
+    with open(save_path, "w") as f:
+        for k, v in info.items():
+            if not isinstance(k, int):
+                continue
+            f.writelines(f"{v['fileid']} 1 {v['signer']} 0.0 1.79769e+308 {v['label']}\n")
+
+
+def sign_dict_update(total_dict, info):
+    for k, v in info.items():
+        if not isinstance(k, int):
+            continue
+        split_label = v['label'].split()
+        for gloss in split_label:
+            if gloss not in total_dict.keys():
+                total_dict[gloss] = 1
+            else:
+                total_dict[gloss] += 1
+    return total_dict
+
+
+def resize_img(img_path, dsize='210x260px'):
+    dsize = tuple(int(res) for res in re.findall("\d+", dsize))
+    img = cv2.imread(img_path)
+    if img is None:
+        print(f'image destroyed: {img_path}, please manually modify the numframes')
+        return None
+    img = cv2.resize(img, dsize, interpolation=cv2.INTER_LANCZOS4)
+    return img
+
+
+def resize_dataset(video_idx, dsize, info_dict, target_path):
+    info = info_dict[video_idx]
+    img_list = glob.glob(f"{info['fileid']}/*.jpg")
+    if len(img_list) == len(glob.glob(f"{target_path}/features/fullFrame-{dsize}/{info['folder']}/*.jpg")):
+        return
+    for img_path in img_list:
+        rs_img = resize_img(img_path, dsize=dsize)
+        if rs_img is None:
+            info_dict[video_idx]['num_frames'] = info_dict[video_idx]['num_frames']-1
+            continue
+        rs_img_path = f"{target_path}/features/fullFrame-{dsize}/{info['folder']}/{img_path.split('/')[-1]}"
+        rs_img_dir = os.path.dirname(rs_img_path)
+        if not os.path.exists(rs_img_dir):
+            os.makedirs(rs_img_dir)
+            cv2.imwrite(rs_img_path, rs_img)
+        else:
+            cv2.imwrite(rs_img_path, rs_img)
+
+
+def run_mp_cmd(processes, process_func, process_args):
+    with Pool(processes) as p:
+        outputs = list(tqdm(p.imap(process_func, process_args), total=len(process_args)))
+    return outputs
+
+
+def run_cmd(func, args):
+    return func(args)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Data process for Visual Alignment Constraint for Continuous Sign Language Recognition.')
+    parser.add_argument('--dataset', type=str, default='CSL',
+                        help='save prefix')
+    parser.add_argument('--dataset-root', type=str, default='/disk1/dataset/CSL_Continuous',
+                        help='path to the dataset')
+    parser.add_argument('--target-path', type=str, default='/disk1/dataset/CSL_Continuous_Resized',
+                        help='target path to the dataset')
+    parser.add_argument('--annotation-prefix', type=str, default='{}.txt',
+                        help='annotation prefix')
+    parser.add_argument('--output-res', type=str, default='256x256px',
+                        help='resize resolution for image sequence')
+    parser.add_argument('--process-image', '-p', action='store_true', default=False,
+                        help='resize image')
+    parser.add_argument('--multiprocessing', '-m', action='store_true', default=False,
+                        help='whether adopts multiprocessing to accelate the preprocess')
+
+    args = parser.parse_args()
+    mode = ["train", "dev"]
+    sign_dict = dict()
+    if not os.path.exists(f"./{args.dataset}"):
+        os.makedirs(f"./{args.dataset}")
+    for md in mode:
+        # generate information dict
+        information = csv2dict(args.dataset_root, f"./{args.dataset}/{args.annotation_prefix.format(md)}")
+        video_index = np.arange(len(information) - 1)
+        if args.process_image:
+            print(f"Resize image to {args.output_res}")
+            if args.multiprocessing:
+                run_mp_cmd(100, partial(resize_dataset, dsize=args.output_res, info_dict=information, target_path=args.target_path), video_index)
+            else:
+                for idx in tqdm(video_index):
+                    run_cmd(partial(resize_dataset, dsize=args.output_res, info_dict=information, target_path=args.target_path), idx)
+                    #resize_dataset(idx, dsize=args.output_res, info_dict=information)
+        else:
+            print("Don't resize images")
+        np.save(f"./{args.dataset}/{md}_info.npy", information)
+        # update the total gloss dict
+        sign_dict_update(sign_dict, information)
+        # generate groudtruth stm for evaluation
+        generate_gt_stm(information, f"./{args.dataset}/{args.dataset}-groundtruth-{md}.stm")
+        # resize images
+    sign_dict = sorted(sign_dict.items(), key=lambda d: d[0])
+    save_dict = {}
+    for idx, (key, value) in enumerate(sign_dict):
+        save_dict[key] = [idx + 1, value]
+    np.save(f"./{args.dataset}/gloss_dict.npy", save_dict)

CorrNet_Plus/CorrNet_Plus_CSLR/preprocess/dataset_preprocess-T.py

@@ -0,0 +1,129 @@
+import re
+import os
+import cv2
+import pdb
+import glob
+import pandas
+import argparse
+import numpy as np
+from tqdm import tqdm
+from functools import partial
+from multiprocessing import Pool
+
+
+def csv2dict(anno_path, dataset_type):
+    inputs_list = pandas.read_csv(anno_path)
+    inputs_list = (inputs_list.to_dict()['name|video|start|end|speaker|orth|translation'].values())
+    info_dict = dict()
+    info_dict['prefix'] = anno_path.rsplit("/", 3)[0] + "/features/fullFrame-210x260px"
+    print(f"Generate information dict from {anno_path}")
+    for file_idx, file_info in tqdm(enumerate(inputs_list), total=len(inputs_list)):
+        name, video, start, end, speaker, orth, translation = file_info.split("|")
+        num_frames = len(glob.glob(f"{info_dict['prefix']}/{dataset_type}/{video}"))
+        info_dict[file_idx] = {
+            'fileid': name,
+            'folder': f"{dataset_type}/{video}",
+            'signer': speaker,
+            'label': orth,
+            'num_frames': num_frames,
+            'original_info': file_info,
+        }
+    return info_dict
+
+
+def generate_gt_stm(info, save_path):
+    with open(save_path, "w") as f:
+        for k, v in info.items():
+            if not isinstance(k, int):
+                continue
+            f.writelines(f"{v['fileid']} 1 {v['signer']} 0.0 1.79769e+308 {v['label']}\n")
+
+
+def sign_dict_update(total_dict, info):
+    for k, v in info.items():
+        if not isinstance(k, int):
+            continue
+        split_label = v['label'].split()
+        for gloss in split_label:
+            if gloss not in total_dict.keys():
+                total_dict[gloss] = 1
+            else:
+                total_dict[gloss] += 1
+    return total_dict
+
+
+def resize_img(img_path, dsize='210x260px'):
+    dsize = tuple(int(res) for res in re.findall("\d+", dsize))
+    img = cv2.imread(img_path)
+    img = cv2.resize(img, dsize, interpolation=cv2.INTER_LANCZOS4)
+    return img
+
+
+def resize_dataset(video_idx, dsize, info_dict):
+    info = info_dict[video_idx]
+    img_list = glob.glob(f"{info_dict['prefix']}/{info['folder']}")
+    for img_path in img_list:
+        rs_img = resize_img(img_path, dsize=dsize)
+        rs_img_path = img_path.replace("210x260px", dsize)
+        rs_img_dir = os.path.dirname(rs_img_path)
+        if not os.path.exists(rs_img_dir):
+            os.makedirs(rs_img_dir)
+            cv2.imwrite(rs_img_path, rs_img)
+        else:
+            cv2.imwrite(rs_img_path, rs_img)
+
+
+def run_mp_cmd(processes, process_func, process_args):
+    with Pool(processes) as p:
+        outputs = list(tqdm(p.imap(process_func, process_args), total=len(process_args)))
+    return outputs
+
+
+def run_cmd(func, args):
+    return func(args)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Data process for Visual Alignment Constraint for Continuous Sign Language Recognition.')
+    parser.add_argument('--dataset', type=str, default='phoenix2014-T',
+                        help='save prefix')
+    parser.add_argument('--dataset-root', type=str, default='/disk1/dataset/PHOENIX-2014-T-release-v3/PHOENIX-2014-T',
+                        help='path to the dataset')
+    parser.add_argument('--annotation-prefix', type=str, default='annotations/manual/PHOENIX-2014-T.{}.corpus.csv',
+                        help='annotation prefix')
+    parser.add_argument('--output-res', type=str, default='256x256px',
+                        help='resize resolution for image sequence')
+    parser.add_argument('--process-image', '-p', action='store_true',
+                        help='resize image')
+    parser.add_argument('--multiprocessing', '-m', action='store_true',
+                        help='whether adopts multiprocessing to accelate the preprocess')
+
+    args = parser.parse_args()
+    mode = ["dev", "test", "train"]
+    sign_dict = dict()
+    if not os.path.exists(f"./{args.dataset}"):
+        os.makedirs(f"./{args.dataset}")
+    for md in mode:
+        # generate information dict
+        information = csv2dict(f"{args.dataset_root}/{args.annotation_prefix.format(md)}", dataset_type=md)
+        np.save(f"./{args.dataset}/{md}_info.npy", information)
+        # update the total gloss dict
+        sign_dict_update(sign_dict, information)
+        # generate groudtruth stm for evaluation
+        generate_gt_stm(information, f"./{args.dataset}/{args.dataset}-groundtruth-{md}.stm")
+        # resize images
+        video_index = np.arange(len(information) - 1)
+        print(f"Resize image to {args.output_res}")
+        if args.process_image:
+            if args.multiprocessing:
+                run_mp_cmd(10, partial(resize_dataset, dsize=args.output_res, info_dict=information), video_index)
+            else:
+                for idx in tqdm(video_index):
+                    run_cmd(partial(resize_dataset, dsize=args.output_res, info_dict=information), idx)
+                    #resize_dataset(idx, dsize=args.output_res, info_dict=information)
+    sign_dict = sorted(sign_dict.items(), key=lambda d: d[0])
+    save_dict = {}
+    for idx, (key, value) in enumerate(sign_dict):
+        save_dict[key] = [idx + 1, value]
+    np.save(f"./{args.dataset}/gloss_dict.npy", save_dict)

CorrNet_Plus/CorrNet_Plus_CSLR/preprocess/dataset_preprocess.py

@@ -0,0 +1,131 @@
+import re
+import os
+import cv2
+import pdb
+import glob
+import pandas
+import argparse
+import numpy as np
+from tqdm import tqdm
+from functools import partial
+from multiprocessing import Pool
+
+
+def csv2dict(anno_path, dataset_type):
+    inputs_list = pandas.read_csv(anno_path)
+    if dataset_type == 'train':
+        broken_data = [2390]
+        inputs_list.drop(broken_data, inplace=True)
+    inputs_list = (inputs_list.to_dict()['id|folder|signer|annotation'].values())
+    info_dict = dict()
+    info_dict['prefix'] = anno_path.rsplit("/", 3)[0] + "/features/fullFrame-210x260px"
+    print(f"Generate information dict from {anno_path}")
+    for file_idx, file_info in tqdm(enumerate(inputs_list), total=len(inputs_list)):
+        fileid, folder, signer, label = file_info.split("|")
+        num_frames = len(glob.glob(f"{info_dict['prefix']}/{dataset_type}/{folder}"))
+        info_dict[file_idx] = {
+            'fileid': fileid,
+            'folder': f"{dataset_type}/{folder}",
+            'signer': signer,
+            'label': label,
+            'num_frames': num_frames,
+            'original_info': file_info,
+        }
+    return info_dict
+
+
+def generate_gt_stm(info, save_path):
+    with open(save_path, "w") as f:
+        for k, v in info.items():
+            if not isinstance(k, int):
+                continue
+            f.writelines(f"{v['fileid']} 1 {v['signer']} 0.0 1.79769e+308 {v['label']}\n")
+
+
+def sign_dict_update(total_dict, info):
+    for k, v in info.items():
+        if not isinstance(k, int):
+            continue
+        split_label = v['label'].split()
+        for gloss in split_label:
+            if gloss not in total_dict.keys():
+                total_dict[gloss] = 1
+            else:
+                total_dict[gloss] += 1
+    return total_dict
+
+
+def resize_img(img_path, dsize='210x260px'):
+    dsize = tuple(int(res) for res in re.findall("\d+", dsize))
+    img = cv2.imread(img_path)
+    img = cv2.resize(img, dsize, interpolation=cv2.INTER_LANCZOS4)
+    return img
+
+
+def resize_dataset(video_idx, dsize, info_dict):
+    info = info_dict[video_idx]
+    img_list = glob.glob(f"{info_dict['prefix']}/{info['folder']}")
+    for img_path in img_list:
+        rs_img = resize_img(img_path, dsize=dsize)
+        rs_img_path = img_path.replace("210x260px", dsize)
+        rs_img_dir = os.path.dirname(rs_img_path)
+        if not os.path.exists(rs_img_dir):
+            os.makedirs(rs_img_dir)
+            cv2.imwrite(rs_img_path, rs_img)
+        else:
+            cv2.imwrite(rs_img_path, rs_img)
+
+
+def run_mp_cmd(processes, process_func, process_args):
+    with Pool(processes) as p:
+        outputs = list(tqdm(p.imap(process_func, process_args), total=len(process_args)))
+    return outputs
+
+
+def run_cmd(func, args):
+    return func(args)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(
+        description='Data process for Visual Alignment Constraint for Continuous Sign Language Recognition.')
+    parser.add_argument('--dataset', type=str, default='phoenix2014',
+                        help='save prefix')
+    parser.add_argument('--dataset-root', type=str, default='../dataset/phoenix2014/phoenix-2014-multisigner',
+                        help='path to the dataset')
+    parser.add_argument('--annotation-prefix', type=str, default='annotations/manual/{}.corpus.csv',
+                        help='annotation prefix')
+    parser.add_argument('--output-res', type=str, default='256x256px',
+                        help='resize resolution for image sequence')
+    parser.add_argument('--process-image', '-p', action='store_true',
+                        help='resize image')
+    parser.add_argument('--multiprocessing', '-m', action='store_true',
+                        help='whether adopts multiprocessing to accelate the preprocess')
+
+    args = parser.parse_args()
+    mode = ["dev", "test", "train"]
+    sign_dict = dict()
+    if not os.path.exists(f"./{args.dataset}"):
+        os.makedirs(f"./{args.dataset}")
+    for md in mode:
+        # generate information dict
+        information = csv2dict(f"{args.dataset_root}/{args.annotation_prefix.format(md)}", dataset_type=md)
+        np.save(f"./{args.dataset}/{md}_info.npy", information)
+        # update the total gloss dict
+        sign_dict_update(sign_dict, information)
+        # generate groudtruth stm for evaluation
+        generate_gt_stm(information, f"./{args.dataset}/{args.dataset}-groundtruth-{md}.stm")
+        # resize images
+        video_index = np.arange(len(information) - 1)
+        print(f"Resize image to {args.output_res}")
+        if args.process_image:
+            if args.multiprocessing:
+                run_mp_cmd(10, partial(resize_dataset, dsize=args.output_res, info_dict=information), video_index)
+            else:
+                for idx in tqdm(video_index):
+                    run_cmd(partial(resize_dataset, dsize=args.output_res, info_dict=information), idx)
+    sign_dict = sorted(sign_dict.items(), key=lambda d: d[0])
+    save_dict = {}
+    for idx, (key, value) in enumerate(sign_dict):
+        save_dict[key] = [idx + 1, value]
+    np.save(f"./{args.dataset}/gloss_dict.npy", save_dict)

CorrNet_Plus/CorrNet_Plus_CSLR/requirements.txt

@@ -0,0 +1,9 @@
+matplotlib==3.4.3
+numpy==1.20.3
+opencv_python==4.5.5.64
+pandas==1.3.4
+Pillow==9.4.0
+PyYAML==6.0
+scipy==1.7.1
+six==1.16.0
+tqdm==4.62.3

CorrNet_Plus/CorrNet_Plus_CSLR/seq_scripts.py

@@ -0,0 +1,164 @@
+import os
+import pdb
+import sys
+import copy
+import torch
+import numpy as np
+import torch.nn as nn
+from tqdm import tqdm
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+from evaluation.slr_eval.wer_calculation import evaluate
+from torch.cuda.amp import autocast as autocast
+from torch.cuda.amp import GradScaler
+import gc
+
+def seq_train(loader, model, optimizer, device, epoch_idx, recoder):
+    model.train()
+    loss_value = []
+    clr = [group['lr'] for group in optimizer.optimizer.param_groups]
+    scaler = GradScaler()
+    for batch_idx, data in enumerate(tqdm(loader)):
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        label = device.data_to_device(data[2])
+        label_lgt = device.data_to_device(data[3])
+        optimizer.zero_grad()
+        with autocast():
+            ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt)
+            loss, _ = model.criterion_calculation(ret_dict, label, label_lgt)
+        if np.isinf(loss.item()) or np.isnan(loss.item()):
+            print('loss is nan')
+            #print(data[-1])
+            print(str(data[1])+'  frames')
+            print(str(data[3])+'  glosses')
+            del ret_dict
+            del loss
+            continue
+        scaler.scale(loss).backward()
+        scaler.step(optimizer.optimizer)
+        scaler.update()
+        # nn.utils.clip_grad_norm_(model.rnn.parameters(), 5)
+        loss_value.append(loss.item())
+        if batch_idx % recoder.log_interval == 0:
+            recoder.print_log(
+                '\tEpoch: {}, Batch({}/{}) done. Loss: {:.8f}  lr:{:.6f}'
+                    .format(epoch_idx, batch_idx, len(loader), loss.item(), clr[0]))
+        del ret_dict
+        del loss
+    optimizer.scheduler.step()
+    recoder.print_log('\tMean training loss: {:.10f}.'.format(np.mean(loss_value)))
+    del loss_value
+    del clr
+    gc.collect()
+    torch.cuda.empty_cache()
+    return 
+
+
+def seq_eval(cfg, loader, model, device, mode, epoch, work_dir, recoder,
+             evaluate_tool="python"):
+    model.eval()
+    total_sent = []
+    total_info = []
+    total_conv_sent = []
+    stat = {i: [0, 0] for i in range(len(loader.dataset.dict))}
+    for batch_idx, data in enumerate(tqdm(loader)):
+        recoder.record_timer("device")
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        label = device.data_to_device(data[2])
+        label_lgt = device.data_to_device(data[3])
+        with torch.no_grad():
+            ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt)
+
+        total_info += [file_name.split("|")[0] for file_name in data[-1]]
+        total_sent += ret_dict['recognized_sents']
+        total_conv_sent += ret_dict['conv_sents']
+    try:
+        python_eval = True if evaluate_tool == "python" else False
+        write2file(work_dir + "output-hypothesis-{}.ctm".format(mode), total_info, total_sent)
+        write2file(work_dir + "output-hypothesis-{}-conv.ctm".format(mode), total_info,
+                   total_conv_sent)
+        conv_ret = evaluate(
+            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}-conv.ctm".format(mode),
+            evaluate_dir=cfg.dataset_info['evaluation_dir'],
+            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
+            output_dir="epoch_{}_result/".format(epoch),
+            python_evaluate=python_eval,
+        )
+        lstm_ret = evaluate(
+            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}.ctm".format(mode),
+            evaluate_dir=cfg.dataset_info['evaluation_dir'],
+            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
+            output_dir="epoch_{}_result/".format(epoch),
+            python_evaluate=python_eval,
+            triplet=True,
+        )
+    except:
+        print("Unexpected error:", sys.exc_info()[0])
+        lstm_ret = 100.0
+    finally:
+        pass
+    del conv_ret
+    del total_sent
+    del total_info
+    del total_conv_sent
+    del vid
+    del vid_lgt
+    del label
+    del label_lgt
+    gc.collect()
+    recoder.print_log(f"Epoch {epoch}, {mode} {lstm_ret: 2.2f}%", f"{work_dir}/{mode}.txt")
+    return lstm_ret
+
+
+def seq_feature_generation(loader, model, device, mode, work_dir, recoder):
+    model.eval()
+
+    src_path = os.path.abspath(f"{work_dir}{mode}")
+    tgt_path = os.path.abspath(f"./features/{mode}")
+    if not os.path.exists("./features/"):
+        os.makedirs("./features/")
+
+    if os.path.islink(tgt_path):
+        curr_path = os.readlink(tgt_path)
+        if work_dir[1:] in curr_path and os.path.isabs(curr_path):
+            return
+        else:
+            os.unlink(tgt_path)
+    else:
+        if os.path.exists(src_path) and len(loader.dataset) == len(os.listdir(src_path)):
+            os.symlink(src_path, tgt_path)
+            return
+
+    for batch_idx, data in tqdm(enumerate(loader)):
+        recoder.record_timer("device")
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        with torch.no_grad():
+            ret_dict = model(vid, vid_lgt)
+        if not os.path.exists(src_path):
+            os.makedirs(src_path)
+        start = 0
+        for sample_idx in range(len(vid)):
+            end = start + data[3][sample_idx]
+            filename = f"{src_path}/{data[-1][sample_idx].split('|')[0]}_features.npy"
+            save_file = {
+                "label": data[2][start:end],
+                "features": ret_dict['framewise_features'][sample_idx][:, :vid_lgt[sample_idx]].T.cpu().detach(),
+            }
+            np.save(filename, save_file)
+            start = end
+        assert end == len(data[2])
+    os.symlink(src_path, tgt_path)
+
+
+def write2file(path, info, output):
+    filereader = open(path, "w")
+    for sample_idx, sample in enumerate(output):
+        for word_idx, word in enumerate(sample):
+            filereader.writelines(
+                "{} 1 {:.2f} {:.2f} {}\n".format(info[sample_idx],
+                                                 word_idx * 1.0 / 100,
+                                                 (word_idx + 1) * 1.0 / 100,
+                                                 word[0]))

CorrNet_Plus/CorrNet_Plus_CSLR/slr_network.py

@@ -0,0 +1,146 @@
+import pdb
+import copy
+import utils
+import torch
+import types
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models as models
+from modules.criterions import SeqKD
+from modules import BiLSTMLayer, TemporalConv
+import modules.resnet as resnet
+
+class Identity(nn.Module):
+    def __init__(self):
+        super(Identity, self).__init__()
+
+    def forward(self, x):
+        return x
+
+
+class NormLinear(nn.Module):
+    def __init__(self, in_dim, out_dim):
+        super(NormLinear, self).__init__()
+        self.weight = nn.Parameter(torch.Tensor(in_dim, out_dim))
+        nn.init.xavier_uniform_(self.weight, gain=nn.init.calculate_gain('relu'))
+
+    def forward(self, x):
+        outputs = torch.matmul(x, F.normalize(self.weight, dim=0))
+        return outputs
+
+
+class SLRModel(nn.Module):
+    def __init__(
+            self, num_classes, c2d_type, conv_type, use_bn=False,
+            hidden_size=1024, gloss_dict=None, loss_weights=None,
+            weight_norm=True, share_classifier=True
+    ):
+        super(SLRModel, self).__init__()
+        self.decoder = None
+        self.loss = dict()
+        self.criterion_init()
+        self.num_classes = num_classes
+        self.loss_weights = loss_weights
+        #self.conv2d = getattr(models, c2d_type)(pretrained=True)
+        self.conv2d = getattr(resnet, c2d_type)()
+        self.conv2d.fc = Identity()
+
+        self.conv1d = TemporalConv(input_size=512,
+                                   hidden_size=hidden_size,
+                                   conv_type=conv_type,
+                                   use_bn=use_bn,
+                                   num_classes=num_classes)
+        self.decoder = utils.Decode(gloss_dict, num_classes, 'beam')
+        self.temporal_model = BiLSTMLayer(rnn_type='LSTM', input_size=hidden_size, hidden_size=hidden_size,
+                                          num_layers=2, bidirectional=True)
+        if weight_norm:
+            self.classifier = NormLinear(hidden_size, self.num_classes)
+            self.conv1d.fc = NormLinear(hidden_size, self.num_classes)
+        else:
+            self.classifier = nn.Linear(hidden_size, self.num_classes)
+            self.conv1d.fc = nn.Linear(hidden_size, self.num_classes)
+        if share_classifier:
+            self.conv1d.fc = self.classifier
+        #self.register_backward_hook(self.backward_hook)
+
+    def backward_hook(self, module, grad_input, grad_output):
+        for g in grad_input:
+            g[g != g] = 0
+
+    def masked_bn(self, inputs, len_x):
+        def pad(tensor, length):
+            return torch.cat([tensor, tensor.new(length - tensor.size(0), *tensor.size()[1:]).zero_()])
+
+        x = torch.cat([inputs[len_x[0] * idx:len_x[0] * idx + lgt] for idx, lgt in enumerate(len_x)])
+        x = self.conv2d(x)
+        x = torch.cat([pad(x[sum(len_x[:idx]):sum(len_x[:idx + 1])], len_x[0])
+                       for idx, lgt in enumerate(len_x)])
+        return x
+
+    def forward(self, x, len_x, label=None, label_lgt=None):
+        if len(x.shape) == 5:
+            # videos
+            batch, temp, channel, height, width = x.shape
+            #inputs = x.reshape(batch * temp, channel, height, width)
+            #framewise = self.masked_bn(inputs, len_x)
+            #framewise = framewise.reshape(batch, temp, -1).transpose(1, 2)
+            framewise = self.conv2d(x.permute(0,2,1,3,4)).view(batch, temp, -1).permute(0,2,1) # btc -> bct
+        else:
+            # frame-wise features
+            framewise = x
+
+        conv1d_outputs = self.conv1d(framewise, len_x)
+        # x: T, B, C
+        x = conv1d_outputs['visual_feat']
+        lgt = conv1d_outputs['feat_len']
+        tm_outputs = self.temporal_model(x, lgt)
+        outputs = self.classifier(tm_outputs['predictions'])
+        pred = None if self.training \
+            else self.decoder.decode(outputs, lgt, batch_first=False, probs=False)
+        conv_pred = None if self.training \
+            else self.decoder.decode(conv1d_outputs['conv_logits'], lgt, batch_first=False, probs=False)
+
+        return {
+            #"framewise_features": framewise,
+            #"visual_features": x,
+            "feat_len": lgt,
+            "conv_logits": conv1d_outputs['conv_logits'],
+            "sequence_logits": outputs,
+            "conv_sents": conv_pred,
+            "recognized_sents": pred,
+            "loss_LiftPool_u": conv1d_outputs['loss_LiftPool_u'],
+            "loss_LiftPool_p": conv1d_outputs['loss_LiftPool_p'],
+        }
+
+    def criterion_calculation(self, ret_dict, label, label_lgt):
+        loss = 0
+        total_loss = {}
+        for k, weight in self.loss_weights.items():
+            if k == 'ConvCTC':
+                total_loss['ConvCTC'] = weight * self.loss['CTCLoss'](ret_dict["conv_logits"].log_softmax(-1),
+                                                      label.cpu().int(), ret_dict["feat_len"].cpu().int(),
+                                                      label_lgt.cpu().int()).mean()
+                loss += total_loss['ConvCTC']
+            elif k == 'SeqCTC':
+                total_loss['SeqCTC'] = weight * self.loss['CTCLoss'](ret_dict["sequence_logits"].log_softmax(-1),
+                                                      label.cpu().int(), ret_dict["feat_len"].cpu().int(),
+                                                      label_lgt.cpu().int()).mean()
+                loss += total_loss['SeqCTC']
+            elif k == 'Dist':
+                total_loss['Dist'] = weight * self.loss['distillation'](ret_dict["conv_logits"],
+                                                           ret_dict["sequence_logits"].detach(),
+                                                           use_blank=False)
+                loss += total_loss['Dist']
+            elif k == 'Cu':
+                total_loss['Cu'] = weight * ret_dict["loss_LiftPool_u"]
+                loss += total_loss['Cu']
+            elif k == 'Cp':
+                total_loss['Cp'] = weight * ret_dict["loss_LiftPool_p"]   
+                loss += total_loss['Cp'] 
+        return loss, total_loss
+
+    def criterion_init(self):
+        self.loss['CTCLoss'] = torch.nn.CTCLoss(reduction='none', zero_infinity=False)
+        self.loss['distillation'] = SeqKD(T=8)
+        return self.loss

CorrNet_Plus/CorrNet_Plus_CSLR/test_one_video.py

@@ -0,0 +1,124 @@
+#Ref: https://blog.csdn.net/weixin_41735859/article/details/106474768
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+from decord import VideoReader, cpu
+import argparse
+VIDEO_FORMATS = [".mp4", ".avi", ".mov", ".mkv"]
+
+def is_image_by_extension(file_path):
+    _, file_extension = os.path.splitext(file_path)
+
+    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp']
+
+    return file_extension.lower() in image_extensions
+
+def load_video(video_path, max_frames_num=360):
+    if type(video_path) == str:
+        vr = VideoReader(video_path, ctx=cpu(0))
+    elif type(video_path) == list:
+        vr = VideoReader(video_path[0], ctx=cpu(0))
+    else:
+        raise ValueError(f"Not support video input : {type(video_path)}")
+    total_frame_num = len(vr)
+    if total_frame_num> max_frames_num:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, max_frames_num, dtype=int)
+    else:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, dtype=int)
+    frame_idx = uniform_sampled_frames.tolist()
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    return [cv2.cvtColor(tmp, cv2.COLOR_BGR2RGB) for tmp in spare_frames]  # (frames, height, width, channels)
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--model_path", type=str, help="The path to pretrained weights")
+parser.add_argument("--video_path", type=str, help="The path to a video file or a dir contains extracted images from a video")
+parser.add_argument("--device", type=int, default=0, help="Which device to run inference")
+parser.add_argument("--language", type=str, default='phoenix', choices=['phoenix', 'csl'], help="The target sign language")
+parser.add_argument("--max_frames_num", type=int, default=360, help="The max input frames sampled from an input video")
+    
+args = parser.parse_args()
+
+
+device_id = args.device  # specify which gpu to use
+if args.language == 'phoenix':
+    dataset = 'phoenix2014' 
+elif args.language == 'csl':
+    dataset = 'CSL-Daily' 
+else:
+    raise ValueError("Please select target language from ['phoenix', 'csl'] in your command")
+
+
+# Load data and apply transformation
+dict_path = f'./preprocess/{dataset}/gloss_dict.npy'  # Use the gloss dict of phoenix14 dataset 
+gloss_dict = np.load(dict_path, allow_pickle=True).item()
+
+if os.path.isdir(args.video_path): # extracted images of a video
+    img_list = []
+    for img_path in sorted(os.listdir(args.video_path)):
+        cur_path = os.path.join(args.video_path, img_path)
+        if is_image_by_extension(cur_path):
+            img_list.append(cv2.cvtColor(cv2.imread(cur_path), cv2.COLOR_BGR2RGB))
+elif os.path.splitext(args.video_path)[-1] in VIDEO_FORMATS: # Video case
+    try:
+        img_list = load_video(args.video_path, args.max_frames_num)  # frames [height, width, channels]
+    except Exception as e:
+        raise ValueError(f"Error {e} in loading video")
+    
+transform = video_augmentation.Compose([
+                video_augmentation.CenterCrop(224),
+                video_augmentation.Resize(1.0),
+                video_augmentation.ToTensor(),
+            ])
+vid, label = transform(img_list, None, None)
+vid = vid.float() / 127.5 - 1
+vid = vid.unsqueeze(0)
+
+left_pad = 0
+last_stride = 1
+total_stride = 1
+kernel_sizes = ['K5', "P2", 'K5', "P2"]
+for layer_idx, ks in enumerate(kernel_sizes):
+    if ks[0] == 'K':
+        left_pad = left_pad * last_stride 
+        left_pad += int((int(ks[1])-1)/2)
+    elif ks[0] == 'P':
+        last_stride = int(ks[1])
+        total_stride = total_stride * last_stride
+
+max_len = vid.size(1)
+video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+max_len = max_len + left_pad + right_pad
+vid = torch.cat(
+    (
+        vid[0,0][None].expand(left_pad, -1, -1, -1),
+        vid[0],
+        vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+    )
+    , dim=0).unsqueeze(0)
+
+device = utils.GpuDataParallel()
+device.set_device(device_id)
+# Define model and load state-dict
+model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+            loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+state_dict = torch.load(args.model_path)['model_state_dict']
+state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+model.load_state_dict(state_dict, strict=True)
+model = model.to(device.output_device)
+model.cuda()
+
+model.eval()
+
+vid = device.data_to_device(vid)
+vid_lgt = device.data_to_device(video_length)
+ret_dict = model(vid, vid_lgt, label=None, label_lgt=None)
+print('output glosses : {}'.format(ret_dict['recognized_sents']))
+# Example 
+# output glosses : [[('ICH', 0), ('LUFT', 1), ('WETTER', 2), ('GERADE', 3), ('loc-SUEDWEST', 4), ('TEMPERATUR', 5), ('__PU__', 6), ('KUEHL', 7), ('SUED', 8), ('WARM', 9), ('ICH', 10), ('IX', 11)]]

CorrNet_Plus/CorrNet_Plus_CSLR/utils/__init__.py

@@ -0,0 +1,7 @@
+from .device import GpuDataParallel
+from .decode import Decode
+from .optimizer import Optimizer
+from .pack_code import pack_code
+from .parameters import get_parser
+from .random_state import RandomState
+from .record import Recorder

CorrNet_Plus/CorrNet_Plus_CSLR/utils/decode.py

@@ -0,0 +1,66 @@
+import os
+import pdb
+import time
+import torch
+import ctcdecode
+import numpy as np
+from itertools import groupby
+import torch.nn.functional as F
+
+
+class Decode(object):
+    def __init__(self, gloss_dict, num_classes, search_mode, blank_id=0):
+        self.i2g_dict = dict((v[0], k) for k, v in gloss_dict.items())
+        self.g2i_dict = {v: k for k, v in self.i2g_dict.items()}
+        self.num_classes = num_classes
+        self.search_mode = search_mode
+        self.blank_id = blank_id
+        vocab = [chr(x) for x in range(20000, 20000 + num_classes)]
+        self.ctc_decoder = ctcdecode.CTCBeamDecoder(vocab, beam_width=10, blank_id=blank_id,
+                                                    num_processes=10)
+
+    def decode(self, nn_output, vid_lgt, batch_first=True, probs=False):
+        if not batch_first:
+            nn_output = nn_output.permute(1, 0, 2)
+        if self.search_mode == "max":
+            return self.MaxDecode(nn_output, vid_lgt)
+        else:
+            return self.BeamSearch(nn_output, vid_lgt, probs)
+
+    def BeamSearch(self, nn_output, vid_lgt, probs=False):
+        '''
+        CTCBeamDecoder Shape:
+                - Input:  nn_output (B, T, N), which should be passed through a softmax layer
+                - Output: beam_resuls (B, N_beams, T), int, need to be decoded by i2g_dict
+                          beam_scores (B, N_beams), p=1/np.exp(beam_score)
+                          timesteps (B, N_beams)
+                          out_lens (B, N_beams)
+        '''
+        if not probs:
+            nn_output = nn_output.softmax(-1).cpu()
+        vid_lgt = vid_lgt.cpu()
+        beam_result, beam_scores, timesteps, out_seq_len = self.ctc_decoder.decode(nn_output, vid_lgt)
+        ret_list = []
+        for batch_idx in range(len(nn_output)):
+            first_result = beam_result[batch_idx][0][:out_seq_len[batch_idx][0]]
+            if len(first_result) != 0:
+                first_result = torch.stack([x[0] for x in groupby(first_result)])
+            ret_list.append([(self.i2g_dict[int(gloss_id)], idx) for idx, gloss_id in
+                             enumerate(first_result)])
+        return ret_list
+
+    def MaxDecode(self, nn_output, vid_lgt):
+        index_list = torch.argmax(nn_output, axis=2)
+        batchsize, lgt = index_list.shape
+        ret_list = []
+        for batch_idx in range(batchsize):
+            group_result = [x[0] for x in groupby(index_list[batch_idx][:vid_lgt[batch_idx]])]
+            filtered = [*filter(lambda x: x != self.blank_id, group_result)]
+            if len(filtered) > 0:
+                max_result = torch.stack(filtered)
+                max_result = [x[0] for x in groupby(max_result)]
+            else:
+                max_result = filtered
+            ret_list.append([(self.i2g_dict[int(gloss_id)], idx) for idx, gloss_id in
+                             enumerate(max_result)])
+        return ret_list

CorrNet_Plus/CorrNet_Plus_CSLR/utils/device.py

@@ -0,0 +1,57 @@
+import os
+import pdb
+import torch
+import torch.nn as nn
+
+
+class GpuDataParallel(object):
+    def __init__(self):
+        self.gpu_list = []
+        self.output_device = None
+
+    def set_device(self, device):
+        device = str(device)
+        if device != 'None':
+            self.gpu_list = [i for i in range(len(device.split(',')))]
+            os.environ["CUDA_VISIBLE_DEVICES"] = device
+            output_device = self.gpu_list[0]
+            self.occupy_gpu(self.gpu_list)
+        self.output_device = output_device if len(self.gpu_list) > 0 else "cpu"
+
+    def model_to_device(self, model):
+        # model = convert_model(model)
+        model = model.to(self.output_device)
+        if len(self.gpu_list) > 1:
+            model = nn.DataParallel(
+                model,
+                device_ids=self.gpu_list,
+                output_device=self.output_device)
+        return model
+
+    def data_to_device(self, data):
+        if isinstance(data, torch.FloatTensor):
+            return data.to(self.output_device)
+        elif isinstance(data, torch.DoubleTensor):
+            return data.float().to(self.output_device)
+        elif isinstance(data, torch.ByteTensor):
+            return data.long().to(self.output_device)
+        elif isinstance(data, torch.LongTensor):
+            return data.to(self.output_device)
+        elif isinstance(data, list) or isinstance(data, tuple):
+            return [self.data_to_device(d) for d in data]
+        else:
+            raise ValueError(data.shape, "Unknown Dtype: {}".format(data.dtype))
+
+    def criterion_to_device(self, loss):
+        return loss.to(self.output_device)
+
+    def occupy_gpu(self, gpus=None):
+        """
+            make program appear on nvidia-smi.
+        """
+        if len(gpus) == 0:
+            torch.zeros(1).cuda()
+        else:
+            gpus = [gpus] if isinstance(gpus, int) else list(gpus)
+            for g in gpus:
+                torch.zeros(1).cuda(g)

CorrNet_Plus/CorrNet_Plus_CSLR/utils/optimizer.py

@@ -0,0 +1,59 @@
+import pdb
+import torch
+import numpy as np
+import torch.optim as optim
+
+
+class Optimizer(object):
+    def __init__(self, model, optim_dict):
+        self.optim_dict = optim_dict
+        if self.optim_dict["optimizer"] == 'SGD':
+            self.optimizer = optim.SGD(
+                model,
+                lr=self.optim_dict['base_lr'],
+                momentum=0.9,
+                nesterov=self.optim_dict['nesterov'],
+                weight_decay=self.optim_dict['weight_decay']
+            )
+        elif self.optim_dict["optimizer"] == 'Adam':
+            alpha = self.optim_dict['learning_ratio']
+            self.optimizer = optim.Adam(
+                # [
+                #     {'params': model.conv2d.parameters(), 'lr': self.optim_dict['base_lr']*alpha},
+                #     {'params': model.conv1d.parameters(), 'lr': self.optim_dict['base_lr']*alpha},
+                #     {'params': model.rnn.parameters()},
+                #     {'params': model.classifier.parameters()},
+                # ],
+                # model.conv1d.fc.parameters(),
+                model.parameters(),
+                lr=self.optim_dict['base_lr'],
+                weight_decay=self.optim_dict['weight_decay']
+            )
+        else:
+            raise ValueError()
+        self.scheduler = self.define_lr_scheduler(self.optimizer, self.optim_dict['step'])
+
+    def define_lr_scheduler(self, optimizer, milestones):
+        if self.optim_dict["optimizer"] in ['SGD', 'Adam']:
+            lr_scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=milestones, gamma=0.2)
+            return lr_scheduler
+        else:
+            raise ValueError()
+
+    def zero_grad(self):
+        self.optimizer.zero_grad()
+
+    def step(self):
+        self.optimizer.step()
+
+    def state_dict(self):
+        return self.optimizer.state_dict()
+
+    def load_state_dict(self, state_dict):
+        self.optimizer.load_state_dict(state_dict)
+
+    def to(self, device):
+        for state in self.optimizer.state.values():
+            for k, v in state.items():
+                if isinstance(v, torch.Tensor):
+                    state[k] = v.to(device)

CorrNet_Plus/CorrNet_Plus_CSLR/utils/pack_code.py

@@ -0,0 +1,24 @@
+import subprocess
+from pathlib import Path
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+
+def pack_code(git_root, run_dir):
+    if os.path.isdir(f"{git_root}/.git"):
+        subprocess.run(
+            ['git', 'archive', '-o', f"{run_dir}/code.tar.gz", 'HEAD'],
+            check=True,
+        )
+        diff_process = subprocess.run(
+            ['git', 'diff', 'HEAD'],
+            check=True, stdout=subprocess.PIPE, text=True,
+        )
+        if diff_process.stdout:
+            logger.warning('Working tree is dirty. Patch:\n%s', diff_process.stdout)
+            with open(f"{run_dir}/dirty.patch", 'w') as f:
+                f.write(diff_process.stdout)
+    else:
+        logger.warning('.git does not exist in current dir')

CorrNet_Plus/CorrNet_Plus_CSLR/utils/parameters.py

@@ -0,0 +1,159 @@
+import argparse
+
+
+def get_parser():
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # parameter priority: command line > config > default
+    parser = argparse.ArgumentParser(
+        description='The pytorch implementation for Visual Alignment Constraint '
+                    'for Continuous Sign Language Recognition.')
+    parser.add_argument(
+        '--work-dir',
+        default='./work_dir/temp',
+        help='the work folder for storing results')
+    parser.add_argument(
+        '--config',
+        default='./configs/baseline.yaml',
+        help='path to the configuration file')
+    parser.add_argument(
+        '--random_fix',
+        type=str2bool,
+        default=True,
+        help='fix random seed or not')
+    parser.add_argument(
+        '--device',
+        type=str,
+        default=0,
+        help='the indexes of GPUs for training or testing')
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # processor
+    parser.add_argument(
+        '--phase', default='train', help='can be train, test and features')
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # debug
+    parser.add_argument(
+        '--save-interval',
+        type=int,
+        default=200,
+        help='the interval for storing models (#epochs)')
+    parser.add_argument(
+        '--random-seed',
+        type=int,
+        default=0,
+        help='the default value for random seed.')
+    parser.add_argument(
+        '--eval-interval',
+        type=int,
+        default=100,
+        help='the interval for evaluating models (#epochs)')
+    parser.add_argument(
+        '--print-log',
+        type=str2bool,
+        default=True,
+        help='print logging or not')
+    parser.add_argument(
+        '--log-interval',
+        type=int,
+        default=20,
+        help='the interval for printing messages (#iteration)')
+    parser.add_argument(
+        '--evaluate-tool', default="python", help='sclite or python')
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # feeder
+    parser.add_argument(
+        '--feeder', default='dataloader_video.BaseFeeder', help='data loader will be used')
+    parser.add_argument(
+        '--dataset',
+        default=None,
+        help='data loader will be used'
+    )
+    parser.add_argument(
+        '--dataset-info',
+        default=dict(),
+        help='data loader will be used'
+    )
+    parser.add_argument(
+        '--num-worker',
+        type=int,
+        default=4,
+        help='the number of worker for data loader')
+    parser.add_argument(
+        '--feeder-args',
+        default=dict(),
+        help='the arguments of data loader')
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # model
+    parser.add_argument('--model', default=None, help='the model will be used')
+    parser.add_argument(
+        '--model-args',
+        type=dict,
+        default=dict(),
+        help='the arguments of model')
+    parser.add_argument(
+        '--load-weights',
+        default=None,
+        help='load weights for network initialization')
+    parser.add_argument(
+        '--load-checkpoints',
+        default=None,
+        help='load checkpoints for continue training')
+    parser.add_argument(
+        '--decode-mode',
+        default="max",
+        help='search mode for decode, max or beam')
+    parser.add_argument(
+        '--ignore-weights',
+        type=str,
+        default=[],
+        nargs='+',
+        help='the name of weights which will be ignored in the initialization')
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # optim
+    parser.add_argument(
+        '--batch-size', type=int, default=16, help='training batch size')
+    parser.add_argument(
+        '--test-batch-size', type=int, default=8, help='test batch size')
+
+    default_optimizer_dict = {
+        "base_lr": 1e-2,
+        "optimizer": "SGD",
+        "nesterov": False,
+        "step": [5, 10],
+        "weight_decay": 0.00005,
+        "start_epoch": 1,
+    }
+    default_loss_dict = {
+        "SeqCTC": 1.0,
+    }
+
+    parser.add_argument(
+        '--loss-weights',
+        default=default_loss_dict,
+        help='loss selection'
+    )
+
+    parser.add_argument(
+        '--optimizer-args',
+        default=default_optimizer_dict,
+        help='the arguments of optimizer')
+
+    parser.add_argument(
+        '--num-epoch',
+        type=int,
+        default=80,
+        help='stop training in which epoch')
+    return parser
+
+
+def str2bool(v):
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')

CorrNet_Plus/CorrNet_Plus_CSLR/utils/random_state.py

@@ -0,0 +1,32 @@
+import pdb
+import torch
+import random
+import numpy as np
+import os
+
+
+class RandomState(object):
+    def __init__(self, seed):
+        torch.set_num_threads(1)
+        os.environ['PYTHONHASHSEED'] = str(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+        torch.manual_seed(seed)
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        np.random.seed(seed)
+        random.seed(seed)
+
+    def save_rng_state(self):
+        rng_dict = {}
+        rng_dict["torch"] = torch.get_rng_state()
+        rng_dict["cuda"] = torch.cuda.get_rng_state_all()
+        rng_dict["numpy"] = np.random.get_state()
+        rng_dict["random"] = random.getstate()
+        return rng_dict
+
+    def set_rng_state(self, rng_dict):
+        torch.set_rng_state(rng_dict["torch"])
+        torch.cuda.set_rng_state_all(rng_dict["cuda"])
+        np.random.set_state(rng_dict["numpy"])
+        random.setstate(rng_dict["random"])

CorrNet_Plus/CorrNet_Plus_CSLR/utils/record.py

@@ -0,0 +1,51 @@
+import pdb
+import time
+
+
+class Recorder(object):
+    def __init__(self, work_dir, print_log, log_interval):
+        self.cur_time = time.time()
+        self.print_log_flag = print_log
+        self.log_interval = log_interval
+        self.log_path = '{}/log.txt'.format(work_dir)
+        self.timer = dict(dataloader=0.001, device=0.001, forward=0.001, backward=0.001)
+
+    def print_time(self):
+        localtime = time.asctime(time.localtime(time.time()))
+        self.print_log("Local current time :  " + localtime)
+
+    def print_log(self, str, path=None, print_time=True):
+        if path is None:
+            path = self.log_path
+        if print_time:
+            localtime = time.asctime(time.localtime(time.time()))
+            str = "[ " + localtime + ' ] ' + str
+        print(str)
+        if self.print_log_flag:
+            with open(path, 'a') as f:
+                f.writelines(str)
+                f.writelines("\n")
+
+    def record_time(self):
+        self.cur_time = time.time()
+        return self.cur_time
+
+    def split_time(self):
+        split_time = time.time() - self.cur_time
+        self.record_time()
+        return split_time
+
+    def timer_reset(self):
+        self.cur_time = time.time()
+        self.timer = dict(dataloader=0.001, device=0.001, forward=0.001, backward=0.001)
+
+    def record_timer(self, key):
+        self.timer[key] += self.split_time()
+
+    def print_time_statistics(self):
+        proportion = {
+            k: '{:02d}%'.format(int(round(v * 100 / sum(self.timer.values()))))
+            for k, v in self.timer.items()}
+        self.print_log(
+            '\tTime consumption: [Data]{dataloader}, [GPU]{device}, [Forward]{forward}, [Backward]{backward}'.format(
+                **proportion))

CorrNet_Plus/CorrNet_Plus_CSLR/utils/video_augmentation.py

@@ -0,0 +1,336 @@
+# ----------------------------------------
+# Written by Yuecong Min
+# ----------------------------------------
+import cv2
+import pdb
+import PIL
+import copy
+import scipy.misc
+import torch
+import random
+import numbers
+import numpy as np
+
+
+class Compose(object):
+    def __init__(self, transforms):
+        self.transforms = transforms
+
+    def __call__(self, image, label, file_info=None):
+        for t in self.transforms:
+            if file_info is not None and isinstance(t, WERAugment):
+                image, label = t(image, label, file_info)
+            else:
+                image = t(image)
+        return image, label
+
+
+class WERAugment(object):
+    def __init__(self, boundary_path):
+        self.boundary_dict = np.load(boundary_path, allow_pickle=True).item()
+        self.K = 3
+
+    def __call__(self, video, label, file_info):
+        ind = np.arange(len(video)).tolist()
+        if file_info not in self.boundary_dict.keys():
+            return video, label
+        binfo = copy.deepcopy(self.boundary_dict[file_info])
+        binfo = [0] + binfo + [len(video)]
+        k = np.random.randint(min(self.K, len(label) - 1))
+        for i in range(k):
+            ind, label, binfo = self.one_operation(ind, label, binfo)
+        ret_video = [video[i] for i in ind]
+        return ret_video, label
+
+    def one_operation(self, *inputs):
+        prob = np.random.random()
+        if prob < 0.3:
+            return self.delete(*inputs)
+        elif 0.3 <= prob < 0.7:
+            return self.substitute(*inputs)
+        else:
+            return self.insert(*inputs)
+
+    @staticmethod
+    def delete(ind, label, binfo):
+        del_wd = np.random.randint(len(label))
+        ind = ind[:binfo[del_wd]] + ind[binfo[del_wd + 1]:]
+        duration = binfo[del_wd + 1] - binfo[del_wd]
+        del label[del_wd]
+        binfo = [i for i in binfo[:del_wd]] + [i - duration for i in binfo[del_wd + 1:]]
+        return ind, label, binfo
+
+    @staticmethod
+    def insert(ind, label, binfo):
+        ins_wd = np.random.randint(len(label))
+        ins_pos = np.random.choice(binfo)
+        ins_lab_pos = binfo.index(ins_pos)
+
+        ind = ind[:ins_pos] + ind[binfo[ins_wd]:binfo[ins_wd + 1]] + ind[ins_pos:]
+        duration = binfo[ins_wd + 1] - binfo[ins_wd]
+        label = label[:ins_lab_pos] + [label[ins_wd]] + label[ins_lab_pos:]
+        binfo = binfo[:ins_lab_pos] + [binfo[ins_lab_pos - 1] + duration] + [i + duration for i in binfo[ins_lab_pos:]]
+        return ind, label, binfo
+
+    @staticmethod
+    def substitute(ind, label, binfo):
+        sub_wd = np.random.randint(len(label))
+        tar_wd = np.random.randint(len(label))
+
+        ind = ind[:binfo[tar_wd]] + ind[binfo[sub_wd]:binfo[sub_wd + 1]] + ind[binfo[tar_wd + 1]:]
+        label[tar_wd] = label[sub_wd]
+        delta_duration = binfo[sub_wd + 1] - binfo[sub_wd] - (binfo[tar_wd + 1] - binfo[tar_wd])
+        binfo = binfo[:tar_wd + 1] + [i + delta_duration for i in binfo[tar_wd + 1:]]
+        return ind, label, binfo
+
+
+class ToTensor(object):
+    def __call__(self, video):
+        if isinstance(video, list):
+            video = np.array(video)
+            video = torch.from_numpy(video.transpose((0, 3, 1, 2))).float()
+        if isinstance(video, np.ndarray):
+            video = torch.from_numpy(video.transpose((0, 3, 1, 2)))
+        return video
+
+
+class RandomCrop(object):
+    """
+    Extract random crop of the video.
+    Args:
+        size (sequence or int): Desired output size for the crop in format (h, w).
+        crop_position (str): Selected corner (or center) position from the
+        list ['c', 'tl', 'tr', 'bl', 'br']. If it is non, crop position is
+        selected randomly at each call.
+    """
+
+    def __init__(self, size):
+        if isinstance(size, numbers.Number):
+            if size < 0:
+                raise ValueError('If size is a single number, it must be positive')
+            size = (size, size)
+        else:
+            if len(size) != 2:
+                raise ValueError('If size is a sequence, it must be of len 2.')
+        self.size = size
+
+    def __call__(self, clip):
+        crop_h, crop_w = self.size
+        if isinstance(clip[0], np.ndarray):
+            im_h, im_w, im_c = clip[0].shape
+        elif isinstance(clip[0], PIL.Image.Image):
+            im_w, im_h = clip[0].size
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+        if crop_w > im_w:
+            pad = crop_w - im_w
+            clip = [np.pad(img, ((0, 0), (pad // 2, pad - pad // 2), (0, 0)), 'constant', constant_values=0) for img in
+                    clip]
+            w1 = 0
+        else:
+            w1 = random.randint(0, im_w - crop_w)
+
+        if crop_h > im_h:
+            pad = crop_h - im_h
+            clip = [np.pad(img, ((pad // 2, pad - pad // 2), (0, 0), (0, 0)), 'constant', constant_values=0) for img in
+                    clip]
+            h1 = 0
+        else:
+            h1 = random.randint(0, im_h - crop_h)
+
+        if isinstance(clip[0], np.ndarray):
+            return [img[h1:h1 + crop_h, w1:w1 + crop_w, :] for img in clip]
+        elif isinstance(clip[0], PIL.Image.Image):
+            return [img.crop((w1, h1, w1 + crop_w, h1 + crop_h)) for img in clip]
+
+
+class CenterCrop(object):
+    def __init__(self, size):
+        if isinstance(size, numbers.Number):
+            self.size = (int(size), int(size))
+        else:
+            self.size = size
+
+    def __call__(self, clip):
+        try:
+            im_h, im_w, im_c = clip[0].shape
+        except ValueError:
+            print(clip[0].shape)
+        new_h, new_w = self.size
+        new_h = im_h if new_h >= im_h else new_h
+        new_w = im_w if new_w >= im_w else new_w
+        top = int(round((im_h - new_h) / 2.))
+        left = int(round((im_w - new_w) / 2.))
+        return [img[top:top + new_h, left:left + new_w] for img in clip]
+
+
+class RandomHorizontalFlip(object):
+    def __init__(self, prob):
+        self.prob = prob
+
+    def __call__(self, clip):
+        # B, H, W, 3
+        flag = random.random() < self.prob
+        if flag:
+            clip = np.flip(clip, axis=2)
+            clip = np.ascontiguousarray(copy.deepcopy(clip))
+        return np.array(clip)
+
+
+class RandomRotation(object):
+    """
+    Rotate entire clip randomly by a random angle within
+    given bounds
+    Args:
+    degrees (sequence or int): Range of degrees to select from
+    If degrees is a number instead of sequence like (min, max),
+    the range of degrees, will be (-degrees, +degrees).
+    """
+
+    def __init__(self, degrees):
+        if isinstance(degrees, numbers.Number):
+            if degrees < 0:
+                raise ValueError('If degrees is a single number,'
+                                 'must be positive')
+            degrees = (-degrees, degrees)
+        else:
+            if len(degrees) != 2:
+                raise ValueError('If degrees is a sequence,'
+                                 'it must be of len 2.')
+        self.degrees = degrees
+
+    def __call__(self, clip):
+        """
+        Args:
+        img (PIL.Image or numpy.ndarray): List of images to be cropped
+        in format (h, w, c) in numpy.ndarray
+        Returns:
+        PIL.Image or numpy.ndarray: Cropped list of images
+        """
+        angle = random.uniform(self.degrees[0], self.degrees[1])
+        if isinstance(clip[0], np.ndarray):
+            rotated = [scipy.misc.imrotate(img, angle) for img in clip]
+        elif isinstance(clip[0], PIL.Image.Image):
+            rotated = [img.rotate(angle) for img in clip]
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+        return rotated
+
+
+class TemporalRescale(object):
+    def __init__(self, temp_scaling=0.2, frame_interval=1):
+        self.min_len = 32
+        self.max_len = int(np.ceil(230/frame_interval))
+        self.L = 1.0 - temp_scaling
+        self.U = 1.0 + temp_scaling
+
+    def __call__(self, clip):
+        vid_len = len(clip)
+        new_len = int(vid_len * (self.L + (self.U - self.L) * np.random.random()))
+        if new_len < self.min_len:
+            new_len = self.min_len
+        if new_len > self.max_len:
+            new_len = self.max_len
+        if (new_len - 4) % 4 != 0:
+            new_len += 4 - (new_len - 4) % 4
+        if new_len <= vid_len:
+            index = sorted(random.sample(range(vid_len), new_len))
+        else:
+            index = sorted(random.choices(range(vid_len), k=new_len))
+        return clip[index]
+
+
+class RandomResize(object):
+    """
+    Resize video bysoomingin and out.
+    Args:
+        rate (float): Video is scaled uniformly between
+        [1 - rate, 1 + rate].
+        interp (string): Interpolation to use for re-sizing
+        ('nearest', 'lanczos', 'bilinear', 'bicubic' or 'cubic').
+    """
+
+    def __init__(self, rate=0.0, interp='bilinear'):
+        self.rate = rate
+        self.interpolation = interp
+
+    def __call__(self, clip):
+        scaling_factor = random.uniform(1 - self.rate, 1 + self.rate)
+
+        if isinstance(clip[0], np.ndarray):
+            im_h, im_w, im_c = clip[0].shape
+        elif isinstance(clip[0], PIL.Image.Image):
+            im_w, im_h = clip[0].size
+
+        new_w = int(im_w * scaling_factor)
+        new_h = int(im_h * scaling_factor)
+        new_size = (new_h, new_w)
+        if isinstance(clip[0], np.ndarray):
+            return [scipy.misc.imresize(img, size=(new_h, new_w), interp=self.interpolation) for img in clip]
+        elif isinstance(clip[0], PIL.Image.Image):
+            return [img.resize(size=(new_w, new_h), resample=self._get_PIL_interp(self.interpolation)) for img in clip]
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+
+    def _get_PIL_interp(self, interp):
+        if interp == 'nearest':
+            return PIL.Image.NEAREST
+        elif interp == 'lanczos':
+            return PIL.Image.LANCZOS
+        elif interp == 'bilinear':
+            return PIL.Image.BILINEAR
+        elif interp == 'bicubic':
+            return PIL.Image.BICUBIC
+        elif interp == 'cubic':
+            return PIL.Image.CUBIC
+
+
+class Resize(object):
+    """
+    Resize video bysoomingin and out.
+    Args:
+        rate (float): Video is scaled uniformly between
+        [1 - rate, 1 + rate].
+        interp (string): Interpolation to use for re-sizing
+        ('nearest', 'lanczos', 'bilinear', 'bicubic' or 'cubic').
+    """
+
+    def __init__(self, rate=0.0, interp='bilinear'):
+        self.rate = rate
+        self.interpolation = interp
+
+    def __call__(self, clip):
+        if self.rate == 1.0:
+            return clip
+        scaling_factor = self.rate
+
+        if isinstance(clip[0], np.ndarray):
+            im_h, im_w, im_c = clip[0].shape
+        elif isinstance(clip[0], PIL.Image.Image):
+            im_w, im_h = clip[0].size
+
+        new_w = int(im_w * scaling_factor) if scaling_factor>0 and scaling_factor<=1 else int(scaling_factor)
+        new_h = int(im_h * scaling_factor) if scaling_factor>0 and scaling_factor<=1 else int(scaling_factor)
+        new_size = (new_w, new_h)
+        if isinstance(clip[0], np.ndarray):
+            return [np.array(PIL.Image.fromarray(img).resize(new_size)) for img in clip]
+        elif isinstance(clip[0], PIL.Image.Image):
+            return [img.resize(size=(new_w, new_h), resample=self._get_PIL_interp(self.interpolation)) for img in clip]
+        else:
+            raise TypeError('Expected numpy.ndarray or PIL.Image' +
+                            'but got list of {0}'.format(type(clip[0])))
+
+    def _get_PIL_interp(self, interp):
+        if interp == 'nearest':
+            return PIL.Image.NEAREST
+        elif interp == 'lanczos':
+            return PIL.Image.LANCZOS
+        elif interp == 'bilinear':
+            return PIL.Image.BILINEAR
+        elif interp == 'bicubic':
+            return PIL.Image.BICUBIC
+        elif interp == 'cubic':
+            return PIL.Image.CUBIC

CorrNet_Plus/CorrNet_Plus_CSLR/weight_map_generation/resnet.py

@@ -0,0 +1,309 @@
+import torch
+import torch.nn as nn
+import torch.utils.model_zoo as model_zoo
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+__all__ = [
+    'ResNet', 'resnet10', 'resnet18', 'resnet34', 'resnet50', 'resnet101',
+    'resnet152', 'resnet200'
+]
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-333f7ec4.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-19c8e357.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-5d3b4d8f.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-b121ed2d.pth',
+}
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None, clusters=1):
+        super().__init__()
+        #self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+        self.clusters = clusters
+        self.query = nn.Parameter(torch.rand(self.clusters, 1, embed_dim), requires_grad=True)
+
+    def forward(self, x):
+        N, C, T, H, W= x.shape
+        x = x.flatten(start_dim=3).permute(3, 0, 2, 1).reshape(-1, N*T, C).contiguous()  # NCTHW -> (HW)(NT)C
+        #x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)(NT)C
+        #x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)(NT)C
+        x, _ = F.multi_head_attention_forward(
+            #query=x[:1], key=x, value=x,
+            query=self.query.repeat(1,N*T,1), key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.view(self.clusters,N,T,C).contiguous().permute(1,3,2,0) #PNTC->NCTP
+
+class UnfoldTemporalWindows(nn.Module):
+    def __init__(self, window_size=9, window_stride=1, window_dilation=1):
+        super().__init__()
+        self.window_size = window_size
+        self.window_stride = window_stride
+        self.window_dilation = window_dilation
+
+        self.padding = (window_size + (window_size-1) * (window_dilation-1) - 1) // 2
+        self.unfold = nn.Unfold(kernel_size=(self.window_size, 1),
+                                dilation=(self.window_dilation, 1),
+                                stride=(self.window_stride, 1),
+                                padding=(self.padding, 0))
+
+    def forward(self, x):
+        # Input shape: (N,C,T,H,W), out: (N,C,T,V*window_size)
+        N, C, T, H, W = x.shape
+        x = x.view(N, C, T, H*W)
+        x = self.unfold(x)  #(N, C*Window_Size, T, H*W)
+        # Permute extra channels from window size to the graph dimension; -1 for number of windows
+        x = x.view(N, C, self.window_size, T, H, W).permute(0,1,3,2,4,5).reshape(N, C, T, self.window_size, H, W).contiguous()# NCTSHW
+        return x
+
+class Temporal_weighting(nn.Module):
+    def __init__(self, input_size ):
+        super().__init__()
+        hidden_size = input_size//16
+        self.conv_transform = nn.Conv1d(input_size, hidden_size, kernel_size=1, stride=1, padding=0)
+        self.conv_back = nn.Conv1d(hidden_size, input_size, kernel_size=1, stride=1, padding=0)
+        self.num = 3
+        self.conv_enhance = nn.ModuleList([
+            nn.Conv1d(hidden_size, hidden_size, kernel_size=3, stride=1, padding=int(i+1), groups=hidden_size, dilation=int(i+1)) for i in range(self.num)
+        ])
+        self.weights = nn.Parameter(torch.ones(self.num) / self.num, requires_grad=True)
+        self.alpha = nn.Parameter(torch.zeros(1), requires_grad=True)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        out = self.conv_transform(x.mean(-1).mean(-1))
+        aggregated_out = 0
+        for i in range(self.num):
+            aggregated_out += self.conv_enhance[i](out) * self.weights[i]
+        out = self.conv_back(aggregated_out)
+        return x*(F.sigmoid(out.unsqueeze(-1).unsqueeze(-1))-0.5) * self.alpha
+
+class Get_Correlation(nn.Module):
+    def __init__(self, channels, neighbors=3, save_weight_map=False):
+        super().__init__()
+        self.save_weight_map = save_weight_map
+        reduction_channel = channels//16
+
+        self.down_conv2 = nn.Conv3d(channels, channels, kernel_size=1, bias=False)
+        self.neighbors = neighbors
+        self.clusters = 1
+        self.weights2 = nn.Parameter(torch.ones(self.neighbors*2) / (self.neighbors*2), requires_grad=True)
+        self.unfold = UnfoldTemporalWindows(2*self.neighbors+1)
+        self.weights3 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.weights4 = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.attpool = AttentionPool2d(spacial_dim=None, embed_dim=channels, num_heads=1, clusters=self.clusters)
+        self.mlp = nn.Sequential(nn.Conv3d(channels, reduction_channel, kernel_size=1),
+                                 nn.GELU(),
+                                nn.Conv3d(reduction_channel, channels, kernel_size=1),)
+
+        # For generating aggregated_x with multi-scale conv
+        self.down_conv = nn.Conv3d(channels, reduction_channel, kernel_size=1, bias=False)
+        self.spatial_aggregation1 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,1,1), groups=reduction_channel)
+        self.spatial_aggregation2 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,2,2), dilation=(1,2,2), groups=reduction_channel)
+        self.spatial_aggregation3 = nn.Conv3d(reduction_channel, reduction_channel, kernel_size=(9,3,3), padding=(4,3,3), dilation=(1,3,3), groups=reduction_channel)
+        self.weights = nn.Parameter(torch.ones(3) / 3, requires_grad=True)
+        self.conv_back = nn.Conv3d(reduction_channel, channels, kernel_size=1, bias=False)
+
+    def forward(self, x):
+        N, C, T, H, W = x.shape
+        def clustering(query, key):
+            affinities = torch.einsum('bctp,bctl->btpl', query, key)
+            return torch.einsum('bctl,btpl->bctp', key, F.sigmoid(affinities)-0.5)
+
+        x_mean = x.mean(3, keepdim=True).mean(4, keepdim=False)
+        x_max = x.max(-1, keepdim=False)[0].max(-1, keepdim=True)[0]
+        x_att = self.attpool(x) #NCTP
+        x2 = self.down_conv2(x)
+        upfold = self.unfold(x2)
+        upfold = (torch.concat([upfold[:,:,:,:self.neighbors], upfold[:,:,:,self.neighbors+1:]],3)* self.weights2.view(1, 1, 1, -1, 1, 1)).view(N, C, T, -1)
+        x_mean = x_mean*self.weights4[0] + x_max*self.weights4[1] + x_att*self.weights4[2]
+        x_mean = clustering(x_mean, upfold)
+        features = x_mean.view(N, C, T, self.clusters, 1)
+
+        x_down = self.down_conv(x)
+        aggregated_x = self.spatial_aggregation1(x_down)*self.weights[0] + self.spatial_aggregation2(x_down)*self.weights[1] \
+                    + self.spatial_aggregation3(x_down)*self.weights[2]
+        aggregated_x = self.conv_back(aggregated_x)
+        
+        if self.save_weight_map:
+            torch.save(F.sigmoid(aggregated_x)-0.5, "./weight_map.pth")
+            return features * (F.sigmoid(aggregated_x)-0.5)
+        else:
+            return features * (F.sigmoid(aggregated_x)-0.5)
+        
+
+def conv3x3(in_planes, out_planes, stride=1):
+    # 3x3x3 convolution with padding
+    return nn.Conv3d(
+        in_planes,
+        out_planes,
+        kernel_size=(1,3,3),
+        stride=(1,stride,stride),
+        padding=(0,1,1),
+        bias=False)
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride)
+        self.bn1 = nn.BatchNorm3d(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes)
+        self.bn2 = nn.BatchNorm3d(planes)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+class ResNet(nn.Module):
+
+    def __init__(self, block, layers, num_classes=1000):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv3d(3, 64, kernel_size=(1,7,7), stride=(1,2,2), padding=(0,3,3),
+                               bias=False)
+        self.bn1 = nn.BatchNorm3d(64)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool3d(kernel_size=(1,3,3), stride=(1,2,2), padding=(0,1,1))
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.corr2 = Get_Correlation(self.inplanes, neighbors=1)
+        self.temporal_weight2 = Temporal_weighting(self.inplanes)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.corr3 = Get_Correlation(self.inplanes, neighbors=3, save_weight_map=True)
+        self.temporal_weight3 = Temporal_weighting(self.inplanes)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+        self.corr4 = Get_Correlation(self.inplanes, neighbors=5)
+        self.temporal_weight4 = Temporal_weighting(self.inplanes)
+        self.alpha = nn.Parameter(torch.zeros(3), requires_grad=True)
+        self.avgpool = nn.AvgPool2d(7, stride=1)
+        self.fc = nn.Linear(512 * block.expansion, num_classes)
+        
+        for m in self.modules():
+            if isinstance(m, nn.Conv3d) or isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.BatchNorm3d) or isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv3d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=(1,stride,stride), bias=False),
+                nn.BatchNorm3d(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        N, C, T, H, W = x.size()
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x) 
+        #aug_x, affinities = self.corr2(x)
+        #x = x + aug_x * self.alpha[0]
+        #x = x + (affinities-0.5)*x
+        x = x + self.corr2(x) * self.alpha[0]
+        x = x + self.temporal_weight2(x)
+        x = self.layer3(x)
+        #aug_x, affinities = self.corr3(x)
+        #x = x + aug_x * self.alpha[1]
+        #x = x + (affinities-0.5)*x
+        x = x + self.corr3(x) * self.alpha[1]
+        x = x + self.temporal_weight3(x)
+        x = self.layer4(x)
+        #x = checkpoint(self.layer4, x)
+        #aug_x, affinities = self.corr4(x)
+        #x = x + aug_x * self.alpha[2]
+        #x = x + (affinities-0.5)*x
+        x = x + self.corr4(x) * self.alpha[2]
+        x = x + self.temporal_weight4(x)
+        #x = checkpoint(self.layer3, x)
+        
+        x = x.transpose(1,2).contiguous()
+        x = x.view((-1,)+x.size()[2:]) #bt,c,h,w
+
+        x = self.avgpool(x)
+        x = x.view(x.size(0), -1) #bt,c
+        x = self.fc(x) #bt,c
+
+        return x
+
+def resnet18(**kwargs):
+    """Constructs a ResNet-18 based model.
+    """
+    model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
+    checkpoint = model_zoo.load_url(model_urls['resnet18'], map_location=torch.device('cpu'))
+    layer_name = list(checkpoint.keys())
+    for ln in layer_name :
+        if 'conv' in ln or 'downsample.0.weight' in ln:
+            checkpoint[ln] = checkpoint[ln].unsqueeze(2)  
+    model.load_state_dict(checkpoint, strict=False)
+    del checkpoint
+    import gc
+    gc.collect()
+    return model
+
+
+def resnet34(**kwargs):
+    """Constructs a ResNet-34 model.
+    """
+    model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
+    return model
+
+def test():
+    net = resnet18()
+    y = net(torch.randn(1,3,224,224))
+    print(y.size())
+
+#test()

CorrNet_Plus/README.md

@@ -0,0 +1,310 @@
+# CorrNet+
+This repo holds codes of the paper: CorrNet+: Sign Language Recognition and Translation via Spatial-Temporal Correlation [[paper]](https://arxiv.org/abs/2404.11111), which is an extension of our previous work (CVPR 2023) [[paper]](https://arxiv.org/abs/2303.03202)
+
+For the code supporting continuous sign language recognition, refer to [CorrNet_Plus_CSLR](./CorrNet_Plus_CSLR) for the code.
+
+We currently reserve the code of CorrNet_Plus_SLT.
+
+## Performance
+- On the continuous sign language cognition task, CorrNet+ achieves superior performance on PHOENIX14, PHOENIX14-T, CSL-Daily and CSL datasets.
+
+<table align="center">
+<tbody align="center" valign="center">
+    <tr>
+        <td rowspan="3">Method</td>
+        <td colspan="4">PHOENIX2014</td>
+        <td colspan="2">PHOENIX2014-T</td>
+        <td colspan="2">CSL-Daily</td>
+    </tr>
+    <tr>
+        <td colspan="2">Dev(%)</td>
+        <td colspan="2">Test(%)</td>
+        <td rowspan="2">Dev(%)</td>
+        <td rowspan="2">Test(%)</td>
+        <td rowspan="2">Dev(%)</td>
+        <td rowspan="2">Test(%)</td>
+    </tr>
+    <tr>
+        <td>del/ins</td>
+        <td>WER</td>
+        <td>del/ins</td>
+        <td>WER</td>
+    </tr>
+    <tr>
+        <td>CVT-SLR (CVPR2023)</td>
+        <td>6.4/2.6</td>
+        <td>19.8</td>
+        <td>6.1/2.3</td>
+        <td>20.1</td>
+        <td>19.4</td>
+        <td>20.3</td>
+        <td>-</td>
+        <td>-</td>
+    </tr>
+    <tr>
+        <td>CoSign-2s (ICCV2023)</td>
+        <td>-</td>
+        <td>19.7</td>
+        <td>-</td>
+        <td>20.1</td>
+        <td>19.5</td>
+        <td>20.1</td>
+        <td>-</td>
+        <td>-</td>
+    </tr>
+    <tr>
+        <td>AdaSize (PR2024)</td>
+        <td>7.0/2.6</td>
+        <td>19.7</td>
+        <td>7.2/3.1</td>
+        <td>20.9</td>
+        <td>19.7</td>
+        <td>21.2</td>
+        <td>31.3</td>
+        <td>30.9</td>
+    </tr>
+    <tr>
+        <td>AdaBrowse+ (ACMMM2023)</td>
+        <td>6.0/2.5</td>
+        <td>19.6</td>
+        <td>5.9/2.6</td>
+        <td>20.7</td>
+        <td>19.5</td>
+        <td>20.6</td>
+        <td>31.2</td>
+        <td>30.7</td>
+    </tr>
+    <tr>
+        <td>SEN (AAAI2023)</td>
+        <td>5.8/2.6</td>
+        <td>19.5</td>
+        <td>7.3/4.0</td>
+        <td>21.0</td>
+        <td>19.3</td>
+        <td>20.7</td>
+        <td>31.1</td>
+        <td>30.7</td>
+    </tr>
+    <tr>
+        <td>CTCA (CVPR2023)</td>
+        <td>6.2/2.9</td>
+        <td>19.5</td>
+        <td>6.1/2.6</td>
+        <td>20.1</td>
+        <td>19.3</td>
+        <td>20.3</td>
+        <td>31.3</td>
+        <td>29.4</td>
+    </tr>
+    <tr>
+        <td>C2SLR (CVPR2022)</td>
+        <td>-</td>
+        <td>20.5</td>
+        <td>-</td>
+        <td>20.4</td>
+        <td>20.2</td>
+        <td>20.4</td>
+        <td>-</td>
+        <td>-</td>
+    </tr>
+    <tr>
+        <th>CorrNet+</th>
+        <td>5.3/2.7</td>
+        <th>18.0</th>
+        <td>5.6/2.4</td>
+        <th>18.2</th>
+        <th>17.2</th>
+        <th>19.1</th>
+        <th>28.6</th>
+        <th>28.2</th>
+    </tr>
+</tbody>
+</table>
+
+- On the sign language translation task, CorrNet+ achieves superior performance on PHOENIX14, PHOENIX14-T and CSL-Daily datasets.
+
+<table>
+<tbody align="center" valign="center">
+    <tr>
+        <td colspan="11">PHOENIX2014-T</td>
+    </tr>
+    <tr>
+        <td>Method</td>
+        <td colspan="5">Dev(%)</td>
+        <td colspan="5">Test(%)</td>
+    </tr>
+    <tr>
+        <td></td>
+        <td>Rouge</td>
+        <td>BLEU1</td>
+        <td>BLEU2</td>
+        <td>BLEU3</td>
+        <td>BLEU4</td>
+        <td>Rouge</td>
+        <td>BLEU1</td>
+        <td>BLEU2</td>
+        <td>BLEU3</td>
+        <td>BLEU4</td>
+    </tr>
+    <tr>
+        <td>SignBT (CVPR2021)</td>
+        <td>50.29</td>
+        <td>51.11</td>
+        <td>37.90</td>
+        <td>29.80</td>
+        <td>24.45</td>
+        <td>49.54</td>
+        <td>50.80</td>
+        <td>37.75</td>
+        <td>29.72</td>
+        <td>24.32</td>
+    </tr>
+    <tr>
+        <td>MMTLB (CVPR2022)</td>
+        <td>53.10</td>
+        <td>53.95</td>
+        <td>41.12</td>
+        <td>33.14</td>
+        <td>27.61</td>
+        <td>52.65</td>
+        <td>53.97</td>
+        <td>41.75</td>
+        <td>33.84</td>
+        <td>28.39</td>
+    </tr>
+    <tr>
+        <td>SLTUNET (ICLR2023)</td>
+        <td>52.23</td>
+        <td>-</td>
+        <td>-</td>
+        <td>-</td>
+        <td>27.87</td>
+        <td>52.11</td>
+        <td>52.92</td>
+        <td>41.76</td>
+        <td>33.99</td>
+        <td>28.47</td>
+    </tr>
+    <tr>
+        <td>TwoStream-SLT (NeuIPS2023)</td>
+        <td>54.08</td>
+        <td>54.32</td>
+        <td>41.99</td>
+        <td>34.15</td>
+        <td>28.66</td>
+        <td>53.48</td>
+        <td>54.90</td>
+        <td>42.43</td>
+        <td>34.46</td>
+        <td>28.95</td>
+    </tr>
+    <tr>
+        <td>CorrNet+</td>
+        <th>54.54</th>
+        <th>54.56</th>
+        <th>42.31</th>
+        <th>34.48</th>
+        <th>29.13</th>
+        <th>53.76</th>
+        <th>55.32</th>
+        <th>42.74</th>
+        <th>34.86</th>
+        <th>29.42</th>
+    </tr>
+    <tr>
+        <td colspan="11">CSL-Daily</td>
+    </tr>
+    <tr>
+        <td>Method</td>
+        <td colspan="5">Dev(%)</td>
+        <td colspan="5">Test(%)</td>
+    </tr>
+    <tr>
+        <td></td>
+        <td>Rouge</td>
+        <td>BLEU1</td>
+        <td>BLEU2</td>
+        <td>BLEU3</td>
+        <td>BLEU4</td>
+        <td>Rouge</td>
+        <td>BLEU1</td>
+        <td>BLEU2</td>
+        <td>BLEU3</td>
+        <td>BLEU4</td>
+    </tr>
+    <tr>
+        <td>SignBT (CVPR2021)</td>
+        <td>49.49</td>
+        <td>51.46</td>
+        <td>37.23</td>
+        <td>27.51</td>
+        <td>20.80</td>
+        <td>49.31</td>
+        <td>51.42</td>
+        <td>37.26</td>
+        <td>27.76</td>
+        <td>21.34</td>
+    </tr>
+    <tr>
+        <td>MMTLB (CVPR2022)</td>
+        <td>53.38</td>
+        <td>53.81</td>
+        <td>40.84</td>
+        <td>31.29</td>
+        <td>24.42</td>
+        <td>53.25</td>
+        <td>53.31</td>
+        <td>40.41</td>
+        <td>30.87</td>
+        <td>23.92</td>
+    </tr>
+    <tr>
+        <td>SLTUNET (ICLR2023)</td>
+        <td>53.58</td>
+        <td>-</td>
+        <td>-</td>
+        <td>-</td>
+        <td>23.99</td>
+        <td>54.08</td>
+        <td>54.98</td>
+        <td>41.44</td>
+        <td>31.84</td>
+        <td>25.01</td>
+    </tr>
+    <tr>
+        <td>TwoStream-SLT (NeuIPS2023)</td>
+        <td>55.10</td>
+        <td>55.21</td>
+        <td>42.31</td>
+        <td>32.71</td>
+        <td>25.76</td>
+        <td>55.72</td>
+        <td>55.44</td>
+        <td>42.59</td>
+        <td>32.87</td>
+        <td>25.79</td>
+    </tr>
+    <tr>
+        <td>CorrNet+</td>
+        <th>55.52</th>
+        <th>55.64</th>
+        <th>42.78</th>
+        <th>33.13</th>
+        <th>26.14</th>
+        <th>55.84</th>
+        <th>55.82</th>
+        <th>42.96</th>
+        <th>33.26</th>
+        <th>26.14</th>
+    </tr>
+</tbody>
+</table>
+
+## Visualizations
+
+As shown below, our method intelligently models the human body trajectories across adjacent frames and pays special attention to the moving human body parts.
+
+![The visualizations of spatial-temporal correlation maps](./figure6.jpg "Heatmaps of human body trajectories")
+
+## Data preparation, Environment, Training, Inference and Visualizations
+For detailed instructions of data preparation, environment, training, inference and visualizations, please refer to each sub-repo for guidance.

slt_new/README.md

@@ -0,0 +1,162 @@
+# CorrNet+_CSLR
+This repo holds codes of the paper: CorrNet+: Sign Language Recognition and Translation via Spatial-Temporal Correlation, which is an extension of our previous work (CVPR 2023) [[paper]](https://arxiv.org/abs/2303.03202)
+
+This sub-repo holds the code for supporting the continuous sign language recognition task with CorrNet+.
+
+(**Update on 2025/01/28**) We release a demo for Continuous sign language recognition that supports multi-images and video inputs! You can watch the demo video to watch its effects, or deploy a demo locally to test its performance. 
+
+https://github.com/user-attachments/assets/a7354510-e5e0-44af-b283-39707f625a9b
+
+<div align=center>
+The web demo video
+</div>
+
+## Prerequisites
+
+- This project is implemented in Pytorch (better >=1.13 to be compatible with ctcdecode or these may exist errors). Thus please install Pytorch first.
+
+- ctcdecode==0.4 [[parlance/ctcdecode]](https://github.com/parlance/ctcdecode)，for beam search decode.
+
+- [Optional] sclite [[kaldi-asr/kaldi]](https://github.com/kaldi-asr/kaldi), install kaldi tool to get sclite for evaluation. After installation, create a soft link toward the sclite: 
+  `mkdir ./software`
+  `ln -s PATH_TO_KALDI/tools/sctk-2.4.10/bin/sclite ./software/sclite`
+
+   You may use the python version evaluation tool for convenience (by setting 'evaluate_tool' as 'python' in line 16 of ./configs/baseline.yaml), but sclite can provide more detailed statistics.
+
+- You can install other required modules by conducting 
+   `pip install -r requirements.txt`
+
+## Implementation
+The implementation for the CorrNet+ is given in [./modules/resnet.py](https://github.com/hulianyuyy/CorrNet_Plus/CorrNet_Plus_CSLR/modules/resnet.py).  
+
+It's then equipped with after each stage in ResNet in line 195 [./modules/resnet.py](https://github.com/hulianyuyy/CorrNet_Plus/CorrNet_Plus_CSLR/modules/resnet.py).
+
+We later found that the Identification Module with only spatial decomposition could perform on par with what we report in the paper (spatial-temporal decomposition) and is slighter faster, and thus implement it as such.
+
+## Data Preparation
+You can choose any one of following datasets to verify the effectiveness of CorrNet+.
+
+### PHOENIX2014 dataset
+1. Download the RWTH-PHOENIX-Weather 2014 Dataset [[download link]](https://www-i6.informatik.rwth-aachen.de/~koller/RWTH-PHOENIX/). Our experiments based on phoenix-2014.v3.tar.gz.
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET/phoenix2014-release ./dataset/phoenix2014`
+
+3. The original image sequence is 210x260, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess.py --process-image --multiprocessing
+   ```
+
+### PHOENIX2014-T dataset
+1. Download the RWTH-PHOENIX-Weather 2014 Dataset [[download link]](https://www-i6.informatik.rwth-aachen.de/~koller/RWTH-PHOENIX-2014-T/)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET/PHOENIX-2014-T-release-v3/PHOENIX-2014-T ./dataset/phoenix2014-T`
+
+3. The original image sequence is 210x260, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-T.py --process-image --multiprocessing
+   ```
+
+if you get an error like ```IndexError: list index out of range``` on the PHOENIX2014-T dataset, you may refer to [this issue](https://github.com/hulianyuyy/CorrNet/issues/10#issuecomment-1660363025) to tackle the problem.
+### CSL dataset
+
+1. Request the CSL Dataset from this website [[download link]](https://ustc-slr.github.io/openresources/cslr-dataset-2015/index.html)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET ./dataset/CSL`
+
+3. The original image sequence is 1280x720, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-CSL.py --process-image --multiprocessing
+   ``` 
+
+### CSL-Daily dataset
+
+1. Request the CSL-Daily Dataset from this website [[download link]](http://home.ustc.edu.cn/~zhouh156/dataset/csl-daily/)
+
+2. After finishing dataset download, extract it. It is suggested to make a soft link toward downloaded dataset.   
+   `ln -s PATH_TO_DATASET ./dataset/CSL-Daily`
+
+3. The original image sequence is 1280x720, we resize it to 256x256 for augmentation. Run the following command to generate gloss dict and resize image sequence.     
+
+   ```bash
+   cd ./preprocess
+   python dataset_preprocess-CSL-Daily.py --process-image --multiprocessing
+   ``` 
+
+## Inference
+
+### PHOENIX2014 dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                             |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 18.0%      | 18.2%       | [[Baidu]](https://pan.baidu.com/s/1vlCMSuqZiZkvidg4wrDlZQ?pwd=w5w9) <br />[[Google Drive]](https://drive.google.com/file/d/1jcRv4Gl98mvS4mmLH5dBU_-iN3qGq8Si/view?usp=sharing) |
+
+
+### PHOENIX2014-T dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                             |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 17.2%      | 19.1%       | [[Baidu]](https://pan.baidu.com/s/1PcQtWOhiTEq9RFgBZ2hWhQ?pwd=nm3c) <br />[[Google Drive]](https://drive.google.com/file/d/1uBaKoB2JaB3ydYXmpn1tv0mBZ7cAF8J9/view?usp=sharing) |
+
+### CSL-Daily dataset
+
+| Backbone | Dev WER  | Test WER  | Pretrained model                                            |
+| -------- | ---------- | ----------- | --- |
+| ResNet18 | 28.6%      | 28.2%       | [[Baidu]](https://pan.baidu.com/s/1SbulBImqn78FEYFZV5Oz1w?pwd=mx8m) <br />[[Google Drive]](https://drive.google.com/file/d/1Ve_uzEB1teTmebuQ1XAMFQ0UV0EVEGyM/view?usp=sharing) |
+
+
+​	To evaluate the pretrained model, choose the dataset from phoenix2014/phoenix2014-T/CSL/CSL-Daily in line 3 in ./config/baseline.yaml first, and run the command below：   
+`python main.py --config ./config/baseline.yaml --device your_device --load-weights path_to_weight.pt --phase test`
+
+## Training
+
+The priorities of configuration files are: command line > config file > default values of argparse. To train the SLR model, run the command below:
+
+`python main.py --config ./config/baseline.yaml --device your_device`
+
+Note that you can choose the target dataset from phoenix2014/phoenix2014-T/CSL/CSL-Daily in line 3 in ./config/baseline.yaml.
+
+## Visualizations
+For Grad-CAM visualization of spatial weight maps, you can replace the resnet.py under "./modules" with the resnet.py under "./weight_map_generation", and then run ```python generate_weight_map.py``` with your own hyperparameters. 
+
+For Grad-CAM visualization of correlation maps, you can replace the resnet.py under "./modules" with the resnet.py under "./corr_map_generation", and then run ```python generate_corr_map.py``` with your own hyperparameters.
+
+### Test with one video input
+Except performing inference on datasets, we provide a `test_one_video.py` to perform inference with only one video input. An example command is 
+
+`python test_one_video.py --model_path /path_to_pretrained_weights --video_path /path_to_your_video --device your_device`
+
+The `video_path` can be the path to a video file or a dir contains extracted images from a video.
+
+Acceptable paramters:
+- `model_path`, the path to pretrained weights.
+- `video_path`, the path to a video file or a dir contains extracted images from a video.
+- `device`, which device to run inference, default=0.
+- `language`, the target sign language, default='phoenix', choices=['phoenix', 'csl'].
+- `max_frames_num`, the max input frames sampled from an input video, default=360.
+
+### Demo
+We provide a demo to allow deploying continuous sign language recognition models locally to test its effects. The demo page is shown as follows.
+<div align=center>
+<img width="800" src="./demo.jpg"/>
+<h4> The page of our demo</h4>
+</div>
+The demo video can be found in the top of this page. An example command is 
+
+`python demo.py --model_path /path_to_pretrained_weights --device your_device`
+
+Acceptable paramters:
+- `model_path`, the path to pretrained weights.
+- `device`, which device to run inference, default=0.
+- `language`, the target sign language, default='phoenix', choices=['phoenix', 'csl'].
+- `max_frames_num`, the max input frames sampled from an input video, default=360.
+
+After running the command, you can visit `http://0.0.0.0:7862` to play with the demo. You can also change it into an public URL by setting `share=True` in line 176 in `demo.py`.

slt_new/comparison_checklist.md

@@ -0,0 +1,144 @@
+# CorrNet+ 与 ASLLRP 实现对比检查清单
+
+## 1. 数据集格式对比 ✓
+
+### Phoenix2014 数据集
+- 样本数量：Train: 5672, Dev: 540, Test: 629
+- 每个样本：一个完整视频对应一个gloss序列
+- 平均序列长度：较长（具体数值未提供）
+- 帧率：25fps
+- 分辨率：224x224
+
+### ASLLRP 数据集
+- 样本数量：Train: 1073, Dev: 136, Test: 134
+- 每个样本：一个完整视频对应一个gloss序列
+- 平均序列长度：8个glosses，平均110帧/视频
+- 帧率：24fps
+- 分辨率：原始256x256，调整为224x224
+- Gloss词汇量：1244个唯一glosses
+
+## 2. 数据预处理对比 ✓
+
+### 视频预处理
+- **原版 Phoenix2014**：
+  - 使用CenterCrop裁剪到224x224
+  - 不使用RandomCrop或RandomHorizontalFlip
+  - TemporalRescale: min=32, max=230帧
+
+- **我们的 ASLLRP**：
+  - 使用CenterCrop裁剪到224x224（与原版一致）
+  - 不使用RandomCrop或RandomHorizontalFlip（与原版一致）
+  - TemporalRescale: min=32, max=230帧（与原版一致）
+  - **问题**：ASLLRP有视频短至26帧，低于min=32的限制
+
+### Gloss预处理
+- 两者都将gloss文本转换为ID序列
+- 都使用相同的词汇表处理方式
+- 都添加blank token用于CTC
+
+## 3. 模型架构对比
+
+### Temporal Convolution 配置
+- **原版 CorrNet+**: `conv_type=2` -> ['K5', 'P2', 'K5', 'P2']
+  - 第一个K5卷积：输入长度减少4 (kernel_size-1)
+  - 第一个P2池化：长度减半
+  - 第二个K5卷积：长度再减少4
+  - 第二个P2池化：长度再减半
+  - **总下采样率**: 约4倍 (对于100帧输入，输出约23帧)
+
+- **我们的实现**: 使用相同的`conv_type=1` -> ['K5', 'P2']
+  - K5卷积：长度减少4
+  - P2池化：长度减半
+  - **总下采样率**: 约2倍 (对于100帧输入，输出约48帧)
+
+### Temporal_LiftPool 差异
+- **原版**:
+  ```python
+  Xe = x[:,:,:T:self.kernel_size]  # 从0开始每隔kernel_size取样
+  Xo = x[:,:,1:T:self.kernel_size]  # 从1开始每隔kernel_size取样
+  s = torch.cat((x[:,:,:0:self.kernel_size], s, x[:,:,T::self.kernel_size]),2)
+  ```
+  - 返回拼接后的序列，保持了时间维度的某些信息
+
+- **我们的修复版**:
+  ```python
+  Xe = x[:,:,::self.kernel_size]      # 从0开始每隔kernel_size取样
+  Xo = x[:,:,self.kernel_size-1::self.kernel_size]  # 从kernel_size-1开始
+  # 修剪到相同长度后直接返回加权结果
+  ```
+  - 只返回下采样后的结果，时间维度严格减半
+
+### ResNet配置
+- **原版**: 使用`AvgPool2d(7, stride=1)`，需要224x224输入
+- **我们的实现**: 已修正为相同配置
+
+### BiLSTM配置
+- 两者相同：2层双向LSTM，hidden_size=1024
+
+## 4. 训练配置对比
+
+### 优化器和学习率
+- **原版 Phoenix2014**:
+  - 初始学习率: 0.0001
+  - 学习率调度: StepLR，在epoch 40和60时乘以0.2
+  - 批量大小: 2
+  - 使用autocast和GradScaler进行混合精度训练
+
+- **我们的 ASLLRP**:
+  - 初始学习率: 0.0001 (相同)
+  - 学习率调度: StepLR，在epoch 40和60时乘以0.2 (相同)
+  - 批量大小: 2 (相同)
+  - **禁用了autocast和GradScaler** (为了调试CTC loss问题)
+
+### 损失权重
+- 两者相同:
+  ```python
+  'ConvCTC': 1.0,
+  'SeqCTC': 1.0,
+  'Dist': 5.0,
+  'Cu': 0.0005,
+  'Cp': 0.0005
+  ```
+
+## 5. 解码器对比
+
+### Beam Search配置
+- 两者都使用相同的beam search解码器
+- Beam width: 默认值（通常是10）
+- 使用相同的解码函数
+
+## 6. 评估方式对比
+
+- 两者使用相同的WER计算方法
+- 都使用CTM格式输出
+- 评估脚本相同
+
+## 7. 关键差异分析
+
+### 可能导致只预测单词的原因：
+
+1. **时间下采样不足**:
+   - 我们使用`conv_type=1`，下采样率只有2倍
+   - 原版使用`conv_type=2`，下采样率4倍
+   - ASLLRP的短视频（26-110帧）可能需要更激进的下采样
+
+2. **Temporal_LiftPool实现差异**:
+   - 原版返回拼接序列，保留了更多时间信息
+   - 我们的版本直接返回下采样结果
+   - 这可能影响了时间建模能力
+
+3. **数据集特性差异**:
+   - Phoenix2014: 平均150帧，较长序列
+   - ASLLRP: 平均110帧，但有很短的视频（26帧）
+   - TemporalRescale的min=32限制可能导致短视频被强制拉长
+
+4. **混合精度训练**:
+   - 原版使用autocast和GradScaler
+   - 我们禁用了它们，可能影响训练动态
+
+### 建议修复方向：
+
+1. **修改conv_type为2**：使用更激进的时间下采样
+2. **恢复原版Temporal_LiftPool**：保持时间信息的完整性
+3. **调整TemporalRescale参数**：降低min值以适应短视频
+4. **恢复混合精度训练**：在解决CTC loss问题后重新启用

slt_new/demo.py

@@ -0,0 +1,176 @@
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+from PIL import Image
+import argparse
+
+import numpy as np
+VIDEO_FORMATS = [".mp4", ".avi", ".mov", ".mkv"]
+os.environ['GRADIO_TEMP_DIR'] = 'gradio_temp'
+import gradio as gr
+import os
+import warnings
+from decord import VideoReader, cpu
+warnings.filterwarnings("ignore")
+
+def is_image_by_extension(file_path):
+    _, file_extension = os.path.splitext(file_path)
+
+    image_extensions = ['.jpg', '.jpeg', '.png', '.gif', '.bmp']
+
+    return file_extension.lower() in image_extensions
+
+def load_video(video_path, max_frames_num=360):
+    if type(video_path) == str:
+        vr = VideoReader(video_path, ctx=cpu(0))
+    elif type(video_path) == list:
+        vr = VideoReader(video_path[0], ctx=cpu(0))
+    else:
+        raise ValueError(f"Not support video input : {type(video_path)}")
+    total_frame_num = len(vr)
+    if total_frame_num> max_frames_num:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, max_frames_num, dtype=int)
+    else:
+        uniform_sampled_frames = np.linspace(0, total_frame_num - 1, dtype=int)
+    frame_idx = uniform_sampled_frames.tolist()
+    spare_frames = vr.get_batch(frame_idx).asnumpy()
+    return [cv2.cvtColor(tmp, cv2.COLOR_BGR2RGB) for tmp in spare_frames]  # (frames, height, width, channels)
+
+def run_inference(inputs):
+    """
+    Run inference on one input sample.
+
+    Args:
+        args: Command-line arguments.
+    """
+    img_list = []
+    if isinstance(inputs, list):  # Multi-image case
+        for x in inputs:
+            if is_image_by_extension(x):
+                img_list.append(cv2.cvtColor(cv2.imread(x), cv2.COLOR_BGR2RGB) )
+
+    elif os.path.splitext(inputs)[-1] in VIDEO_FORMATS: # Video case
+        try:
+            img_list = load_video(inputs, args.max_frames_num)  # frames [height, width, channels]
+        except Exception as e:
+            raise ValueError(f"Error {e} in loading video")
+    else:
+        raise ValueError("Video path is incorrect!")
+
+    transform = video_augmentation.Compose([
+                    video_augmentation.CenterCrop(224),
+                    video_augmentation.Resize(1.0),
+                    video_augmentation.ToTensor(),
+                ])
+    vid, label = transform(img_list, None, None)
+    vid = vid.float() / 127.5 - 1
+    vid = vid.unsqueeze(0)
+
+    left_pad = 0
+    last_stride = 1
+    total_stride = 1
+    kernel_sizes = ['K5', "P2", 'K5', "P2"]
+    for layer_idx, ks in enumerate(kernel_sizes):
+        if ks[0] == 'K':
+            left_pad = left_pad * last_stride 
+            left_pad += int((int(ks[1])-1)/2)
+        elif ks[0] == 'P':
+            last_stride = int(ks[1])
+            total_stride = total_stride * last_stride
+
+    max_len = vid.size(1)
+    video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+    right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+    max_len = max_len + left_pad + right_pad
+    vid = torch.cat(
+        (
+            vid[0,0][None].expand(left_pad, -1, -1, -1),
+            vid[0],
+            vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+        )
+        , dim=0).unsqueeze(0)
+
+    vid = device.data_to_device(vid)
+    vid_lgt = device.data_to_device(video_length)
+    ret_dict = model(vid, vid_lgt, label=None, label_lgt=None)
+    return ret_dict['recognized_sents'] # [[('ICH', 0), ('LUFT', 1), ('WETTER', 2), ('GERADE', 3), ('loc-SUEDWEST', 4), ('TEMPERATUR', 5), ('__PU__', 6), ('KUEHL', 7), ('SUED', 8), ('WARM', 9), ('ICH', 10), ('IX', 11)]]
+
+
+def parse_args():
+    """
+    Parse command-line arguments.
+    """
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_path", type=str, help="The path to pretrained weights")
+    parser.add_argument("--device", type=int, default=0)
+    parser.add_argument("--language", type=str, default='phoenix', choices=['phoenix', 'csl'])
+    parser.add_argument("--max_frames_num", type=int, default=360)
+    
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # Load tokenizer, model and image processor
+    model_path = os.path.expanduser(args.model_path)
+    
+    device_id = args.device  # specify which gpu to use
+    if args.language == 'phoenix':
+        dataset = 'phoenix2014' 
+    elif args.language == 'csl':
+        dataset = 'CSL-Daily' 
+    else:
+        raise ValueError("Please select target language from ['phoenix', 'csl'] in your command")
+
+    model_weights = args.model_path
+
+    # Load data and apply transformation
+    dict_path = f'./preprocess/{dataset}/gloss_dict.npy'  # Use the gloss dict of phoenix14 dataset 
+    gloss_dict = np.load(dict_path, allow_pickle=True).item()
+
+    device = utils.GpuDataParallel()
+    device.set_device(device_id)
+    # Define model and load state-dict
+    model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+                loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+    state_dict = torch.load(model_weights)['model_state_dict']
+    state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+    model.load_state_dict(state_dict, strict=True)
+    model = model.to(device.output_device)
+    model.cuda()
+
+    model.eval()
+
+    def identity(x):
+        return x
+
+    with gr.Blocks(title='Continuous sign language recognition') as demo: 
+        gr.Markdown("<center><font size=5>Continuous sign language recognition</center></font>")
+        gr.Markdown("**Upload multiple images or a video** to get the recognized glossess.")
+        with gr.Tab('Multi-Images'):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    multiple_image_show = gr.Gallery(label="Show the input images", height=200)
+                    Multi_image_input = gr.UploadButton(label="Click to upload multiple images", file_types = ['.png','.jpg','.jpeg', '.bmp'], file_count = "multiple")
+                    multiple_image_button = gr.Button("Run")  
+                with gr.Column(scale=1):
+                    multiple_image_output = gr.Textbox(label="Output")
+        with gr.Tab('Video'):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    Video_input = gr.Video(sources=["upload"], label="Upload a video file")
+                    video_button = gr.Button("Run")  
+                with gr.Column(scale=1):
+                    video_output = gr.Textbox(label="Output")
+        multiple_image_button.click(identity, inputs=[Multi_image_input], outputs=multiple_image_show)
+        multiple_image_button.click(run_inference, inputs=Multi_image_input, outputs=multiple_image_output)
+        video_button.click(run_inference, inputs=Video_input, outputs=video_output)
+        
+    demo.launch(share=False,server_name="0.0.0.0", server_port=7862)

slt_new/generate_corr_map.py

@@ -0,0 +1,88 @@
+#Ref: https://blog.csdn.net/weixin_41735859/article/details/106474768
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+
+gpu_id = 0 # The GPU to use
+dataset = 'phoenix2014' # support [phoenix2014, phoenix2014-T, CSL-Daily]
+prefix = './dataset/phoenix2014/phoenix-2014-multisigner' # ['./dataset/CSL-Daily', './dataset/phoenix2014-T', './dataset/phoenix2014/phoenix-2014-multisigner']
+dict_path = f'./preprocess/{dataset}/gloss_dict.npy'
+model_weights = 'path_to_model.pt'
+select_id = 539 # The video selected to show. 539 for 31October_2009_Saturday_tagesschau_default-8, 0 for 01April_2010_Thursday_heute_default-1, 1 for 01August_2011_Monday_heute_default-6, 2 for 01December_2011_Thursday_heute_default-3
+#name = '01April_2010_Thursday_heute_default-1'
+
+# Load data and apply transformation
+gloss_dict = np.load(dict_path, allow_pickle=True).item()
+inputs_list = np.load(f"./preprocess/{dataset}/dev_info.npy", allow_pickle=True).item()
+name = inputs_list[select_id]['fileid']
+print(f'Generating correlation maps for {name}')
+img_folder = os.path.join(prefix, "features/fullFrame-256x256px/" + inputs_list[select_id]['folder']) if 'phoenix' in dataset else os.path.join(prefix, inputs_list[select_id]['folder'])
+img_list = sorted(glob.glob(img_folder))
+img_list = [cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB) for img_path in img_list]
+label_list = []
+for phase in inputs_list[select_id]['label'].split(" "):
+    if phase == '':
+        continue
+    if phase in gloss_dict.keys():
+        label_list.append(gloss_dict[phase][0])
+transform = video_augmentation.Compose([
+                video_augmentation.CenterCrop(224),
+                video_augmentation.Resize(1.0),
+                video_augmentation.ToTensor(),
+            ])
+vid, label = transform(img_list, label_list, None)
+vid = vid.float() / 127.5 - 1
+vid = vid.unsqueeze(0)
+
+left_pad = 0
+last_stride = 1
+total_stride = 1
+kernel_sizes = ['K5', "P2", 'K5', "P2"]
+for layer_idx, ks in enumerate(kernel_sizes):
+    if ks[0] == 'K':
+        left_pad = left_pad * last_stride 
+        left_pad += int((int(ks[1])-1)/2)
+    elif ks[0] == 'P':
+        last_stride = int(ks[1])
+        total_stride = total_stride * last_stride
+
+max_len = vid.size(1)
+video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+max_len = max_len + left_pad + right_pad
+vid = torch.cat(
+    (
+        vid[0,0][None].expand(left_pad, -1, -1, -1),
+        vid[0],
+        vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+    )
+    , dim=0).unsqueeze(0)
+
+fmap_block = list()
+#grad_block = list()
+
+device = utils.GpuDataParallel()
+device.set_device(gpu_id)
+# Define model and load state-dict
+model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+            loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+state_dict = torch.load(model_weights)['model_state_dict']
+state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+model.load_state_dict(state_dict, strict=True)
+model = model.to(device.output_device)
+model.cuda()
+
+model.eval()
+
+print(vid.shape)
+vid = device.data_to_device(vid)
+vid_lgt = device.data_to_device(video_length)
+label = device.data_to_device([torch.LongTensor(label)])
+label_lgt = device.data_to_device(torch.LongTensor([len(label_list)]))
+ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt, dataset=dataset)

slt_new/generate_weight_map.py

@@ -0,0 +1,136 @@
+#Ref: https://blog.csdn.net/weixin_41735859/article/details/106474768
+import numpy as np
+import os
+import glob
+import cv2
+from utils import video_augmentation
+from slr_network import SLRModel
+import torch
+from collections import OrderedDict
+import utils
+
+gpu_id = 0 # The GPU to use
+dataset = 'phoenix2014'  # support [phoenix2014, phoenix2014-T, CSL-Daily]
+prefix = './dataset/phoenix2014/phoenix-2014-multisigner'  # ['./dataset/CSL-Daily', './dataset/phoenix2014-T', './dataset/phoenix2014/phoenix-2014-multisigner']
+dict_path = f'./preprocess/{dataset}/gloss_dict.npy'
+model_weights = 'path_to_model.pt'
+select_id = 2 # The video selected to show. 539 for 31October_2009_Saturday_tagesschau_default-8, 0 for 01April_2010_Thursday_heute_default-1, 1 for 01August_2011_Monday_heute_default-6, 2 for 01December_2011_Thursday_heute_default-3
+#name = '01April_2010_Thursday_heute_default-1'
+
+# Load data and apply transformation
+gloss_dict = np.load(dict_path, allow_pickle=True).item()
+inputs_list = np.load(f"./preprocess/{dataset}/dev_info.npy", allow_pickle=True).item()
+name = inputs_list[select_id]['fileid']
+print(f'Generating CAM for {name}')
+img_folder = os.path.join(prefix, "features/fullFrame-256x256px/" + inputs_list[select_id]['folder']) if 'phoenix' in dataset else os.path.join(prefix, inputs_list[select_id]['folder'])
+img_list = sorted(glob.glob(img_folder))
+img_list = [cv2.cvtColor(cv2.imread(img_path), cv2.COLOR_BGR2RGB) for img_path in img_list]
+label_list = []
+for phase in inputs_list[select_id]['label'].split(" "):
+    if phase == '':
+        continue
+    if phase in gloss_dict.keys():
+        label_list.append(gloss_dict[phase][0])
+transform = video_augmentation.Compose([
+                video_augmentation.CenterCrop(224),
+                video_augmentation.Resize(1.0),
+                video_augmentation.ToTensor(),
+            ])
+vid, label = transform(img_list, label_list, None)
+vid = vid.float() / 127.5 - 1
+vid = vid.unsqueeze(0)
+
+left_pad = 0
+last_stride = 1
+total_stride = 1
+kernel_sizes = ['K5', "P2", 'K5', "P2"]
+for layer_idx, ks in enumerate(kernel_sizes):
+    if ks[0] == 'K':
+        left_pad = left_pad * last_stride 
+        left_pad += int((int(ks[1])-1)/2)
+    elif ks[0] == 'P':
+        last_stride = int(ks[1])
+        total_stride = total_stride * last_stride
+
+max_len = vid.size(1)
+video_length = torch.LongTensor([np.ceil(vid.size(1) / total_stride) * total_stride + 2*left_pad ])
+right_pad = int(np.ceil(max_len / total_stride)) * total_stride - max_len + left_pad
+max_len = max_len + left_pad + right_pad
+vid = torch.cat(
+    (
+        vid[0,0][None].expand(left_pad, -1, -1, -1),
+        vid[0],
+        vid[0,-1][None].expand(max_len - vid.size(1) - left_pad, -1, -1, -1),
+    )
+    , dim=0).unsqueeze(0)
+
+fmap_block = list()
+
+device = utils.GpuDataParallel()
+device.set_device(gpu_id)
+# Define model and load state-dict
+model = SLRModel( num_classes=len(gloss_dict)+1, c2d_type='resnet18', conv_type=2, use_bn=1, gloss_dict=gloss_dict,
+            loss_weights={'ConvCTC': 1.0, 'SeqCTC': 1.0, 'Dist': 25.0},   )
+state_dict = torch.load(model_weights)['model_state_dict']
+state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+model.load_state_dict(state_dict, strict=True)
+model = model.to(device.output_device)
+model.cuda()
+
+model.train()
+
+def forward_hook(module, input, output):
+    fmap_block.append(output)       #N, C, T, H, ,W 
+if 'phoenix' in dataset:
+    model.conv2d.corr2.conv_back.register_forward_hook(forward_hook)	
+else:
+    model.conv2d.corr3.conv_back.register_forward_hook(forward_hook)  # For CSL-Daily
+#model.conv2d.layer4[-1].conv1.register_backward_hook(backward_hook)
+
+def cam_show_img(img, feature_map, grads, out_dir):  # img: ntchw, feature_map: ncthw, grads: ncthw
+    N, C, T, H, W = feature_map.shape
+    cam = np.zeros(feature_map.shape[2:], dtype=np.float32)	# thw
+    grads = grads[0,:].reshape([C, T, -1])					
+    weights = np.mean(grads, axis=-1)	
+    for i in range(C):						
+        for j in range(T):
+            cam[j] += weights[i,j] * feature_map[0, i, j, :, :]		
+    cam = np.maximum(cam, 0)					
+
+    if not os.path.exists(out_dir):
+        os.makedirs(out_dir)
+    else:
+        import shutil
+        shutil.rmtree(out_dir)
+        os.makedirs(out_dir)
+    for i in range(T):
+        out_cam = cam[i]
+        out_cam = out_cam - np.min(out_cam)
+        out_cam = out_cam / (1e-7 + out_cam.max())
+        out_cam = cv2.resize(out_cam, (img.shape[3], img.shape[4]))
+        out_cam = (255 * out_cam).astype(np.uint8)
+        heatmap = cv2.applyColorMap(out_cam, cv2.COLORMAP_JET)
+        cam_img = np.float32(heatmap) / 255 + (img[0,i]/2+0.5).permute(1,2,0).cpu().data.numpy()
+        cam_img = cam_img/np.max(cam_img)
+        cam_img = np.uint8(255 * cam_img)
+        path_cam_img = os.path.join(out_dir, f"cam_{i}.jpg")
+        cv2.imwrite(path_cam_img, cam_img)
+    print('Generate cam.jpg')
+
+print(vid.shape)
+vid = device.data_to_device(vid)
+vid_lgt = device.data_to_device(video_length)
+label = device.data_to_device([torch.LongTensor(label)])
+label_lgt = device.data_to_device(torch.LongTensor([len(label_list)]))
+ret_dict = model(vid, vid_lgt, label=label, label_lgt=label_lgt)
+
+model.zero_grad()
+for i in range(ret_dict['sequence_logits'].size(0)):
+    idx = np.argmax(ret_dict['sequence_logits'].cpu().data.numpy()[i,0])  #TBC
+    class_loss = ret_dict['sequence_logits'][i, 0, idx]
+    class_loss.backward(retain_graph=True)
+# 生成cam
+grads_val = torch.load('./weight_map.pth').cpu().data.numpy()
+fmap = fmap_block[0].cpu().data.numpy()
+# 保存cam图片
+cam_show_img(vid, fmap, grads_val, out_dir='./agg_map')

slt_new/main.py

@@ -0,0 +1,329 @@
+import os
+
+os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+import pdb
+import sys
+import cv2
+import yaml
+import torch
+import random
+import importlib
+import faulthandler
+import numpy as np
+import torch.nn as nn
+import shutil
+import inspect
+import time
+from collections import OrderedDict
+
+faulthandler.enable()
+import utils
+from modules.sync_batchnorm import convert_model
+from seq_scripts import seq_train, seq_eval, seq_feature_generation
+from torch.cuda.amp import autocast as autocast
+
+class Processor():
+    def __init__(self, arg):
+        self.arg = arg
+        if os.path.exists(self.arg.work_dir):
+            # Auto-remove for non-interactive mode
+            print(f'Work dir {self.arg.work_dir} exists, removing...')
+            shutil.rmtree(self.arg.work_dir)
+            os.makedirs(self.arg.work_dir)
+        else:
+            os.makedirs(self.arg.work_dir)
+        shutil.copy2(__file__, self.arg.work_dir)
+        shutil.copy2('./configs/baseline.yaml', self.arg.work_dir)
+        shutil.copy2('./modules/tconv.py', self.arg.work_dir)
+        shutil.copy2('./modules/resnet.py', self.arg.work_dir)
+        self.recoder = utils.Recorder(self.arg.work_dir, self.arg.print_log, self.arg.log_interval)
+        self.save_arg()
+        if self.arg.random_fix:
+            self.rng = utils.RandomState(seed=self.arg.random_seed)
+        self.device = utils.GpuDataParallel()
+        self.recoder = utils.Recorder(self.arg.work_dir, self.arg.print_log, self.arg.log_interval)
+        self.dataset = {}
+        self.data_loader = {}
+        self.gloss_dict = np.load(self.arg.dataset_info['dict_path'], allow_pickle=True).item()
+        # Check if gloss_dict contains blank token
+        has_blank = any('blank' in str(k).lower() for k in self.gloss_dict.keys())
+        # If blank is not in dict, add 1 for blank token (like Phoenix2014)
+        # If blank is in dict, use dict length as is (like ASLLRP)
+        self.arg.model_args['num_classes'] = len(self.gloss_dict) if has_blank else len(self.gloss_dict) + 1
+        self.model, self.optimizer = self.loading()
+
+    def start(self):
+        if self.arg.phase == 'train':
+            best_dev = 100.0
+            best_epoch = 0
+            total_time = 0
+            epoch_time = 0
+            self.recoder.print_log('Parameters:\n{}\n'.format(str(vars(self.arg))))
+            seq_model_list = []
+            for epoch in range(self.arg.optimizer_args['start_epoch'], self.arg.num_epoch):
+                save_model = epoch % self.arg.save_interval == 0
+                eval_model = epoch % self.arg.eval_interval == 0
+                epoch_time = time.time()
+                # train end2end model
+                seq_train(self.data_loader['train'], self.model, self.optimizer,
+                          self.device, epoch, self.recoder)
+                if eval_model:
+                    dev_wer = seq_eval(self.arg, self.data_loader['dev'], self.model, self.device,
+                                       'dev', epoch, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+                    self.recoder.print_log("Dev WER: {:05.2f}%".format(dev_wer))
+                if dev_wer < best_dev:
+                    best_dev = dev_wer
+                    best_epoch = epoch
+                    model_path = "{}_best_model.pt".format(self.arg.work_dir)
+                    self.save_model(epoch, model_path)
+                    self.recoder.print_log('Save best model')
+                self.recoder.print_log('Best_dev: {:05.2f}, Epoch : {}'.format(best_dev, best_epoch))
+                if save_model:
+                    model_path = "{}dev_{:05.2f}_epoch{}_model.pt".format(self.arg.work_dir, dev_wer, epoch)
+                    seq_model_list.append(model_path)
+                    print("seq_model_list", seq_model_list)
+                    self.save_model(epoch, model_path)
+                epoch_time = time.time() - epoch_time
+                total_time += epoch_time
+                torch.cuda.empty_cache()
+                self.recoder.print_log('Epoch {} costs {} mins {} seconds'.format(epoch, int(epoch_time)//60, int(epoch_time)%60))
+            self.recoder.print_log('Training costs {} hours {} mins {} seconds'.format(int(total_time)//60//60, int(total_time)//60%60, int(total_time)%60))
+        elif self.arg.phase == 'test':
+            if self.arg.load_weights is None and self.arg.load_checkpoints is None:
+                print('Please appoint --weights.')
+            self.recoder.print_log('Model:   {}.'.format(self.arg.model))
+            self.recoder.print_log('Weights: {}.'.format(self.arg.load_weights))
+            # train_wer = seq_eval(self.arg, self.data_loader["train_eval"], self.model, self.device,
+            #                      "train", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            dev_wer = seq_eval(self.arg, self.data_loader["dev"], self.model, self.device,
+                               "dev", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            test_wer = seq_eval(self.arg, self.data_loader["test"], self.model, self.device,
+                                "test", 6667, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+            self.recoder.print_log('Evaluation Done.\n')
+        elif self.arg.phase == "features":
+            for mode in ["train", "dev", "test"]:
+                seq_feature_generation(
+                    self.data_loader[mode + "_eval" if mode == "train" else mode],
+                    self.model, self.device, mode, self.arg.work_dir, self.recoder
+                )
+        elif self.arg.phase == 'finetune':
+            best_dev = 100.0
+            best_epoch = 0
+            total_time = 0
+            epoch_time = 0
+            self.recoder.print_log('Parameters:\n{}\n'.format(str(vars(self.arg))))
+            seq_model_list = []
+            for name, m in self.model.conv2d.named_modules():
+                m.requires_grad = False
+            for name, m in self.model.conv1d.named_modules():
+                if 'fc' not in name:
+                    m.requires_grad = False
+            for name, m in self.model.temporal_model.named_modules():
+                m.requires_grad = False
+            from slr_network import NormLinear
+            self.model.classifier = NormLinear(1024, len(self.gloss_dict) + 1).cuda()
+            self.model.conv1d.fc = self.model.classifier
+
+            for epoch in range(self.arg.optimizer_args['start_epoch'], self.arg.num_epoch):
+                save_model = epoch % self.arg.save_interval == 0
+                eval_model = epoch % self.arg.eval_interval == 0
+                epoch_time = time.time()
+                # train end2end model
+                seq_train(self.data_loader['train'], self.model, self.optimizer,
+                          self.device, epoch, self.recoder)
+                if eval_model:
+                    dev_wer = seq_eval(self.arg, self.data_loader['dev'], self.model, self.device,
+                                       'dev', epoch, self.arg.work_dir, self.recoder, self.arg.evaluate_tool)
+                    self.recoder.print_log("Dev WER: {:05.2f}%".format(dev_wer))
+                if dev_wer < best_dev:
+                    best_dev = dev_wer
+                    best_epoch = epoch
+                    model_path = "{}_best_model.pt".format(self.arg.work_dir)
+                    self.save_model(epoch, model_path)
+                    self.recoder.print_log('Save best model')
+                self.recoder.print_log('Best_dev: {:05.2f}, Epoch : {}'.format(best_dev, best_epoch))
+                if save_model:
+                    model_path = "{}dev_{:05.2f}_epoch{}_model.pt".format(self.arg.work_dir, dev_wer, epoch)
+                    seq_model_list.append(model_path)
+                    print("seq_model_list", seq_model_list)
+                    self.save_model(epoch, model_path)
+                epoch_time = time.time() - epoch_time
+                total_time += epoch_time
+                torch.cuda.empty_cache()
+                self.recoder.print_log('Epoch {} costs {} mins {} seconds'.format(epoch, int(epoch_time)//60, int(epoch_time)%60))
+            self.recoder.print_log('Training costs {} hours {} mins {} seconds'.format(int(total_time)//60//60, int(total_time)//60%60, int(total_time)%60))
+
+    def save_arg(self):
+        arg_dict = vars(self.arg)
+        if not os.path.exists(self.arg.work_dir):
+            os.makedirs(self.arg.work_dir)
+        with open('{}/config.yaml'.format(self.arg.work_dir), 'w') as f:
+            yaml.dump(arg_dict, f)
+
+    def save_model(self, epoch, save_path):
+        torch.save({
+            'epoch': epoch,
+            'model_state_dict': self.model.state_dict(),
+            'optimizer_state_dict': self.optimizer.state_dict(),
+            'scheduler_state_dict': self.optimizer.scheduler.state_dict(),
+            'rng_state': self.rng.save_rng_state(),
+        }, save_path)
+
+    def loading(self):
+        self.device.set_device(self.arg.device)
+        print("Loading model")
+        model_class = import_class(self.arg.model)
+        model = model_class(
+            **self.arg.model_args,
+            gloss_dict=self.gloss_dict,
+            loss_weights=self.arg.loss_weights,
+        )
+        shutil.copy2(inspect.getfile(model_class), self.arg.work_dir)
+        optimizer = utils.Optimizer(model, self.arg.optimizer_args)
+
+        if self.arg.load_weights:
+            self.load_model_weights(model, self.arg.load_weights)
+        elif self.arg.load_checkpoints:
+            self.load_checkpoint_weights(model, optimizer)
+        model = self.model_to_device(model)
+        # Handle DataParallel wrapper
+        if isinstance(model, nn.DataParallel):
+            self.kernel_sizes = model.module.conv1d.kernel_size
+        else:
+            self.kernel_sizes = model.conv1d.kernel_size
+        print("Loading model finished.")
+        self.load_data()
+        return model, optimizer
+
+    def model_to_device(self, model):
+        model = model.to(self.device.output_device)
+        if len(self.device.gpu_list) > 1:
+            # Use DataParallel for multi-GPU training
+            model = nn.DataParallel(model, device_ids=self.device.gpu_list, output_device=self.device.output_device)
+            print(f"Using DataParallel on GPUs: {self.device.gpu_list}")
+        model = convert_model(model)
+        model.cuda()
+        return model
+
+    def load_model_weights(self, model, weight_path):
+        state_dict = torch.load(weight_path)
+        if len(self.arg.ignore_weights):
+            for w in self.arg.ignore_weights:
+                if state_dict.pop(w, None) is not None:
+                    print('Successfully Remove Weights: {}.'.format(w))
+                else:
+                    print('Can Not Remove Weights: {}.'.format(w))
+        weights = self.modified_weights(state_dict['model_state_dict'], False)
+        # weights = self.modified_weights(state_dict['model_state_dict'])
+        model.load_state_dict(weights, strict=True)
+
+    @staticmethod
+    def modified_weights(state_dict, modified=False):
+        state_dict = OrderedDict([(k.replace('.module', ''), v) for k, v in state_dict.items()])
+        if not modified:
+            return state_dict
+        modified_dict = dict()
+        return modified_dict
+
+    def load_checkpoint_weights(self, model, optimizer):
+        self.load_model_weights(model, self.arg.load_checkpoints)
+        state_dict = torch.load(self.arg.load_checkpoints)
+
+        if len(torch.cuda.get_rng_state_all()) == len(state_dict['rng_state']['cuda']):
+            print("Loading random seeds...")
+            self.rng.set_rng_state(state_dict['rng_state'])
+        if "optimizer_state_dict" in state_dict.keys():
+            print("Loading optimizer parameters...")
+            optimizer.load_state_dict(state_dict["optimizer_state_dict"])
+            optimizer.to(self.device.output_device)
+        if "scheduler_state_dict" in state_dict.keys():
+            print("Loading scheduler parameters...")
+            optimizer.scheduler.load_state_dict(state_dict["scheduler_state_dict"])
+
+        self.arg.optimizer_args['start_epoch'] = state_dict["epoch"] + 1
+        self.recoder.print_log("Resuming from checkpoint: epoch {self.arg.optimizer_args['start_epoch']}")
+
+    def load_data(self):
+        print("Loading data")
+        from tqdm import tqdm
+        self.feeder = import_class(self.arg.feeder)
+        shutil.copy2(inspect.getfile(self.feeder), self.arg.work_dir)
+        if self.arg.dataset == 'CSL':
+            dataset_list = zip(["train", "dev"], [True, False])
+        elif 'phoenix' in self.arg.dataset:
+            dataset_list = zip(["train", "dev", "test"], [True, False, False]) 
+        elif self.arg.dataset == 'CSL-Daily':
+            dataset_list = zip(["train", "dev", "test"], [True, False, False])
+        elif self.arg.dataset == 'ASLLRP':
+            dataset_list = zip(["train", "dev", "test"], [True, False, False])
+        
+        dataset_list = list(dataset_list)
+        for idx, (mode, train_flag) in enumerate(tqdm(dataset_list, desc="Creating data loaders")):
+            arg = self.arg.feeder_args
+            arg["prefix"] = self.arg.dataset_info['dataset_root']
+            arg["mode"] = mode.split("_")[0]
+            arg["transform_mode"] = train_flag
+            self.dataset[mode] = self.feeder(gloss_dict=self.gloss_dict, kernel_size= self.kernel_sizes, dataset=self.arg.dataset, **arg)
+            print(f"  Building DataLoader for {mode} set...")
+            self.data_loader[mode] = self.build_dataloader(self.dataset[mode], mode, train_flag)
+        print("Loading data finished.")
+    def init_fn(self, worker_id):
+        np.random.seed(int(self.arg.random_seed)+worker_id)
+    def build_dataloader(self, dataset, mode, train_flag):
+        print(f"    Initializing {self.arg.num_worker} workers for {mode} DataLoader...")
+        loader = torch.utils.data.DataLoader(
+            dataset,
+            batch_size=self.arg.batch_size if mode == "train" else self.arg.test_batch_size,
+            shuffle=train_flag,
+            drop_last=train_flag,
+            num_workers=self.arg.num_worker,  # if train_flag else 0
+            collate_fn=self.feeder.collate_fn,
+            pin_memory=True,
+            worker_init_fn=self.init_fn,
+            persistent_workers=True if self.arg.num_worker > 0 else False,  # Keep workers alive
+            prefetch_factor=2,  # Prefetch batches
+        )
+        
+        # Force worker initialization by accessing first batch
+        if self.arg.num_worker > 0:
+            print(f"    Warming up workers...")
+            import time
+            start_time = time.time()
+            try:
+                _ = next(iter(loader))
+                print(f"    Workers initialized in {time.time() - start_time:.1f}s")
+            except StopIteration:
+                pass
+        
+        return loader
+
+
+def import_class(name):
+    components = name.rsplit('.', 1)
+    mod = importlib.import_module(components[0])
+    mod = getattr(mod, components[1])
+    return mod
+
+
+if __name__ == '__main__':
+    sparser = utils.get_parser()
+    p = sparser.parse_args()
+    # p.config = "baseline_iter.yaml"
+    if p.config is not None:
+        with open(p.config, 'r') as f:
+            try:
+                default_arg = yaml.load(f, Loader=yaml.FullLoader)
+            except AttributeError:
+                default_arg = yaml.load(f)
+        key = vars(p).keys()
+        for k in default_arg.keys():
+            if k not in key:
+                print('WRONG ARG: {}'.format(k))
+                assert (k in key)
+        sparser.set_defaults(**default_arg)
+    args = sparser.parse_args()
+    with open(f"./configs/{args.dataset}.yaml", 'r') as f:
+        args.dataset_info = yaml.load(f, Loader=yaml.FullLoader)
+    processor = Processor(args)
+    utils.pack_code("./", args.work_dir)
+    processor.start()

slt_new/requirements.txt

@@ -0,0 +1,9 @@
+matplotlib==3.4.3
+numpy==1.20.3
+opencv_python==4.5.5.64
+pandas==1.3.4
+Pillow==9.4.0
+PyYAML==6.0
+scipy==1.7.1
+six==1.16.0
+tqdm==4.62.3

slt_new/seq_scripts.py

@@ -0,0 +1,166 @@
+import os
+import pdb
+import sys
+import copy
+import torch
+import numpy as np
+import torch.nn as nn
+from tqdm import tqdm
+import torch.nn.functional as F
+import matplotlib.pyplot as plt
+from evaluation.slr_eval.wer_calculation import evaluate
+#from torch.cuda.amp import autocast as autocast
+#from torch.cuda.amp import GradScaler
+import gc
+
+def seq_train(loader, model, optimizer, device, epoch_idx, recoder):
+    model.train()
+    loss_value = []
+    clr = [group['lr'] for group in optimizer.optimizer.param_groups]
+    #scaler = GradScaler()
+    pbar = tqdm(loader)
+    for batch_idx, data in enumerate(pbar):
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        label = device.data_to_device(data[2])
+        label_lgt = device.data_to_device(data[3])
+        optimizer.zero_grad()
+        #with autocast():
+        ret_dict = model(vid, vid_lgt)
+        # criterion_calculation should be called outside DataParallel
+        loss, _ = model.module.criterion_calculation(ret_dict, label, label_lgt) if isinstance(model, nn.DataParallel) else model.criterion_calculation(ret_dict, label, label_lgt)
+        if np.isinf(loss.item()) or np.isnan(loss.item()):
+            pdb.set_trace()
+        
+        # Normal training step
+        #scaler.scale(loss).backward()
+        loss.backward()
+        #scaler.unscale_(optimizer.optimizer)
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)
+        #scaler.step(optimizer.optimizer)
+        optimizer.optimizer.step()
+        #scaler.update()
+        loss_value.append(loss.item())
+        if batch_idx % recoder.log_interval == 0:
+            recoder.print_log(
+                '\tEpoch: {}, Batch({}/{}) done. Loss: {:.8f}  lr:{:.6f}'
+                    .format(epoch_idx, batch_idx, len(loader), loss.item(), clr[0]))
+        del ret_dict
+        del loss
+    optimizer.scheduler.step()
+    recoder.print_log('\tMean training loss: {:.10f}.'.format(np.mean(loss_value)))
+    del loss_value
+    del clr
+    gc.collect()
+    torch.cuda.empty_cache()
+    return 
+
+
+def seq_eval(cfg, loader, model, device, mode, epoch, work_dir, recoder,
+             evaluate_tool="python"):
+    model.eval()
+    total_sent = []
+    total_info = []
+    total_conv_sent = []
+    stat = {i: [0, 0] for i in range(len(loader.dataset.dict))}
+    for batch_idx, data in enumerate(tqdm(loader)):
+        recoder.record_timer("device")
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        label = device.data_to_device(data[2])
+        label_lgt = device.data_to_device(data[3])
+        with torch.no_grad():
+            ret_dict = model(vid, vid_lgt)
+
+        total_info += [file_name.split("|")[0] for file_name in data[-1]]
+        total_sent += ret_dict['recognized_sents']
+        total_conv_sent += ret_dict['conv_sents']
+    try:
+        python_eval = True if evaluate_tool == "python" else False
+        write2file(work_dir + "output-hypothesis-{}.ctm".format(mode), total_info, total_sent)
+        write2file(work_dir + "output-hypothesis-{}-conv.ctm".format(mode), total_info,
+                   total_conv_sent)
+        conv_ret = evaluate(
+            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}-conv.ctm".format(mode),
+            evaluate_dir=cfg.dataset_info['evaluation_dir'],
+            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
+            output_dir="epoch_{}_result/".format(epoch),
+            python_evaluate=python_eval,
+        )
+        lstm_ret = evaluate(
+            prefix=work_dir, mode=mode, output_file="output-hypothesis-{}.ctm".format(mode),
+            evaluate_dir=cfg.dataset_info['evaluation_dir'],
+            evaluate_prefix=cfg.dataset_info['evaluation_prefix'],
+            output_dir="epoch_{}_result/".format(epoch),
+            python_evaluate=python_eval,
+            triplet=True,
+        )
+    except:
+        print("Unexpected error:", sys.exc_info()[0])
+        lstm_ret = 100.0
+    finally:
+        pass
+    if 'conv_ret' in locals():
+        del conv_ret
+    del total_sent
+    del total_info
+    del total_conv_sent
+    del vid
+    del vid_lgt
+    del label
+    del label_lgt
+    gc.collect()
+    recoder.print_log(f"Epoch {epoch}, {mode} {lstm_ret: 2.2f}%", f"{work_dir}/{mode}.txt")
+    return lstm_ret
+
+
+def seq_feature_generation(loader, model, device, mode, work_dir, recoder):
+    model.eval()
+
+    src_path = os.path.abspath(f"{work_dir}{mode}")
+    tgt_path = os.path.abspath(f"./features/{mode}")
+    if not os.path.exists("./features/"):
+        os.makedirs("./features/")
+
+    if os.path.islink(tgt_path):
+        curr_path = os.readlink(tgt_path)
+        if work_dir[1:] in curr_path and os.path.isabs(curr_path):
+            return
+        else:
+            os.unlink(tgt_path)
+    else:
+        if os.path.exists(src_path) and len(loader.dataset) == len(os.listdir(src_path)):
+            os.symlink(src_path, tgt_path)
+            return
+
+    for batch_idx, data in tqdm(enumerate(loader)):
+        recoder.record_timer("device")
+        vid = device.data_to_device(data[0])
+        vid_lgt = device.data_to_device(data[1])
+        with torch.no_grad():
+            ret_dict = model(vid, vid_lgt)
+        if not os.path.exists(src_path):
+            os.makedirs(src_path)
+        start = 0
+        for sample_idx in range(len(vid)):
+            end = start + data[3][sample_idx]
+            filename = f"{src_path}/{data[-1][sample_idx].split('|')[0]}_features.npy"
+            save_file = {
+                "label": data[2][start:end],
+                "features": ret_dict['framewise_features'][sample_idx][:, :vid_lgt[sample_idx]].T.cpu().detach(),
+            }
+            np.save(filename, save_file)
+            start = end
+        assert end == len(data[2])
+    os.symlink(src_path, tgt_path)
+
+
+def write2file(path, info, output):
+    filereader = open(path, "w")
+    for sample_idx, sample in enumerate(output):
+        for word_idx, word in enumerate(sample):
+            filereader.writelines(
+                "{} 1 {:.2f} {:.2f} {}\n".format(info[sample_idx],
+                                                 word_idx * 1.0 / 100,
+                                                 (word_idx + 1) * 1.0 / 100,
+                                                 word[0]))

slt_new/slr_network.py

@@ -0,0 +1,170 @@
+import pdb
+import copy
+import utils
+import torch
+import types
+import numpy as np
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.models as models
+from modules.criterions import SeqKD
+from modules import BiLSTMLayer, TemporalConv
+import modules.resnet as resnet
+
+class Identity(nn.Module):
+    def __init__(self):
+        super(Identity, self).__init__()
+
+    def forward(self, x):
+        return x
+
+
+class NormLinear(nn.Module):
+    def __init__(self, in_dim, out_dim):
+        super(NormLinear, self).__init__()
+        self.weight = nn.Parameter(torch.Tensor(in_dim, out_dim))
+        nn.init.xavier_uniform_(self.weight, gain=nn.init.calculate_gain('relu'))
+
+    def forward(self, x):
+        outputs = torch.matmul(x, F.normalize(self.weight, dim=0))
+        return outputs
+
+
+class SLRModel(nn.Module):
+    def __init__(
+            self, num_classes, c2d_type, conv_type, use_bn=False,
+            hidden_size=1024, gloss_dict=None, loss_weights=None,
+            weight_norm=True, share_classifier=True
+    ):
+        super(SLRModel, self).__init__()
+        self.decoder = None
+        self.loss = dict()
+        self.criterion_init()
+        self.num_classes = num_classes
+        self.loss_weights = loss_weights
+        #self.conv2d = getattr(models, c2d_type)(pretrained=True)
+        self.conv2d = getattr(resnet, c2d_type)()
+        self.conv2d.fc = nn.Identity()
+
+        self.conv1d = TemporalConv(input_size=512,
+                                   hidden_size=hidden_size,
+                                   conv_type=conv_type,
+                                   use_bn=use_bn,
+                                   num_classes=num_classes)
+        # Auto-detect blank token in gloss_dict
+        blank_id = num_classes - 1  # Default for datasets without blank in dict
+        for gloss, idx in gloss_dict.items():
+            if 'blank' in str(gloss).lower():
+                blank_id = idx
+                break
+        self.decoder = utils.Decode(gloss_dict, num_classes, 'beam', blank_id=blank_id)
+        self.temporal_model = BiLSTMLayer(rnn_type='LSTM', input_size=hidden_size, hidden_size=hidden_size,
+                                          num_layers=2, bidirectional=True)
+        if weight_norm:
+            self.classifier = NormLinear(hidden_size, self.num_classes)
+            self.conv1d.fc = NormLinear(hidden_size, self.num_classes)
+        else:
+            self.classifier = nn.Linear(hidden_size, self.num_classes)
+            self.conv1d.fc = nn.Linear(hidden_size, self.num_classes)
+        if share_classifier:
+            self.conv1d.fc = self.classifier
+        #self.register_backward_hook(self.backward_hook)
+
+    def backward_hook(self, module, grad_input, grad_output):
+        for g in grad_input:
+            g[g != g] = 0
+
+    def masked_bn(self, inputs, len_x):
+        def pad(tensor, length):
+            return torch.cat([tensor, tensor.new(length - tensor.size(0), *tensor.size()[1:]).zero_()])
+
+        x = torch.cat([inputs[len_x[0] * idx:len_x[0] * idx + lgt] for idx, lgt in enumerate(len_x)])
+        x = self.conv2d(x)
+        x = torch.cat([pad(x[sum(len_x[:idx]):sum(len_x[:idx + 1])], len_x[0])
+                       for idx, lgt in enumerate(len_x)])
+        return x
+
+    def forward(self, x, len_x):
+        if len(x.shape) == 5:
+            # videos
+            batch, temp, channel, height, width = x.shape
+            #inputs = x.reshape(batch * temp, channel, height, width)
+            #framewise = self.masked_bn(inputs, len_x)
+            #framewise = framewise.reshape(batch, temp, -1).transpose(1, 2)
+            # x shape: (B, T, C, H, W) -> permute to (B, C, T, H, W) for 3D Conv
+            x_permuted = x.permute(0,2,1,3,4)  # (B,T,C,H,W) -> (B,C,T,H,W)
+            framewise = self.conv2d(x_permuted)
+            # Ensure we have B*T, 512 dimensions
+            framewise = framewise.view(batch, temp, -1).permute(0,2,1) # btc -> bct
+        else:
+            # frame-wise features
+            framewise = x
+
+        conv1d_outputs = self.conv1d(framewise, len_x)
+        # x: T, B, C
+        x = conv1d_outputs['visual_feat']
+        lgt = conv1d_outputs['feat_len']
+        tm_outputs = self.temporal_model(x, lgt)
+        outputs = self.classifier(tm_outputs['predictions'])
+        pred = None if self.training \
+            else self.decoder.decode(outputs, lgt, batch_first=False, probs=False)
+        conv_pred = None if self.training \
+            else self.decoder.decode(conv1d_outputs['conv_logits'], lgt, batch_first=False, probs=False)
+
+        # Ensure feat_len is a tensor for proper DataParallel gathering
+        if not isinstance(lgt, torch.Tensor):
+            lgt = torch.tensor(lgt, device=x.device)
+        
+        return {
+            #"framewise_features": framewise,
+            #"visual_features": x,
+            "feat_len": lgt,
+            "conv_logits": conv1d_outputs['conv_logits'],
+            "sequence_logits": outputs,
+            "conv_sents": conv_pred,
+            "recognized_sents": pred,
+            "loss_LiftPool_u": conv1d_outputs['loss_LiftPool_u'],
+            "loss_LiftPool_p": conv1d_outputs['loss_LiftPool_p'],
+        }
+
+    def criterion_calculation(self, ret_dict, label, label_lgt):
+        loss = 0
+        total_loss = {}
+        
+        # Match original CorrNet+ implementation exactly
+        for k, weight in self.loss_weights.items():
+            if k == 'ConvCTC':
+                total_loss['ConvCTC'] = weight * self.loss['CTCLoss'](
+                    ret_dict["conv_logits"].log_softmax(-1),
+                    label.cpu().int(), 
+                    ret_dict["feat_len"].cpu().int(),
+                    label_lgt.cpu().int()
+                ).mean()
+                loss += total_loss['ConvCTC']
+            elif k == 'SeqCTC':
+                total_loss['SeqCTC'] = weight * self.loss['CTCLoss'](
+                    ret_dict["sequence_logits"].log_softmax(-1),
+                    label.cpu().int(), 
+                    ret_dict["feat_len"].cpu().int(),
+                    label_lgt.cpu().int()
+                ).mean()
+                loss += total_loss['SeqCTC']
+            elif k == 'Dist':
+                total_loss['Dist'] = weight * self.loss['distillation'](
+                    ret_dict["conv_logits"],
+                    ret_dict["sequence_logits"].detach(),
+                    use_blank=False
+                )
+                loss += total_loss['Dist']
+            elif k == 'Cu':
+                total_loss['Cu'] = weight * ret_dict["loss_LiftPool_u"]
+                loss += total_loss['Cu']
+            elif k == 'Cp':
+                total_loss['Cp'] = weight * ret_dict["loss_LiftPool_p"]   
+                loss += total_loss['Cp'] 
+        return loss, total_loss
+
+    def criterion_init(self):
+        self.loss['CTCLoss'] = torch.nn.CTCLoss(reduction='none', zero_infinity=False)
+        self.loss['distillation'] = SeqKD(T=8)
+        return self.loss

slt_new/train_asllrp.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+# Training script for ASLLRP dataset
+
+# Activate conda environment
+source /research/cbim/vast/sf895/miniforge3/etc/profile.d/conda.sh
+conda activate signx-slt
+
+# Set CUDA device - use all 8 GPUs
+export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
+
+# Start training
+python main.py \
+    --config ./configs/asllrp.yaml \
+    --device 0,1,2,3,4,5,6,7 \
+    --phase train \
+    --print-log True \
+    --log-interval 50 \
+    --save-interval 5 \
+    --eval-interval 1 \
+    --num-epoch 80 \
+    --batch-size 16 \
+    --test-batch-size 32 \
+    --num-worker 32

slt_new/train_asllrp_single.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+source /research/cbim/vast/sf895/miniforge3/bin/activate signx-slt
+CUDA_VISIBLE_DEVICES=0 python main.py \
+    --config ./configs/asllrp.yaml \
+    --device 0 \
+    --phase train

slt_new/训练细节.txt

@@ -0,0 +1,54 @@
+基于我的分析，以下是CorrNet+的训练细节：
+
+  CorrNet+ 训练配置和性能
+
+  硬件配置
+
+  - GPU数量: 2个GPU（device: 0,1）
+  - 批大小: 每GPU 2个样本，总批大小 = 4
+
+  训练设置
+
+  - 总epoch数: 80
+  - 优化器: Adam
+  - 学习率: 0.0001
+  - 学习率调整: 在第40和60个epoch降低学习率（×0.2）
+
+  数据集规模（以CSL-Daily为例）
+
+  - CSL-Daily训练集：约18,401个视频
+  - Phoenix2014训练集：约5,672个视频
+
+  总训练步数计算
+
+  对于CSL-Daily：
+  - 每个epoch步数 = 18,401 / 4 ≈ 4,600步
+  - 总步数 = 4,600 × 80 = 368,000步
+
+  对于您的ASLLRP数据集：
+  - 训练样本：1,073个
+  - 批大小：16（8个GPU）
+  - 每个epoch步数 = 1,073 / 16 ≈ 67步
+  - 总步数 = 67 × 80 = 5,360步
+
+  性能指标（WER）
+
+  根据README表格，CorrNet+在不同数据集上的表现：
+  - Phoenix2014: Dev 5.3%, Test 5.6%
+  - Phoenix2014-T: Dev 18.0%, Test 18.2%
+  - CSL-Daily: Dev 17.2%, Test 19.1%
+
+  训练时间估算
+
+  - 原论文使用2个GPU训练80个epoch
+  - 您使用8个GPU，理论上可以加速约4倍
+  - 但您的数据集规模较小（1,073 vs 18,401），所以训练会快很多
+
+  建议
+
+  1.
+  学习率调整：由于您使用8个GPU（批大小16），可以考虑将学习率提高到0.0002或0.0004
+  2. 早期验证：您的数据集较小，可能在20-40个epoch就能看到不错的结果
+  3. 过拟合风险：数据集较小时要注意过拟合，可以增加dropout或使用更强的数据增强
+
+  您的训练正在进行中，建议等第一个epoch结束后查看验证集WER，这样可以评估初始性能