Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+feeders/__pycache__/feeder_ucla.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

config/custom/balanced.yaml

@@ -0,0 +1,85 @@
+work_dir: ./work_dir/custom/ctrgcn_balanced
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  random_choose: False       
+  random_shift: False        
+  random_move: False         
+  window_size: 64
+  normalization: False       
+  random_rot: True           # Keep rotation augmentation - it's proven effective
+  p_interval: [0.5, 1]      
+  vel: False
+  bone: False
+
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: 'spatial'
+  drop_out: 0.2              # Moderate dropout (was 0.5, now 0.2)
+
+# Model weights (optional)
+weights: null                
+ignore_weights: []           
+
+#optim
+weight_decay: 0.0006         # Modest increase from original 0.0004 (was 0.001)
+base_lr: 0.08               # Moderate reduction from original 0.1 (was 0.05)
+lr_decay_rate: 0.1
+step: [35, 55]              # Back to original schedule (was [40, 60])
+warm_up_epoch: 5
+optimizer: SGD               
+
+# training
+device: [0]
+batch_size: 48              # Compromise between 32 and 64
+test_batch_size: 64
+num_epoch: 80               
+nesterov: True
+start_epoch: 0              
+phase: train                
+save_score: False           
+seed: 1                     
+log_interval: 100           
+save_interval: 1            
+save_epoch: 30              
+eval_interval: 1            
+print_log: True             
+show_topk: [1, 5]           
+num_worker: 24              
+model_saved_name: ./work_dir/custom/ctrgcn_balanced/runs
+
+# Early stopping (keep but with longer patience)
+early_stopping: True
+patience: 15                # Increased from 10 to 15
+min_delta: 0.001           
+
+# Remove excessive regularization
+use_joint_stream: True
+use_bone_stream: True
+use_motion_stream: True
+
+# Mild label smoothing (was 0.1, now 0.05)
+label_smoothing: 0.05
+
+# Remove gradient clipping - not needed with other regularization 

config/custom/default.yaml

@@ -0,0 +1,52 @@
+work_dir: ./work_dir/custom/ctrgcn_joint
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  random_choose: False
+  random_shift: False
+  random_move: False
+  window_size: 64
+  normalization: False
+  random_rot: True
+  p_interval: [0.5, 1]
+  vel: False
+  bone: False
+
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: 'spatial'
+
+#optim
+weight_decay: 0.0004
+base_lr: 0.1
+lr_decay_rate: 0.1
+step: [35, 55]
+warm_up_epoch: 5
+
+# training
+device: [0]
+batch_size: 64
+test_batch_size: 64
+num_epoch: 65
+nesterov: True 

config/custom/enhanced.yaml

@@ -0,0 +1,83 @@
+work_dir: ./work_dir/custom/ctrgcn_enhanced
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  random_choose: True        # Enable random temporal cropping
+  random_shift: True         # Enable temporal shifting
+  random_move: True          # Enable spatial transformations (rotation, scaling, translation)
+  window_size: 64
+  normalization: False       # Keep disabled for compatibility
+  random_rot: True           # Enable 3D rotations - very effective
+  p_interval: [0.75, 1]      # More aggressive temporal cropping
+  vel: False
+  bone: False
+
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]         # Stable test-time cropping
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: 'spatial'
+  drop_out: 0.3              # Slightly increased dropout for better generalization
+
+# Model weights (optional)
+weights: null                
+ignore_weights: []           
+
+#optim
+weight_decay: 0.0008         # Slightly increased for better regularization
+base_lr: 0.09               # Slightly higher LR to compensate for stronger augmentation
+lr_decay_rate: 0.1
+step: [35, 55]              # Original schedule
+warm_up_epoch: 5
+optimizer: SGD               
+
+# training
+device: [0]
+batch_size: 56              # Larger batch size for stable training with augmentation
+test_batch_size: 64
+num_epoch: 80               
+nesterov: True
+start_epoch: 0              
+phase: train                
+save_score: False           
+seed: 1                     
+log_interval: 100           
+save_interval: 1            
+save_epoch: 30              
+eval_interval: 1            
+print_log: True             
+show_topk: [1, 5]           
+num_worker: 24              
+model_saved_name: ./work_dir/custom/ctrgcn_enhanced/runs
+
+# Early stopping with longer patience due to augmentation noise
+early_stopping: True
+patience: 18                # Longer patience for augmented training
+min_delta: 0.001           
+
+# Multi-stream training
+use_joint_stream: True
+use_bone_stream: True
+use_motion_stream: True
+
+# Very mild label smoothing with strong augmentation
+label_smoothing: 0.03 

config/custom/improved copy.yaml

@@ -0,0 +1,86 @@
+work_dir: ./work_dir/custom/ctrgcn_improved_final
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  random_choose: False       # Disable temporal sampling (compatibility issue)
+  random_shift: False        # Disable temporal shifting (compatibility issue)
+  random_move: False         # Disable spatial perturbations (compatibility issue)
+  window_size: 64
+  normalization: False       # Disable normalization (compatibility issue)
+  random_rot: False          # Disable rotation augmentation (compatibility issue)
+  p_interval: [0.5, 1]      # Keep probability interval
+  vel: False
+  bone: False
+
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: 'spatial'
+  drop_out: 0.5              # Add dropout for regularization
+
+# Model weights (optional)
+weights: null                # No pretrained weights
+ignore_weights: []           # No weights to ignore
+
+#optim
+weight_decay: 0.001          # Increase weight decay for better regularization
+base_lr: 0.05               # Reduce initial learning rate
+lr_decay_rate: 0.1
+step: [40, 60]              # Adjust LR schedule - later decay
+warm_up_epoch: 5
+optimizer: SGD               # Optimizer type
+
+# training
+device: [0]
+batch_size: 32              # Reduce batch size for better generalization
+test_batch_size: 64
+num_epoch: 80               # Increase epochs with early stopping
+nesterov: True
+start_epoch: 0              # Starting epoch
+phase: train                # Training phase
+save_score: False           # Don't save prediction scores
+seed: 1                     # Random seed
+log_interval: 100           # Log every 100 iterations
+save_interval: 1            # Save model every epoch
+save_epoch: 30              # Start saving after epoch 30
+eval_interval: 1            # Evaluate every epoch
+print_log: True             # Print logs
+show_topk: [1, 5]           # Show top-1 and top-5 accuracy
+num_worker: 24              # Number of data loading workers
+model_saved_name: ./work_dir/custom/ctrgcn_improved_final/runs
+
+# Early stopping
+early_stopping: True
+patience: 10                # Stop if no improvement for 10 epochs
+min_delta: 0.001           # Minimum improvement threshold
+
+# Multi-stream training for better generalization
+use_joint_stream: True
+use_bone_stream: True
+use_motion_stream: True
+
+# Label smoothing for regularization
+label_smoothing: 0.1
+
+# Additional regularization
+gradient_clip: 1.0          # Gradient clipping 

