Upload train_full_SSL_knn.py with huggingface_hub

train_full_SSL_knn.py

@@ -0,0 +1,731 @@
+"""
+Copyright 2023 LINE Corporation
+LINE Corporation licenses this file to you under the Apache License,
+version 2.0 (the "License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at:
+    https://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.
+"""
+
+from __future__ import print_function
+
+import argparse
+import inspect
+import os
+import pdb
+import pickle
+import random
+import re
+import shutil
+import time
+from collections import *
+
+import ipdb
+import numpy as np
+
+# torch
+import torch
+import torch.backends.cudnn as cudnn
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+import yaml
+from einops import rearrange, reduce, repeat
+from evaluation.classificationMAP import getClassificationMAP as cmAP
+from evaluation.detectionMAP import getSingleStreamDetectionMAP as dsmAP
+from feeders.tools import collate_with_padding_multi_joint
+from model.losses import cross_entropy_loss, mvl_loss
+from sklearn.metrics import f1_score
+
+# Custom
+from tensorboardX import SummaryWriter
+from torch.autograd import Variable
+from torch.optim.lr_scheduler import _LRScheduler
+from tqdm import tqdm
+from utils.logger import Logger
+
+def remove_prefix_from_state_dict(state_dict, prefix):
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        if k.startswith(prefix):
+            new_k = k[len(prefix):]  # strip the prefix
+        else:
+            new_k = k
+        new_state_dict[new_k] = v
+    return new_state_dict
+
+
+def init_seed(seed):
+    torch.cuda.manual_seed_all(seed)
+    torch.manual_seed(seed)
+    np.random.seed(seed)
+    random.seed(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+def get_parser():
+    # parameter priority: command line > config > default
+    parser = argparse.ArgumentParser(
+        description="Spatial Temporal Graph Convolution Network"
+    )
+    parser.add_argument(
+        "--work-dir",
+        default="./work_dir/temp",
+        help="the work folder for storing results",
+    )
+
+    parser.add_argument("-model_saved_name", default="")
+    parser.add_argument(
+        "--config",
+        default="./config/nturgbd-cross-view/test_bone.yaml",
+        help="path to the configuration file",
+    )
+
+    # processor
+    parser.add_argument("--phase", default="train", help="must be train or test")
+
+    # visulize and debug
+    parser.add_argument("--seed", type=int, default=8, help="random seed for pytorch")
+    parser.add_argument(
+        "--log-interval",
+        type=int,
+        default=100,
+        help="the interval for printing messages (#iteration)",
+    )
+    parser.add_argument(
+        "--save-interval",
+        type=int,
+        default=2,
+        help="the interval for storing models (#iteration)",
+    )
+    parser.add_argument(
+        "--eval-interval",
+        type=int,
+        default=5,
+        help="the interval for evaluating models (#iteration)",
+    )
+    parser.add_argument(
+        "--print-log", type=str2bool, default=True, help="print logging or not"
+    )
+    parser.add_argument(
+        "--show-topk",
+        type=int,
+        default=[1, 5],
+        nargs="+",
+        help="which Top K accuracy will be shown",
+    )
+
+    # feeder
+    parser.add_argument(
+        "--feeder", default="feeder.feeder", help="data loader will be used"
+    )
+    parser.add_argument(
+        "--num-worker",
+        type=int,
+        default=32,
+        help="the number of worker for data loader",
+    )
+    parser.add_argument(
+        "--train-feeder-args",
+        default=dict(),
+        help="the arguments of data loader for training",
+    )
+    parser.add_argument(
+        "--test-feeder-args",
+        default=dict(),
+        help="the arguments of data loader for test",
+    )
+
+    # 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(
+        "--weights", default=None, help="the weights for network initialization"
+    )
+    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(
+        "--base-lr", type=float, default=0.01, help="initial learning rate"
+    )
+    parser.add_argument(
+        "--step",
+        type=int,
+        default=[200],
+        nargs="+",
+        help="the epoch where optimizer reduce the learning rate",
+    )
+
+    # training
+    parser.add_argument(
+        "--device",
+        type=int,
+        default=0,
+        nargs="+",
+        help="the indexes of GPUs for training or testing",
+    )
+    parser.add_argument("--optimizer", default="SGD", help="type of optimizer")
+    parser.add_argument(
+        "--nesterov", type=str2bool, default=False, help="use nesterov or not"
+    )
+    parser.add_argument(
+        "--batch-size", type=int, default=256, help="training batch size"
+    )
+    parser.add_argument(
+        "--test-batch-size", type=int, default=256, help="test batch size"
+    )
+    parser.add_argument(
+        "--start-epoch", type=int, default=0, help="start training from which epoch"
+    )
+    parser.add_argument(
+        "--num-epoch", type=int, default=80, help="stop training in which epoch"
+    )
+    parser.add_argument(
+        "--weight-decay", type=float, default=0.0005, help="weight decay for optimizer"
+    )
+    # loss
+    parser.add_argument("--loss", type=str, default="CE", help="loss type(CE or focal)")
+    parser.add_argument(
+        "--label_count_path",
+        default=None,
+        type=str,
+        help="Path to label counts (used in loss weighting)",
+    )
+    parser.add_argument(
+        "---beta",
+        type=float,
+        default=0.9999,
+        help="Hyperparameter for Class balanced loss",
+    )
+    parser.add_argument(
+        "--gamma", type=float, default=2.0, help="Hyperparameter for Focal loss"
+    )
+
+    parser.add_argument("--only_train_part", default=False)
+    parser.add_argument("--only_train_epoch", default=0)
+    parser.add_argument("--warm_up_epoch", default=10)
+
+    parser.add_argument(
+        "--lambda-mil", default=1.0, help="balancing hyper-parameter of mil branch"
+    )
+
+    parser.add_argument(
+        "--class-threshold",
+        type=float,
+        default=0.1,
+        help="class threshold for rejection",
+    )
+    parser.add_argument(
+        "--start-threshold",
+        type=float,
+        default=0.03,
+        help="start threshold for action localization",
+    )
+    parser.add_argument(
+        "--end-threshold",
+        type=float,
+        default=0.055,
+        help="end threshold for action localization",
+    )
+    parser.add_argument(
+        "--threshold-interval",
+        type=float,
+        default=0.005,
+        help="threshold interval for action localization",
+    )
+    parser.add_argument(
+        "--knn_k",
+        type=float,
+        default=50,
+        help="threshold interval for action localization",
+    )
+    parser.add_argument(
+        "--knn_t",
+        type=float,
+        default=0.1,
+        help="threshold interval for action localization",
+    )
+    return parser
+
+
+class Processor:
+    """
+    Processor for Skeleton-based Action Recgnition
+    """
+
+    def __init__(self, arg):
+        self.arg = arg
+        self.save_arg()
+        if arg.phase == "train":
+            if not arg.train_feeder_args["debug"]:
+                if os.path.isdir(arg.model_saved_name):
+                    print("log_dir: ", arg.model_saved_name, "already exist")
+                    # answer = input('delete it? y/n:')
+                    answer = "y"
+                    if answer == "y":
+                        print("Deleting dir...")
+                        shutil.rmtree(arg.model_saved_name)
+                        print("Dir removed: ", arg.model_saved_name)
+                        # input('Refresh the website of tensorboard by pressing any keys')
+                    else:
+                        print("Dir not removed: ", arg.model_saved_name)
+                self.train_writer = SummaryWriter(
+                    os.path.join(arg.model_saved_name, "train"), "train"
+                )
+                self.val_writer = SummaryWriter(
+                    os.path.join(arg.model_saved_name, "val"), "val"
+                )
+            else:
+                self.train_writer = self.val_writer = SummaryWriter(
+                    os.path.join(arg.model_saved_name, "test"), "test"
+                )
+        self.global_step = 0
+        self.load_model()
+        self.load_optimizer()
+        self.load_data()
+        self.lr = self.arg.base_lr
+        self.best_acc = 0
+        self.best_per_class_acc = 0
+        self.loss_nce = torch.nn.BCELoss()
+
+        self.my_logger = Logger(
+            os.path.join(arg.model_saved_name, "log.txt"), title="SWTAL"
+        )
+        self.my_logger.set_names(["Step", "cmap"] + [f"map_0.{i}" for i in range(1, 6)]+["avg"])
+
+    def load_data(self):
+        Feeder = import_class(self.arg.feeder)
+        self.data_loader = dict()
+        if self.arg.phase == "train":
+            self.data_loader["train"] = torch.utils.data.DataLoader(
+                dataset=Feeder(**self.arg.train_feeder_args),
+                batch_size=1,
+                shuffle=True,
+                num_workers=self.arg.num_worker,
+                drop_last=True,
+                collate_fn=collate_with_padding_multi_joint,
+            )
+        self.data_loader["test"] = torch.utils.data.DataLoader(
+            dataset=Feeder(**self.arg.test_feeder_args),
+            batch_size=self.arg.test_batch_size,
+            shuffle=False,
+            num_workers=self.arg.num_worker,
+            drop_last=False,
+            collate_fn=collate_with_padding_multi_joint,
+        )
+
+    def load_model(self):
+        output_device = (
+            self.arg.device[0] if type(self.arg.device) is list else self.arg.device
+        )
+        self.output_device = output_device
+        Model = import_class(self.arg.model)
+
+        shutil.copy2(inspect.getfile(Model), self.arg.work_dir)
+        # print(Model)
+        self.model = Model(**self.arg.model_args).cuda(output_device)
+
+        self.loss_type = arg.loss
+
+        if self.arg.weights:
+            self.print_log("Load weights from {}.".format(self.arg.weights))
+            if ".pkl" in self.arg.weights:
+                with open(self.arg.weights, "r") as f:
+                    weights = pickle.load(f)
+            else:
+                weights = torch.load(self.arg.weights)
+
+            weights = OrderedDict(
+                [
+                    [k.split("module.")[-1], v.cuda(output_device)]
+                    for k, v in weights.items()
+                ]
+            )
+            # print(weights.keys())
+            if 'unik' not in self.arg.model:
+                print('this is agcn')
+                weights = remove_prefix_from_state_dict(weights, 'encoder_q.agcn.')
+            
+            if 'unik' in self.arg.model:
+                print('this is unik')
+                weights = remove_prefix_from_state_dict(weights, 'encoder_q.unik.')
+            
+            
+            self.arg.ignore_weights = ['data_bn','fc','encoder_q','encoder_k','queue','queue_ptr','value_transform','mask_param']
+            
+            keys = list(weights.keys())
+            
+            for w in self.arg.ignore_weights:
+                for key in keys:
+                    if w in key:
+                        if weights.pop(key, None) is not None:
+                            continue
+                        #     self.print_log(
+                        #         "Sucessfully Remove Weights: {}.".format(key)
+                        #     )
+                        # else:
+                        #     self.print_log("Can Not Remove Weights: {}.".format(key))
+
+            try:
+                self.model.load_state_dict(weights)
+            except:
+                state = self.model.state_dict()
+                # print(state.keys())
+                diff = list(set(state.keys()).difference(set(weights.keys())))
+                print("Can not find these weights:")
+                for d in diff:
+                    print("  " + d)
+                state.update(weights)
+                self.model.load_state_dict(state)
+
+        if type(self.arg.device) is list:
+            if len(self.arg.device) > 1:
+                self.model = nn.DataParallel(
+                    self.model, device_ids=self.arg.device, output_device=output_device
+                )
+
+    def load_optimizer(self):
+        if self.arg.optimizer == "SGD":
+            self.optimizer = optim.SGD(
+                self.model.parameters(),
+                lr=self.arg.base_lr,
+                momentum=0.9,
+                nesterov=self.arg.nesterov,
+                weight_decay=self.arg.weight_decay,
+            )
+        elif self.arg.optimizer == "Adam":
+            self.optimizer = optim.Adam(
+                self.model.parameters(),
+                lr=self.arg.base_lr,
+                weight_decay=self.arg.weight_decay,
+            )
+        else:
+            raise ValueError()
+
+    def save_arg(self):
+        # save arg
+        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 adjust_learning_rate(self, epoch):
+        if self.arg.optimizer == "SGD" or self.arg.optimizer == "Adam":
+            if epoch < self.arg.warm_up_epoch:
+                lr = self.arg.base_lr * (epoch + 1) / self.arg.warm_up_epoch
+            else:
+                lr = self.arg.base_lr * (
+                    0.1 ** np.sum(epoch >= np.array(self.arg.step))
+                )
+            for param_group in self.optimizer.param_groups:
+                param_group["lr"] = lr
+
+            return lr
+        else:
+            raise ValueError()
+
+    def print_time(self):
+        localtime = time.asctime(time.localtime(time.time()))
+        self.print_log("Local current time :  " + localtime)
+
+    def print_log(self, str, print_time=True):
+        if print_time:
+            localtime = time.asctime(time.localtime(time.time()))
+            str = "[ " + localtime + " ] " + str
+        print(str)
+        if self.arg.print_log:
+            with open("{}/print_log.txt".format(self.arg.work_dir), "a") as f:
+                print(str, file=f)
+
+    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
+
+    @torch.no_grad()
+    def build_feature_bank(self):
+        self.model.eval()
+        self.print_log("Building feature bank...")
+
+        loader = self.data_loader["train"]
+        process = tqdm(self.data_loader['train'])
+
+        feature_bank = []
+        feature_labels = []
+
+        for batch_idx, (data, label, target, mask, index, soft_label) in enumerate(process):
+            data = data.float().cuda(self.output_device)
+            target = target.cuda(self.output_device)  # [N, T]
+
+            # 1. 提取特征
+            feat = self.model(data)            # [N, T, C]
+            feat = F.normalize(feat, dim=-1)   # 建议归一化
+            feat = feat.reshape(-1, feat.size(-1))   # [N*T, C]
+
+            # 2. 标签展平
+            label_flat = target.view(-1)       # [N*T]
+
+            feature_bank.append(feat)
+            feature_labels.append(label_flat)
+
+        # 3. 合并所有帧
+        feature_bank = torch.cat(feature_bank, dim=0)     # [N_total*T, C]
+        feature_labels = torch.cat(feature_labels, dim=0) # [N_total*T]
+
+        self.feature_bank = feature_bank
+        self.feature_labels = feature_labels
+
+        self.print_log(f"Feature bank size: {feature_bank.shape}")
+        self.print_log(f"Label bank size: {feature_labels.shape}")
+
+    @torch.no_grad()
+    def eval(
+        self,
+        epoch,
+        wb_dict,
+        loader_name=["test"],
+    ):
+        self.model.eval()
+        self.print_log("Eval epoch: {}".format(epoch + 1))
+
+        vid_preds = []
+        frm_preds = []
+        vid_lens = []
+        labels = []
+
+        for ln in loader_name:
+            loss_value = []
+            step = 0
+            process = tqdm(self.data_loader[ln])
+
+            for batch_idx, (data, label, target, mask, index, soft_label) in enumerate(
+                process
+            ):
+                data = data.float().cuda(self.output_device)
+                label = label.cuda(self.output_device)
+                mask = mask.cuda(self.output_device)
+
+                ab_labels = torch.cat([label, torch.ones(label.size(0), 1).cuda()], -1)
+
+                # forward
+                with torch.no_grad():
+                    features = self.model(data)           # shape: [N, T, C_feat]
+                    features = F.normalize(features, dim=-1)  # 单位化（建议）
+
+                    n, t, c = features.shape
+                    features_flat = features.view(n * t, c)  # shape: [N*T, C_feat]
+                    # 使用 knn_predict（你贴的函数）
+                    pred_scores = knn_predict(
+                        features_flat,         # [N*T, C_feat]
+                        self.feature_bank.T,   # [C_feat, N_bank*T]
+                        self.feature_labels,   # [N_bank*T]
+                        classes=5,             # 根据你的任务类别数
+                        knn_k=self.arg.knn_k ,
+                        knn_t=self.arg.knn_t
+                    )  # 输出 [N*T, topk]，取 [:, 0] 是 top-1
+
+                    # pred_top1 = pred_labels[:, 0]  # [N*T]
+                    # # 变为 one-hot logits，模拟 frm_scrs 原始格式
+                    # frm_scrs_re = F.one_hot(pred_top1, num_classes=5).float()  # [N*T, C]
+                    # frm_scrs = frm_scrs_re.view(n, t, -1)  # [N, T, C]
+                    frm_scrs = pred_scores.view(n, t, -1)  # [N, T, C]
+
+
+                '''Loc LOSS'''
+                target = target.cuda(self.output_device)
+                ''' into one hot'''
+                ground_truth_flat = target.view(-1)  
+                one_hot_ground_truth = F.one_hot(ground_truth_flat, num_classes=5)
+                ''' into one hot'''
+                frm_scrs_re = rearrange(frm_scrs, "n t c -> (n t) c")
+                '''Loc LOSS'''
+                '''Loc LOSS'''
+                loss = cross_entropy_loss(
+                    frm_scrs_re, one_hot_ground_truth
+                ) 
+                '''Loc LOSS'''
+
+                loss_value.append(loss.data.item())
+
+                for i in range(data.size(0)):
+                    frm_scr = frm_scrs[i]
+
+                    label_ = label[i].cpu().numpy()
+                    mask_ = mask[i].cpu().numpy()
+                    vid_len = mask_.sum()
+
+                    frm_pred = F.softmax(frm_scr, -1).cpu().numpy()[:vid_len]
+                    # vid_pred = vid_pred.cpu().numpy()
+
+                    vid_pred = 0
+                    vid_preds.append(vid_pred)
+                    frm_preds.append(frm_pred)
+                    vid_lens.append(vid_len)
+                    labels.append(label_)
+
+                step += 1
+
+            vid_preds = np.array(vid_preds)
+            frm_preds = np.array(frm_preds)
+            vid_lens = np.array(vid_lens)
+            labels = np.array(labels)
+
+            # cmap = cmAP(vid_preds, labels)
+            cmap = 0
+            score = cmap
+            loss = np.mean(loss_value)
+
+            
+            dmap, iou = dsmAP(
+                vid_preds,
+                frm_preds,
+                vid_lens,
+                self.arg.test_feeder_args["data_path"],
+                self.arg,
+                multi=True,
+                knn=True
+            )
+
+            for iou_val, dmap_val in zip(iou, dmap):
+                if isinstance(dmap_val, list):
+                    try:
+                        score_strs = []
+                        for v in dmap_val:
+                            if isinstance(v, (int, float, np.float32, np.float64)):
+                                score_strs.append("%.2f" % (100 * v))
+                            else:
+                                score_strs.append("n/a")
+                        score_str = ", ".join(score_strs)
+                    except Exception as e:
+                        score_str = "ERROR: " + str(e)
+                else:
+                    score_str = "%.2f" % (100 * dmap_val)
+                mAP = "%.2f" % (100 * np.mean(dmap_val))
+                print("Detection map @ %.1f = %s" % (iou_val, score_str))
+                self.print_log("Detection map @ %.1f = %s" % (iou_val, score_str))
+                self.print_log("Detection map @ %.1f = %s" % (iou_val, mAP))
+            
+            flat_dmap = []
+            for x in dmap:
+                if isinstance(x, list):
+                    flat_dmap.extend(x)
+                else:
+                    flat_dmap.append(x)
+            dmap = flat_dmap
+
+            print("Avg mAP %.2f" % (100 * np.mean(dmap)))
+            self.print_log("Avg mAP %.2f"% (100 * np.mean(dmap)))
+
+
+            wb_dict["val loss"] = loss
+            wb_dict["val acc"] = score
+
+            if score > self.best_acc:
+                self.best_acc = score
+
+            print("Acc score: ", score, " model: ", self.arg.model_saved_name)
+            if self.arg.phase == "train":
+                self.val_writer.add_scalar("loss", loss, self.global_step)
+                self.val_writer.add_scalar("acc", score, self.global_step)
+
+            self.print_log(
+                "\tMean {} loss of {} batches: {}.".format(
+                    ln, len(self.data_loader[ln]), np.mean(loss_value)
+                )
+            )
+            self.print_log("\tAcc score: {:.3f}%".format(score))
+
+        return wb_dict,  np.mean(dmap)
+
+    def start(self):
+        best_map = 0
+        best_epoch = 0
+        wb_dict = {}
+
+        
+        self.build_feature_bank()
+        wb_dict,map = self.eval(0, wb_dict, loader_name=["test"])
+        if map>best_map:
+            best_map = map
+            best_epoch = 0
+        # Log stats. for this epoch
+        print("Epoch: {0}\nMetrics: {1}".format(0, wb_dict))
+            
+
+
+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.")
+
+def knn_predict(feature, feature_bank, feature_labels, classes, knn_k, knn_t):
+    # compute cos similarity between each feature vector and feature bank ---> [B, N]
+    sim_matrix = torch.mm(feature, feature_bank)
+    # [B, K]
+    sim_weight, sim_indices = sim_matrix.topk(k=knn_k, dim=-1)
+    # [B, K]
+    sim_labels = torch.gather(feature_labels.expand(feature.size(0), -1), dim=-1, index=sim_indices)
+    sim_weight = (sim_weight / knn_t).exp()
+
+    # counts for each class
+    one_hot_label = torch.zeros(feature.size(0) * knn_k, classes, device=sim_labels.device)
+    # [B*K, C]
+    one_hot_label = one_hot_label.scatter(dim=-1, index=sim_labels.view(-1, 1), value=1.0)
+    # weighted score ---> [B, C]
+    pred_scores = torch.sum(one_hot_label.view(feature.size(0), -1, classes) * sim_weight.unsqueeze(dim=-1), dim=1)
+
+    pred_labels = pred_scores.argsort(dim=-1, descending=True)
+    # return pred_labels
+    return pred_scores
+
+
+def import_class(name):
+    components = name.split(".")
+    mod = __import__(components[0])
+    for comp in components[1:]:
+        mod = getattr(mod, comp)
+    return mod
+
+
+if __name__ == "__main__":
+    parser = get_parser()
+
+    # load arg form config file
+    p = parser.parse_args()
+    if p.config is not None:
+        with open(p.config, "r") as f:
+            default_arg = yaml.safe_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
+        parser.set_defaults(**default_arg)
+
+    arg = parser.parse_args()
+    print("BABEL Action Recognition")
+    print("Config: ", arg)
+    init_seed(arg.seed)
+    processor = Processor(arg)
+    processor.start()