config/custom/improved.yaml

@@ -0,0 +1,86 @@
+work_dir: ./work_dir/custom/ctrgcn_improved
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  random_choose: True       # Disable temporal sampling (compatibility issue)
+  random_shift: True        # Disable temporal shifting (compatibility issue)
+  random_move: True         # Disable spatial perturbations (compatibility issue)
+  window_size: 64
+  normalization: False       # Disable normalization (compatibility issue)
+  random_rot: True          # Disable rotation augmentation (compatibility issue)
+  p_interval: [0.5, 1]      # Keep probability interval
+  vel: False
+  bone: False
+
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: action_recognition.ctrgcn.model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: action_recognition.ctrgcn.graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: 'spatial'
+  drop_out: 0.5              # Add dropout for regularization
+
+# Model weights (optional)
+weights: null                # No pretrained weights
+ignore_weights: []           # No weights to ignore
+
+#optim
+weight_decay: 0.001          # Increase weight decay for better regularization
+base_lr: 0.01               # Reduce initial learning rate
+lr_decay_rate: 0.1
+step: [40, 60]              # Adjust LR schedule - later decay
+warm_up_epoch: 5
+optimizer: SGD               # Optimizer type
+
+# training
+device: [0]
+batch_size: 32              # Reduce batch size for better generalization
+test_batch_size: 64
+num_epoch: 80               # Increase epochs with early stopping
+nesterov: True
+start_epoch: 0              # Starting epoch
+phase: train                # Training phase
+save_score: False           # Don't save prediction scores
+seed: 1                     # Random seed
+log_interval: 100           # Log every 100 iterations
+save_interval: 1            # Save model every epoch
+save_epoch: 30              # Start saving after epoch 30
+eval_interval: 1            # Evaluate every epoch
+print_log: True             # Print logs
+show_topk: [1, 5]           # Show top-1 and top-5 accuracy
+num_worker: 24              # Number of data loading workers
+model_saved_name: ./work_dir/custom/ctrgcn_improved/runs
+
+# Early stopping
+early_stopping: True
+patience: 10                # Stop if no improvement for 10 epochs
+min_delta: 0.001           # Minimum improvement threshold
+
+# Multi-stream training for better generalization
+use_joint_stream: True
+use_bone_stream: True
+use_motion_stream: True
+
+# Label smoothing for regularization
+label_smoothing: 0.1
+
+# Additional regularization
+gradient_clip: 1.0          # Gradient clipping 

config/custom/optimized.yaml

@@ -0,0 +1,93 @@
+# Optimized CTR-GCN Configuration
+# Balanced approach - moderate augmentation with stability
+
+work_dir: ./work_dir/custom/ctrgcn_optimized
+
+# feeder
+feeder: feeders.feeder_custom.Feeder
+train_feeder_args:
+  data_path: data/train
+  label_path: data/train_labels.txt
+  split: train
+  debug: False
+  # Moderate augmentation - not too aggressive
+  random_choose: True
+  random_shift: True
+  random_move: True
+  random_rot: True
+  window_size: 64
+  normalization: False
+  # More conservative temporal cropping
+  p_interval: [0.85, 1]  # Less aggressive than enhanced (0.75)
+  vel: False
+  bone: False
+
+# data loader for testing
+test_feeder: feeders.feeder_custom.Feeder
+test_feeder_args:
+  data_path: data/test
+  label_path: data/test_labels.txt
+  split: test
+  window_size: 64
+  p_interval: [0.95]  # Conservative for testing
+  vel: False
+  bone: False
+  debug: False
+
+# model
+model: model.ctrgcn.Model
+model_args:
+  num_class: 52
+  num_point: 17
+  num_person: 1
+  graph: graph.custom_17j.Graph
+  graph_args:
+    labeling_mode: spatial
+  drop_out: 0.25  # Between balanced (0.2) and enhanced (0.3)
+
+# training
+device: [0]
+batch_size: 52  # Compromise between balanced (48) and enhanced (56)
+test_batch_size: 64
+num_epoch: 80
+
+# optimizer
+weight_decay: 0.0007  # Between balanced (0.0006) and enhanced (0.0008)
+base_lr: 0.085  # Between balanced (0.08) and enhanced (0.09)
+lr_decay_rate: 0.1
+step: [35, 55]
+warm_up_epoch: 5
+
+# training configuration
+nesterov: True
+start_epoch: 0
+save_interval: 1
+save_epoch: 30
+eval_interval: 1
+save_score: False
+show_topk: [1, 5]
+
+# Early stopping
+early_stopping: True
+patience: 16  # Between balanced (15) and enhanced (18)
+min_delta: 0.001
+
+# Multi-stream configuration
+use_joint_stream: True
+use_bone_stream: True
+use_motion_stream: True
+
+# Regularization
+label_smoothing: 0.04  # Between balanced (0.05) and enhanced (0.03)
+
+# Environment
+num_worker: 24
+seed: 1
+
+# Model loading
+weights: null
+ignore_weights: []
+start_epoch: 0
+save_score: false
+print_log: true
+log_interval: 100 

feeders/__pycache__/feeder_ucla.cpython-313.pyc

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

feeders/tools.py

@@ -0,0 +1,234 @@
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+import pdb
+
+import torch
+import torch.nn.functional as F
+
+def valid_crop_resize(data_numpy,valid_frame_num,p_interval,window):
+    # input: C,T,V,M
+    C, T, V, M = data_numpy.shape
+    begin = 0
+    end = valid_frame_num
+    valid_size = end - begin
+
+    #crop
+    if len(p_interval) == 1:
+        p = p_interval[0]
+        bias = int((1-p) * valid_size/2)
+        data = data_numpy[:, begin+bias:end-bias, :, :]# center_crop
+        cropped_length = data.shape[1]
+    else:
+        p = np.random.rand(1)*(p_interval[1]-p_interval[0])+p_interval[0]
+        cropped_length = np.minimum(np.maximum(int(np.floor(valid_size*p)),64), valid_size)# constraint cropped_length lower bound as 64
+        bias = np.random.randint(0,valid_size-cropped_length+1)
+        data = data_numpy[:, begin+bias:begin+bias+cropped_length, :, :]
+        if data.shape[1] == 0:
+            print(cropped_length, bias, valid_size)
+
+    # resize
+    data = torch.tensor(data,dtype=torch.float)
+    data = data.permute(0, 2, 3, 1).contiguous().view(C * V * M, cropped_length)
+    data = data[None, None, :, :]
+    data = F.interpolate(data, size=(C * V * M, window), mode='bilinear',align_corners=False).squeeze() # could perform both up sample and down sample
+    data = data.contiguous().view(C, V, M, window).permute(0, 3, 1, 2).contiguous().numpy()
+
+    return data
+
+def downsample(data_numpy, step, random_sample=True):
+    # input: C,T,V,M
+    begin = np.random.randint(step) if random_sample else 0
+    return data_numpy[:, begin::step, :, :]
+
+
+def temporal_slice(data_numpy, step):
+    # input: C,T,V,M
+    C, T, V, M = data_numpy.shape
+    return data_numpy.reshape(C, T / step, step, V, M).transpose(
+        (0, 1, 3, 2, 4)).reshape(C, T / step, V, step * M)
+
+
+def mean_subtractor(data_numpy, mean):
+    # input: C,T,V,M
+    # naive version
+    if mean == 0:
+        return
+    C, T, V, M = data_numpy.shape
+    valid_frame = (data_numpy != 0).sum(axis=3).sum(axis=2).sum(axis=0) > 0
+    begin = valid_frame.argmax()
+    end = len(valid_frame) - valid_frame[::-1].argmax()
+    data_numpy[:, :end, :, :] = data_numpy[:, :end, :, :] - mean
+    return data_numpy
+
+
+def auto_pading(data_numpy, size, random_pad=False):
+    C, T, V, M = data_numpy.shape
+    if T < size:
+        begin = random.randint(0, size - T) if random_pad else 0
+        data_numpy_paded = np.zeros((C, size, V, M))
+        data_numpy_paded[:, begin:begin + T, :, :] = data_numpy
+        return data_numpy_paded
+    else:
+        return data_numpy
+
+
+def random_choose(data_numpy, size, auto_pad=True):
+    # input: C,T,V,M 随机选择其中一段，不是很合理。因为有0
+    C, T, V, M = data_numpy.shape
+    if T == size:
+        return data_numpy
+    elif T < size:
+        if auto_pad:
+            return auto_pading(data_numpy, size, random_pad=True)
+        else:
+            return data_numpy
+    else:
+        begin = random.randint(0, T - size)
+        return data_numpy[:, begin:begin + size, :, :]
+
+def random_move(data_numpy,
+                angle_candidate=[-10., -5., 0., 5., 10.],
+                scale_candidate=[0.9, 1.0, 1.1],
+                transform_candidate=[-0.2, -0.1, 0.0, 0.1, 0.2],
+                move_time_candidate=[1]):
+    # input: C,T,V,M
+    C, T, V, M = data_numpy.shape
+    move_time = random.choice(move_time_candidate)
+    node = np.arange(0, T, T * 1.0 / move_time).round().astype(int)
+    node = np.append(node, T)
+    num_node = len(node)
+
+    A = np.random.choice(angle_candidate, num_node)
+    S = np.random.choice(scale_candidate, num_node)
+    T_x = np.random.choice(transform_candidate, num_node)
+    T_y = np.random.choice(transform_candidate, num_node)
+
+    a = np.zeros(T)
+    s = np.zeros(T)
+    t_x = np.zeros(T)
+    t_y = np.zeros(T)
+
+    # linspace
+    for i in range(num_node - 1):
+        a[node[i]:node[i + 1]] = np.linspace(
+            A[i], A[i + 1], node[i + 1] - node[i]) * np.pi / 180
+        s[node[i]:node[i + 1]] = np.linspace(S[i], S[i + 1],
+                                             node[i + 1] - node[i])
+        t_x[node[i]:node[i + 1]] = np.linspace(T_x[i], T_x[i + 1],
+                                               node[i + 1] - node[i])
+        t_y[node[i]:node[i + 1]] = np.linspace(T_y[i], T_y[i + 1],
+                                               node[i + 1] - node[i])
+
+    theta = np.array([[np.cos(a) * s, -np.sin(a) * s],
+                      [np.sin(a) * s, np.cos(a) * s]])
+
+    # perform transformation
+    for i_frame in range(T):
+        xy = data_numpy[0:2, i_frame, :, :]
+        new_xy = np.dot(theta[:, :, i_frame], xy.reshape(2, -1))
+        new_xy[0] += t_x[i_frame]
+        new_xy[1] += t_y[i_frame]
+        data_numpy[0:2, i_frame, :, :] = new_xy.reshape(2, V, M)
+
+    return data_numpy
+
+
+def random_shift(data_numpy):
+    C, T, V, M = data_numpy.shape
+    data_shift = np.zeros(data_numpy.shape)
+    valid_frame = (data_numpy != 0).sum(axis=3).sum(axis=2).sum(axis=0) > 0
+    begin = valid_frame.argmax()
+    end = len(valid_frame) - valid_frame[::-1].argmax()
+
+    size = end - begin
+    bias = random.randint(0, T - size)
+    data_shift[:, bias:bias + size, :, :] = data_numpy[:, begin:end, :, :]
+
+    return data_shift
+
+
+def _rot(rot):
+    """
+    rot: T,3
+    """
+    cos_r, sin_r = rot.cos(), rot.sin()  # T,3
+    zeros = torch.zeros(rot.shape[0], 1)  # T,1
+    ones = torch.ones(rot.shape[0], 1)  # T,1
+
+    r1 = torch.stack((ones, zeros, zeros),dim=-1)  # T,1,3
+    rx2 = torch.stack((zeros, cos_r[:,0:1], sin_r[:,0:1]), dim = -1)  # T,1,3
+    rx3 = torch.stack((zeros, -sin_r[:,0:1], cos_r[:,0:1]), dim = -1)  # T,1,3
+    rx = torch.cat((r1, rx2, rx3), dim = 1)  # T,3,3
+
+    ry1 = torch.stack((cos_r[:,1:2], zeros, -sin_r[:,1:2]), dim =-1)
+    r2 = torch.stack((zeros, ones, zeros),dim=-1)
+    ry3 = torch.stack((sin_r[:,1:2], zeros, cos_r[:,1:2]), dim =-1)
+    ry = torch.cat((ry1, r2, ry3), dim = 1)
+
+    rz1 = torch.stack((cos_r[:,2:3], sin_r[:,2:3], zeros), dim =-1)
+    r3 = torch.stack((zeros, zeros, ones),dim=-1)
+    rz2 = torch.stack((-sin_r[:,2:3], cos_r[:,2:3],zeros), dim =-1)
+    rz = torch.cat((rz1, rz2, r3), dim = 1)
+
+    rot = rz.matmul(ry).matmul(rx)
+    return rot
+
+
+def random_rot(data_numpy, theta=0.3):
+    """
+    data_numpy: C,T,V,M
+    """
+    data_torch = torch.from_numpy(data_numpy).float()  # Ensure float32
+    C, T, V, M = data_torch.shape
+    data_torch = data_torch.permute(1, 0, 2, 3).contiguous().view(T, C, V*M)  # T,3,V*M
+    rot = torch.zeros(3, dtype=torch.float32).uniform_(-theta, theta)  # Ensure float32
+    rot = torch.stack([rot, ] * T, dim=0)
+    rot = _rot(rot)  # T,3,3
+    data_torch = torch.matmul(rot, data_torch)
+    data_torch = data_torch.view(T, C, V, M).permute(1, 0, 2, 3).contiguous()
+
+    return data_torch.numpy()  # Convert back to numpy
+
+def openpose_match(data_numpy):
+    C, T, V, M = data_numpy.shape
+    assert (C == 3)
+    score = data_numpy[2, :, :, :].sum(axis=1)
+    # the rank of body confidence in each frame (shape: T-1, M)
+    rank = (-score[0:T - 1]).argsort(axis=1).reshape(T - 1, M)
+
+    # data of frame 1
+    xy1 = data_numpy[0:2, 0:T - 1, :, :].reshape(2, T - 1, V, M, 1)
+    # data of frame 2
+    xy2 = data_numpy[0:2, 1:T, :, :].reshape(2, T - 1, V, 1, M)
+    # square of distance between frame 1&2 (shape: T-1, M, M)
+    distance = ((xy2 - xy1) ** 2).sum(axis=2).sum(axis=0)
+
+    # match pose
+    forward_map = np.zeros((T, M), dtype=int) - 1
+    forward_map[0] = range(M)
+    for m in range(M):
+        choose = (rank == m)
+        forward = distance[choose].argmin(axis=1)
+        for t in range(T - 1):
+            distance[t, :, forward[t]] = np.inf
+        forward_map[1:][choose] = forward
+    assert (np.all(forward_map >= 0))
+
+    # string data
+    for t in range(T - 1):
+        forward_map[t + 1] = forward_map[t + 1][forward_map[t]]
+
+    # generate data
+    new_data_numpy = np.zeros(data_numpy.shape)
+    for t in range(T):
+        new_data_numpy[:, t, :, :] = data_numpy[:, t, :, forward_map[
+                                                             t]].transpose(1, 2, 0)
+    data_numpy = new_data_numpy
+
+    # score sort
+    trace_score = data_numpy[2, :, :, :].sum(axis=1).sum(axis=0)
+    rank = (-trace_score).argsort()
+    data_numpy = data_numpy[:, :, :, rank]
+
+    return data_numpy

graph/custom_17j.py

@@ -0,0 +1,46 @@
+import numpy as np
+from action_recognition.ctrgcn.graph import tools
+
+num_node = 17
+self_link = [(i, i) for i in range(num_node)]
+inward_ori_index = [
+    (1, 0), (2, 1), (3, 2), (4, 3),      # spine chain
+    (5, 1), (6, 5), (7, 6),             # left arm
+    (8, 1), (9, 8), (10, 9),            # right arm  
+    (11, 0), (12, 11), (13, 12),        # left leg
+    (14, 0), (15, 14), (16, 15)         # right leg
+]
+inward = [(i, j) for (i, j) in inward_ori_index]
+outward = [(j, i) for (i, j) in inward]
+neighbor = inward + outward
+
+
+class Graph:
+    def __init__(self, labeling_mode='spatial'):
+        self.num_node = num_node
+        self.self_link = self_link
+        self.inward = inward
+        self.outward = outward
+        self.neighbor = neighbor
+        self.A = self.get_adjacency_matrix(labeling_mode)
+
+    def get_adjacency_matrix(self, labeling_mode=None):
+        if labeling_mode is None:
+            return self.A
+        if labeling_mode == 'spatial':
+            A = tools.get_spatial_graph(num_node, self_link, inward, outward)
+        else:
+            raise ValueError()
+        return A
+
+
+if __name__ == '__main__':
+    import matplotlib.pyplot as plt
+    import os
+    # os.environ['DISPLAY'] = 'localhost:10.0'
+    A = Graph('spatial').get_adjacency_matrix()
+    for i, graph in enumerate(A):
+        plt.figure()
+        plt.imshow(graph, cmap='gray')
+    plt.show()
+    print("OK") 

graph/tools.py

@@ -0,0 +1,80 @@
+import numpy as np
+
+def get_sgp_mat(num_in, num_out, link):
+    A = np.zeros((num_in, num_out))
+    for i, j in link:
+        A[i, j] = 1
+    A_norm = A / np.sum(A, axis=0, keepdims=True)
+    return A_norm
+
+def edge2mat(link, num_node):
+    A = np.zeros((num_node, num_node))
+    for i, j in link:
+        A[j, i] = 1
+    return A
+
+def get_k_scale_graph(scale, A):
+    if scale == 1:
+        return A
+    An = np.zeros_like(A)
+    A_power = np.eye(A.shape[0])
+    for k in range(scale):
+        A_power = A_power @ A
+        An += A_power
+    An[An > 0] = 1
+    return An
+
+def normalize_digraph(A):
+    Dl = np.sum(A, 0)
+    h, w = A.shape
+    Dn = np.zeros((w, w))
+    for i in range(w):
+        if Dl[i] > 0:
+            Dn[i, i] = Dl[i] ** (-1)
+    AD = np.dot(A, Dn)
+    return AD
+
+
+def get_spatial_graph(num_node, self_link, inward, outward):
+    I = edge2mat(self_link, num_node)
+    In = normalize_digraph(edge2mat(inward, num_node))
+    Out = normalize_digraph(edge2mat(outward, num_node))
+    A = np.stack((I, In, Out))
+    return A
+
+def normalize_adjacency_matrix(A):
+    node_degrees = A.sum(-1)
+    degs_inv_sqrt = np.power(node_degrees, -0.5)
+    norm_degs_matrix = np.eye(len(node_degrees)) * degs_inv_sqrt
+    return (norm_degs_matrix @ A @ norm_degs_matrix).astype(np.float32)
+
+
+def k_adjacency(A, k, with_self=False, self_factor=1):
+    assert isinstance(A, np.ndarray)
+    I = np.eye(len(A), dtype=A.dtype)
+    if k == 0:
+        return I
+    Ak = np.minimum(np.linalg.matrix_power(A + I, k), 1) \
+       - np.minimum(np.linalg.matrix_power(A + I, k - 1), 1)
+    if with_self:
+        Ak += (self_factor * I)
+    return Ak
+
+def get_multiscale_spatial_graph(num_node, self_link, inward, outward):
+    I = edge2mat(self_link, num_node)
+    A1 = edge2mat(inward, num_node)
+    A2 = edge2mat(outward, num_node)
+    A3 = k_adjacency(A1, 2)
+    A4 = k_adjacency(A2, 2)
+    A1 = normalize_digraph(A1)
+    A2 = normalize_digraph(A2)
+    A3 = normalize_digraph(A3)
+    A4 = normalize_digraph(A4)
+    A = np.stack((I, A1, A2, A3, A4))
+    return A
+
+
+
+def get_uniform_graph(num_node, self_link, neighbor):
+    A = normalize_digraph(edge2mat(neighbor + self_link, num_node))
+    return A

inference.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Inference Script for CTR-GCN
+=============================
+
+This script performs inference on pose sequences using a trained CTR-GCN model.
+It reads pose data from poses.pkl (containing 243-frame segments) and predicts
+action labels using the specified configuration and checkpoint.
+
+Usage:
+    python inference.py --config config/custom/improved.yaml --weights work_dir/custom/ctrgcn_improved/runs-66-23166.pt
+
+Author: AI Assistant
+Date: 2025
+"""
+
+import os
+import yaml
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+# Import required modules
+from action_recognition.ctrgcn.feeders import tools
+
+def import_class(import_str):
+    mod_str, _sep, class_str = import_str.rpartition('.')
+    __import__(mod_str)
+    return getattr(__import__(mod_str, fromlist=[class_str]), class_str)
+
+# Hardcoded config and checkpoint paths
+CONFIG_PATH = os.path.join(os.path.dirname(__file__), 'config/custom/improved.yaml')
+WEIGHTS_PATH = os.path.join(os.path.dirname(__file__), 'work_dir/custom/ctrgcn_improved/runs-56-19656.pt')
+
+# Device selection (CPU by default, use CUDA if available)
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Model/class cache
+_model = None
+_config = None
+_class_names = None
+
+def load_model():
+    global _model, _config
+    if _model is not None and _config is not None:
+        return _model, _config
+    with open(CONFIG_PATH, 'r') as f:
+        config = yaml.load(f, Loader=yaml.FullLoader)
+    Model = import_class(config['model'])
+    model = Model(**config['model_args'])
+    weights = torch.load(WEIGHTS_PATH, map_location='cpu')
+    if any(key.startswith('module.') for key in weights.keys()):
+        weights = {key[7:]: value for key, value in weights.items()}
+    model.load_state_dict(weights)
+    model.eval()
+    model = model.to(DEVICE)
+    _model = model
+    _config = config
+    return model, config
+
+def preprocess_pose_data(pose_data, window_size=64, p_interval=[0.95]):
+    if pose_data.ndim == 4:
+        data = pose_data.squeeze(0).transpose(2, 0, 1)
+    elif pose_data.ndim == 3:
+        data = pose_data.transpose(2, 0, 1)
+    else:
+        raise ValueError(f"Unexpected pose_data shape: {pose_data.shape}")
+    data = data[:, :, :, np.newaxis]
+    C, T, V, M = data.shape
+    data = tools.valid_crop_resize(data, T, p_interval, window_size)
+    return data
+
+def predict_label(model, data):
+    data_tensor = torch.from_numpy(data).float().unsqueeze(0).to(DEVICE)
+    with torch.no_grad():
+        output = model(data_tensor)
+        probabilities = F.softmax(output, dim=1)
+        predicted_label = torch.argmax(output, dim=1).item()
+        confidence = probabilities[0, predicted_label].item()
+    return predicted_label, confidence, probabilities.cpu().numpy()[0]
+
+def load_class_names(config):
+    global _class_names
+    if _class_names is not None:
+        return _class_names
+    class_names = {}
+    label_path = config.get('test_feeder_args', {}).get('label_path', None)
+    if label_path and os.path.exists(label_path):
+        with open(label_path, 'r') as f:
+            for line in f:
+                parts = line.strip().split()
+                if len(parts) >= 2:
+                    label = int(parts[1])
+                    if label not in class_names:
+                        class_names[label] = f"Class_{label}"
+    for i in range(52):
+        if i not in class_names:
+            class_names[i] = f"Class_{i}"
+    _class_names = class_names
+    return class_names
+
+def extract_embeddings_from_segments(segments):
+    """
+    Extract feature embeddings from pose segments for clustering/analysis.
+    
+    segments: List of np.ndarray, each of shape (243, 17, 3)
+    Returns: List of dicts with keys: sequence_id, embedding (numpy array)
+    """
+    model, config = load_model()
+    window_size = config.get('test_feeder_args', {}).get('window_size', 64)
+    results = []
+    
+    for i, pose_data in enumerate(segments):
+        processed_data = preprocess_pose_data(pose_data, window_size=window_size)
+        data_tensor = torch.from_numpy(processed_data).float().unsqueeze(0).to(DEVICE)
+        
+        with torch.no_grad():
+            embedding = model.extract_embedding(data_tensor)
+            embedding_np = embedding.cpu().numpy()[0]  # Remove batch dimension
+        
+        results.append({
+            'sequence_id': i,
+            'embedding': embedding_np
+        })
+    
+    return results
+
+def extract_top5_labels_from_segments(segments):
+    """
+    Extract top 5 action labels from pose segments.
+    
+    segments: List of np.ndarray, each of shape (243, 17, 3)
+    Returns: List of dicts with keys: sequence_id, top5_labels (list of 5 integers)
+    """
+    model, config = load_model()
+    window_size = config.get('test_feeder_args', {}).get('window_size', 64)
+    results = []
+    
+    for i, pose_data in enumerate(segments):
+        processed_data = preprocess_pose_data(pose_data, window_size=window_size)
+        data_tensor = torch.from_numpy(processed_data).float().unsqueeze(0).to(DEVICE)
+        
+        with torch.no_grad():
+            output = model(data_tensor)
+            probabilities = F.softmax(output, dim=1)
+            # Get top 5 predictions
+            top5_probs, top5_indices = torch.topk(probabilities, 5, dim=1)
+            top5_labels = top5_indices.cpu().numpy()[0]  # Remove batch dimension
+        
+        results.append({
+            'sequence_id': i,
+            'top5_labels': top5_labels.tolist()
+        })
+    
+    return results
+
+def run_inference_on_segments(segments):
+    """
+    segments: List of np.ndarray, each of shape (243, 17, 3)
+    Returns: List of dicts with keys: sequence_id, predicted_label, confidence, class_name, probabilities
+    """
+    model, config = load_model()
+    class_names = load_class_names(config)
+    window_size = config.get('test_feeder_args', {}).get('window_size', 64)
+    results = []
+    for i, pose_data in enumerate(segments):
+        processed_data = preprocess_pose_data(pose_data, window_size=window_size)
+        pred_label, confidence, prob_distribution = predict_label(model, processed_data)
+        class_name = class_names.get(pred_label, f"Class_{pred_label}")
+        results.append({
+            'sequence_id': i,
+            'predicted_label': pred_label,
+            'confidence': confidence,
+            'class_name': class_name,
+            'probabilities': prob_distribution
+        })
+    return results 

model/ctrgcn.py

@@ -0,0 +1,344 @@
+import math
+import pdb
+
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.autograd import Variable
+import importlib
+
+def import_class(name):
+    components = name.split('.')
+    module_path = '.'.join(components[:-1])
+    class_name = components[-1]
+    mod = importlib.import_module(module_path)
+    return getattr(mod, class_name)
+
+
+def conv_branch_init(conv, branches):
+    weight = conv.weight
+    n = weight.size(0)
+    k1 = weight.size(1)
+    k2 = weight.size(2)
+    nn.init.normal_(weight, 0, math.sqrt(2. / (n * k1 * k2 * branches)))
+    nn.init.constant_(conv.bias, 0)
+
+
+def conv_init(conv):
+    if conv.weight is not None:
+        nn.init.kaiming_normal_(conv.weight, mode='fan_out')
+    if conv.bias is not None:
+        nn.init.constant_(conv.bias, 0)
+
+
+def bn_init(bn, scale):
+    nn.init.constant_(bn.weight, scale)
+    nn.init.constant_(bn.bias, 0)
+
+
+def weights_init(m):
+    classname = m.__class__.__name__
+    if classname.find('Conv') != -1:
+        if hasattr(m, 'weight'):
+            nn.init.kaiming_normal_(m.weight, mode='fan_out')
+        if hasattr(m, 'bias') and m.bias is not None and isinstance(m.bias, torch.Tensor):
+            nn.init.constant_(m.bias, 0)
+    elif classname.find('BatchNorm') != -1:
+        if hasattr(m, 'weight') and m.weight is not None:
+            m.weight.data.normal_(1.0, 0.02)
+        if hasattr(m, 'bias') and m.bias is not None:
+            m.bias.data.fill_(0)
+
+
+class TemporalConv(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1):
+        super(TemporalConv, self).__init__()
+        pad = (kernel_size + (kernel_size-1) * (dilation-1) - 1) // 2
+        self.conv = nn.Conv2d(
+            in_channels,
+            out_channels,
+            kernel_size=(kernel_size, 1),
+            padding=(pad, 0),
+            stride=(stride, 1),
+            dilation=(dilation, 1))
+
+        self.bn = nn.BatchNorm2d(out_channels)
+
+    def forward(self, x):
+        x = self.conv(x)
+        x = self.bn(x)
+        return x
+
+
+class MultiScale_TemporalConv(nn.Module):
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size=3,
+                 stride=1,
+                 dilations=[1,2,3,4],
+                 residual=True,
+                 residual_kernel_size=1):
+
+        super().__init__()
+        assert out_channels % (len(dilations) + 2) == 0, '# out channels should be multiples of # branches'
+
+        # Multiple branches of temporal convolution
+        self.num_branches = len(dilations) + 2
+        branch_channels = out_channels // self.num_branches
+        if type(kernel_size) == list:
+            assert len(kernel_size) == len(dilations)
+        else:
+            kernel_size = [kernel_size]*len(dilations)
+        # Temporal Convolution branches
+        self.branches = nn.ModuleList([
+            nn.Sequential(
+                nn.Conv2d(
+                    in_channels,
+                    branch_channels,
+                    kernel_size=1,
+                    padding=0),
+                nn.BatchNorm2d(branch_channels),
+                nn.ReLU(inplace=True),
+                TemporalConv(
+                    branch_channels,
+                    branch_channels,
+                    kernel_size=ks,
+                    stride=stride,
+                    dilation=dilation),
+            )
+            for ks, dilation in zip(kernel_size, dilations)
+        ])
+
+        # Additional Max & 1x1 branch
+        self.branches.append(nn.Sequential(
+            nn.Conv2d(in_channels, branch_channels, kernel_size=1, padding=0),
+            nn.BatchNorm2d(branch_channels),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(kernel_size=(3,1), stride=(stride,1), padding=(1,0)),
+            nn.BatchNorm2d(branch_channels)  # 为什么还要加bn
+        ))
+
+        self.branches.append(nn.Sequential(
+            nn.Conv2d(in_channels, branch_channels, kernel_size=1, padding=0, stride=(stride,1)),
+            nn.BatchNorm2d(branch_channels)
+        ))
+
+        # Residual connection
+        if not residual:
+            self.residual = lambda x: 0
+        elif (in_channels == out_channels) and (stride == 1):
+            self.residual = lambda x: x
+        else:
+            self.residual = TemporalConv(in_channels, out_channels, kernel_size=residual_kernel_size, stride=stride)
+
+        # initialize
+        self.apply(weights_init)
+
+    def forward(self, x):
+        # Input dim: (N,C,T,V)
+        res = self.residual(x)
+        branch_outs = []
+        for tempconv in self.branches:
+            out = tempconv(x)
+            branch_outs.append(out)
+
+        out = torch.cat(branch_outs, dim=1)
+        out += res
+        return out
+
+
+class CTRGC(nn.Module):
+    def __init__(self, in_channels, out_channels, rel_reduction=8, mid_reduction=1):
+        super(CTRGC, self).__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        if in_channels == 3 or in_channels == 9:
+            self.rel_channels = 8
+            self.mid_channels = 16
+        else:
+            self.rel_channels = in_channels // rel_reduction
+            self.mid_channels = in_channels // mid_reduction
+        self.conv1 = nn.Conv2d(self.in_channels, self.rel_channels, kernel_size=1)
+        self.conv2 = nn.Conv2d(self.in_channels, self.rel_channels, kernel_size=1)
+        self.conv3 = nn.Conv2d(self.in_channels, self.out_channels, kernel_size=1)
+        self.conv4 = nn.Conv2d(self.rel_channels, self.out_channels, kernel_size=1)
+        self.tanh = nn.Tanh()
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                conv_init(m)
+            elif isinstance(m, nn.BatchNorm2d):
+                bn_init(m, 1)
+
+    def forward(self, x, A=None, alpha=1):
+        x1, x2, x3 = self.conv1(x).mean(-2), self.conv2(x).mean(-2), self.conv3(x)
+        x1 = self.tanh(x1.unsqueeze(-1) - x2.unsqueeze(-2))
+        x1 = self.conv4(x1) * alpha + (A.unsqueeze(0).unsqueeze(0) if A is not None else 0)  # N,C,V,V
+        x1 = torch.einsum('ncuv,nctv->nctu', x1, x3)
+        return x1
+
+class unit_tcn(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size=9, stride=1):
+        super(unit_tcn, self).__init__()
+        pad = int((kernel_size - 1) / 2)
+        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=(kernel_size, 1), padding=(pad, 0),
+                              stride=(stride, 1))
+
+        self.bn = nn.BatchNorm2d(out_channels)
+        self.relu = nn.ReLU(inplace=True)
+        conv_init(self.conv)
+        bn_init(self.bn, 1)
+
+    def forward(self, x):
+        x = self.bn(self.conv(x))
+        return x
+
+
+class unit_gcn(nn.Module):
+    def __init__(self, in_channels, out_channels, A, coff_embedding=4, adaptive=True, residual=True):
+        super(unit_gcn, self).__init__()
+        inter_channels = out_channels // coff_embedding
+        self.inter_c = inter_channels
+        self.out_c = out_channels
+        self.in_c = in_channels
+        self.adaptive = adaptive
+        self.num_subset = A.shape[0]
+        self.convs = nn.ModuleList()
+        for i in range(self.num_subset):
+            self.convs.append(CTRGC(in_channels, out_channels))
+
+        if residual:
+            if in_channels != out_channels:
+                self.down = nn.Sequential(
+                    nn.Conv2d(in_channels, out_channels, 1),
+                    nn.BatchNorm2d(out_channels)
+                )
+            else:
+                self.down = lambda x: x
+        else:
+            self.down = lambda x: 0
+        if self.adaptive:
+            self.PA = nn.Parameter(torch.from_numpy(A.astype(np.float32)))
+        else:
+            self.A = Variable(torch.from_numpy(A.astype(np.float32)), requires_grad=False)
+        self.alpha = nn.Parameter(torch.zeros(1))
+        self.bn = nn.BatchNorm2d(out_channels)
+        self.soft = nn.Softmax(-2)
+        self.relu = nn.ReLU(inplace=True)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                conv_init(m)
+            elif isinstance(m, nn.BatchNorm2d):
+                bn_init(m, 1)
+        bn_init(self.bn, 1e-6)
+
+    def forward(self, x):
+        y = None
+        if self.adaptive:
+            A = self.PA
+        else:
+            A = self.A.cuda(x.get_device())
+        for i in range(self.num_subset):
+            z = self.convs[i](x, A[i], self.alpha)
+            y = z + y if y is not None else z
+        y = self.bn(y)
+        y += self.down(x)
+        y = self.relu(y)
+
+
+        return y
+
+
+class TCN_GCN_unit(nn.Module):
+    def __init__(self, in_channels, out_channels, A, stride=1, residual=True, adaptive=True, kernel_size=5, dilations=[1,2]):
+        super(TCN_GCN_unit, self).__init__()
+        self.gcn1 = unit_gcn(in_channels, out_channels, A, adaptive=adaptive)
+        self.tcn1 = MultiScale_TemporalConv(out_channels, out_channels, kernel_size=kernel_size, stride=stride, dilations=dilations,
+                                            residual=False)
+        self.relu = nn.ReLU(inplace=True)
+        if not residual:
+            self.residual = lambda x: 0
+
+        elif (in_channels == out_channels) and (stride == 1):
+            self.residual = lambda x: x
+
+        else:
+            self.residual = unit_tcn(in_channels, out_channels, kernel_size=1, stride=stride)
+
+    def forward(self, x):
+        y = self.relu(self.tcn1(self.gcn1(x)) + self.residual(x))
+        return y
+
+
+class Model(nn.Module):
+    def __init__(self, num_class=60, num_point=25, num_person=2, graph=None, graph_args=dict(), in_channels=3,
+                 drop_out=0, adaptive=True):
+        super(Model, self).__init__()
+
+        if graph is None:
+            raise ValueError()
+        else:
+            Graph = import_class(graph)
+            self.graph = Graph(**graph_args)
+
+        A = self.graph.A # 3,25,25
+
+        self.num_class = num_class
+        self.num_point = num_point
+        self.data_bn = nn.BatchNorm1d(num_person * in_channels * num_point)
+
+        base_channel = 64
+        self.l1 = TCN_GCN_unit(in_channels, base_channel, A, residual=False, adaptive=adaptive)
+        self.l2 = TCN_GCN_unit(base_channel, base_channel, A, adaptive=adaptive)
+        self.l3 = TCN_GCN_unit(base_channel, base_channel, A, adaptive=adaptive)
+        self.l4 = TCN_GCN_unit(base_channel, base_channel, A, adaptive=adaptive)
+        self.l5 = TCN_GCN_unit(base_channel, base_channel*2, A, stride=2, adaptive=adaptive)
+        self.l6 = TCN_GCN_unit(base_channel*2, base_channel*2, A, adaptive=adaptive)
+        self.l7 = TCN_GCN_unit(base_channel*2, base_channel*2, A, adaptive=adaptive)
+        self.l8 = TCN_GCN_unit(base_channel*2, base_channel*4, A, stride=2, adaptive=adaptive)
+        self.l9 = TCN_GCN_unit(base_channel*4, base_channel*4, A, adaptive=adaptive)
+        self.l10 = TCN_GCN_unit(base_channel*4, base_channel*4, A, adaptive=adaptive)
+
+        self.fc = nn.Linear(base_channel*4, num_class)
+        nn.init.normal_(self.fc.weight, 0, math.sqrt(2. / num_class))
+        bn_init(self.data_bn, 1)
+        if drop_out:
+            self.drop_out = nn.Dropout(drop_out)
+        else:
+            self.drop_out = lambda x: x
+
+    def extract_embedding(self, x):
+        """Extract feature embedding before final classification layer"""
+        if len(x.shape) == 3:
+            N, T, VC = x.shape
+            x = x.view(N, T, self.num_point, -1).permute(0, 3, 1, 2).contiguous().unsqueeze(-1)
+        N, C, T, V, M = x.size()
+
+        x = x.permute(0, 4, 3, 1, 2).contiguous().view(N, M * V * C, T)
+        x = self.data_bn(x)
+        x = x.view(N, M, V, C, T).permute(0, 1, 3, 4, 2).contiguous().view(N * M, C, T, V)
+        x = self.l1(x)
+        x = self.l2(x)
+        x = self.l3(x)
+        x = self.l4(x)
+        x = self.l5(x)
+        x = self.l6(x)
+        x = self.l7(x)
+        x = self.l8(x)
+        x = self.l9(x)
+        x = self.l10(x)
+
+        # N*M,C,T,V
+        c_new = x.size(1)
+        x = x.view(N, M, c_new, -1)
+        x = x.mean(3).mean(1)
+        x = self.drop_out(x)
+        
+        return x  # Return embedding (before final classification)
+
+    def forward(self, x):
+        # Extract embedding
+        embedding = self.extract_embedding(x)
+        # Apply final classification layer
+        return self.fc(embedding)

requirements.txt

@@ -0,0 +1,3 @@
+numpy
+pyyaml
+torch 

torchlight/setup.py

@@ -0,0 +1,8 @@
+from setuptools import find_packages, setup
+
+setup(
+    name='torchlight',
+    version='1.0',
+    description='A mini framework for pytorch',
+    packages=find_packages(),
+    install_requires=[])

torchlight/torchlight.egg-info/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: torchlight
+Version: 1.0
+Summary: A mini framework for pytorch
+Dynamic: summary