pybaseutils 2.1.3__tar.gz → 2.1.4__tar.gz

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybaseutils
-Version: 2.1.3
+Version: 2.1.4
 Summary: pybaseutils
 Home-page: https://github.com/PanJinquan/base-utils
 Author: PanJinquan

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/__init__.py

@@ -5,4 +5,4 @@
     @Date   : 2019-05-07 17:40:27
 """
 
-__version__ = '2.1.3'
+__version__ = '2.1.4'

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/cvutils/video_utils.py

@@ -13,7 +13,7 @@ from tqdm import tqdm
 from pybaseutils import image_utils, file_utils
 from pybaseutils.cvutils import monitor
 
-VIDEO_POSTFIX = ['*.mp4', '*.avi', '*.mov']
+VIDEO_POSTFIX = ['*.mp4', '*.avi', '*.mov', "*.flv"]
 
 get_video_capture = image_utils.get_video_capture
 get_video_info = image_utils.get_video_info

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/dataloader/data_resample.py

@@ -12,7 +12,7 @@ import math
 class ResampleExample(object):
     """样本均衡，重采样DataResampler的使用方法"""
 
-    def __init__(self, item_list, label_index=1, shuffle=True, disp=False):
+    def __init__(self, item_list, label_index, shuffle=True, disp=False):
         """
         :param item_list: item_list=[item_0,item_1,...,item_n],
                           item_n= [path/to/image,label]
@@ -28,14 +28,14 @@ class ResampleExample(object):
                                       disp=self.disp)
 
     def __len__(self):
+        print("start resampler, data will shuffle and update")
         # 更新resampler，实现每个epoch重新采样，避免样本数比较多的类别，没有加入训练
         self.item_list = self.resampler.update(self.shuffle)
         return len(self.item_list)
 
-    def __getitem__(self, idx):
-        image_path = self.item_list[idx][0]
-        label_id = self.item_list[idx][1]
-        return image_path, label_id
+    def __getitem__(self, index):
+        data_info = self.item_list[index]
+        return data_info
 
 
 class DataResample(object):
@@ -195,9 +195,71 @@ class DataResample(object):
         return class_weight
 
 
+class DataLabelResample(object):
+    """样本均衡，重采样的方法"""
+
+    def __init__(self, data, label, balance="mean", shuffle=True, disp=False):
+        """
+        Usage:
+        参考：ResampleExample例子的使用方法
+        :param item_list:
+        :param label_index:
+        :param balance:实现样本均衡策略,均衡力度：mean > log > sqrt > y
+                        "y": 每个label样本数跟原来一样
+                        "sqrt": 每个label样本取sqrt数，实现样本均衡
+                        "log": 每个label样本取log数，实现样本均衡
+                        "mean": 每个label样本取样本平均数，每个label的个数一样
+        """
+        self.shuffle = shuffle
+        self.item_list = list(zip(data, label))
+        self.resample = DataResample(item_list=self.item_list, label_index=1, balance=balance,
+                                     shuffle=shuffle, disp=disp)
+
+    def __len__(self):
+        data, label = self.update(shuffle=self.shuffle)
+        return len(data)
+
+    def update(self, shuffle=False):
+        item_list = self.resample.update(shuffle=shuffle)
+        data = [item[0] for item in item_list]
+        label = [item[1] for item in item_list]
+        return data, label
+
+
+def get_class_count(item_list, label_index):
+    """
+    统计每个类别的个数
+    :param item_list: List[list,list]
+    :param label_index: label在item中的序号
+    :return:
+    """
+    count_info = {}
+    for item in item_list:
+        label = item[label_index]
+        try:
+            # if label in class_count:  # 比较慢，相当于需要查询label是否存在
+            count_info[label] += 1
+        except Exception as e:
+            count_info[label] = 1
+    return count_info
+
+
+def get_label_count(label):
+    """
+    统计每个类别的个数
+    :param label: [int,int,...]
+    :return:
+    """
+    count = np.bincount(label).tolist()
+    label = list(range(max(count)))
+    count_info = {l: c for l, c in zip(label, count) if c > 0}
+    return count_info
+
+
 if __name__ == "__main__":
+    from tqdm import tqdm
     from torch.utils.data import Dataset, DataLoader, Sampler
-    from utils import torch_tools
+    from basetrainer.utils import torch_tools
 
     torch_tools.set_env_random_seed()
     label0 = [["0.1.jpg", 0], ["0.2.jpg", 0], ["0.3.jpg", 0]]
@@ -206,15 +268,16 @@ if __name__ == "__main__":
               ["2.5.jpg", 2], ["2.6.jpg", 2], ["2.7.jpg", 2], ["2.8.jpg", 2]]
     label3 = [["3.1.jpg", 3], ["3.2.jpg", 3], ["3.3.jpg", 3]]
     item_list = label0 + label1 + label2 + label3
-    item_list = item_list * 1000000
+    item_list = item_list * 1
+    item_list = [{"file": item[0], "label": item[1]} for item in item_list]
     print("have item_list:{}".format(len(item_list)))
-    dataset_train = ResampleExample(item_list=item_list, label_index=1, shuffle=True, disp=True)
+    dataset_train = ResampleExample(item_list=item_list, label_index="label", shuffle=True, disp=True)
     # dataset_train = ResampleExample(item_list=item_list, label_index=1, disp=False)
     # dataset_train = ResampleExample(item_list=item_list, label_index=1, disp=False)
-    batch_size = 4
+    batch_size = 20
     dataloader = DataLoader(dataset_train, batch_size, num_workers=0)
     epochs = 2
     for epoch in range(epochs):
         print("{}===".format(epoch) * 10)
-        for batch_image, batch_label in iter(dataloader):
-            print(batch_image, batch_label)
+        for step, data in enumerate(tqdm(dataloader)):
+            print(step, data)

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/dataloader/parser_image_folder.py

@@ -19,13 +19,14 @@ class FolderDataset(parser_image_text.TextDataset):
     def __init__(self, image_dir, class_name=None, transform=None, use_rgb=False, shuffle=False,
                  phase="test", disp=False, check=False, **kwargs):
         """
+        文件夹数据集，要求相同类别的数据放在同一个文件夹，文件名为类别名称
         :param image_dir: [image_dir]->list or `path/to/image_dir`->str
-        :param class_name:
+        :param class_name: 类别文件/列表/字典
         :param transform: torch transform
         :param shuffle:
         :param disp:
         """
-        super(FolderDataset, self).__init__(filename=image_dir,
+        super(FolderDataset, self).__init__(data_file=image_dir,
                                             data_root=None,
                                             class_name=class_name,
                                             transform=transform,
@@ -41,35 +42,24 @@ class FolderDataset(parser_image_text.TextDataset):
         :param index:
         :return: {"image": image, "label": label}
         """
-        item = self.item_list[index]
-        bbox = item[2:] if len(item) == 6 else []
-        image_file, label = item[0], item[1]
-        image = self.read_image(image_file, use_rgb=self.use_rgb)
-        image = self.crop_image(image, bbox=bbox) if bbox else image
-        if self.transform:
-            image = Image.fromarray(image)
-            image = self.transform(image)
-        if image is None:
-            index = int(random.uniform(0, self.num_images))
-            return self.__getitem__(index)
-        return {"image": image, "label": label}
+        return super(FolderDataset, self).__getitem__(index)
 
-    def load_dataset(self, filename, data_root="", use_sub=False):
+    def load_dataset(self, data_file, data_root="", use_sub=False):
         """
         保存格式：[path,label] 或者 [path,label,xmin,ymin,xmax,,ymax]
-        :param filename:
+        :param data_file:
         :param data_root:
-        :return: item_list [path,label] 或者 [path,label,xmin,ymin,xmax,,ymax]
+        :return: item_list [{"file":file,"label":label}]
         """
-        if isinstance(filename, str): filename = [filename]
+        if isinstance(data_file, str): data_file = [data_file]
         item_list = []
-        for i, dir in enumerate(filename):
-            print("loading image from:{}".format(dir))
+        for i, dir in enumerate(data_file):
             if not os.path.exists(dir): raise Exception("文件不存在，image_dir:{}".format(dir))
             paths, labels = file_utils.get_files_labels(dir, postfix=file_utils.IMG_POSTFIX)
+            print("loading data from:{},have {}".format(dir, len(paths)))
             # TODO # 避免多个数据集的相同的label
             if use_sub:  labels = [os.path.join(str(i), l) for l in labels]
-            data = [[p, l] for p, l in zip(paths, labels)]
+            data = [{"file": p, "label": l} for p, l in zip(paths, labels)]
             item_list += data
         return item_list
 

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/dataloader/parser_image_text.py

@@ -23,12 +23,13 @@ from pybaseutils.dataloader import data_resample
 
 class TextDataset(Dataset):
 
-    def __init__(self, filename, data_root=None, class_name=None, transform=None, shuffle=False, use_rgb=False,
+    def __init__(self, data_file, data_root=None, class_name=None, transform=None, shuffle=False, use_rgb=False,
                  phase="test", disp=False, check=False, **kwargs):
         """
-        :param filename:
-        :param data_root:
-        :param class_name:
+        数据文件保存格式：[path,label] 或者 [path,label,xmin,ymin,xmax,ymax]
+        :param data_file: 数据文件路径，List[str] or str
+        :param data_root: 数据文件根目录
+        :param class_name: 类别文件/列表/字典
         :param transform:
         :param shuffle:
         :param use_rgb:
@@ -41,18 +42,21 @@ class TextDataset(Dataset):
         self.use_rgb = use_rgb
         self.transform = transform
         self.phase = phase
+        self.label_index = kwargs.get("label_index", "label")  # 类别字段key
         self.class_name, self.class_dict = self.parser_classes(class_name)
-        self.item_list = self.parser_dataset(filename, data_root=data_root, shuffle=shuffle, check=check)
+        self.item_list = self.parser_dataset(data_file, data_root=data_root, label_index=self.label_index,
+                                             shuffle=shuffle, check=check)
         self.resample = kwargs.get("resample", False)
         if self.resample:
             self.data_resample = data_resample.DataResample(self.item_list,
-                                                            label_index=1,
+                                                            label_index=self.label_index,
                                                             shuffle=shuffle,
                                                             disp=disp)
             self.item_list = self.data_resample.update(True)
             class_count = self.data_resample.class_count  # resample前，每个类别的分布
             balance_nums = self.data_resample.balance_nums  # resample后，每个类别的分布
-        self.class_count = self.count_class_info(self.item_list, class_name=self.class_name)
+        self.class_count = self.count_class_info(self.item_list, class_name=self.class_name,
+                                                 label_index=self.label_index)
         self.num_images = len(self.item_list)
         self.classes = list(self.class_dict.values())
         self.num_classes = max(self.classes) + 1
@@ -81,46 +85,53 @@ class TextDataset(Dataset):
             print("loss_labels: {}".format(class_lack))
         print("------------------------------------------------------------------")
 
-    def parser_dataset(self, filename, data_root="", shuffle=False, check=False):
+    def parser_dataset(self, data_file, data_root="", label_index="label", shuffle=False, check=False):
         """
         保存格式：[path,label] 或者 [path,label,xmin,ymin,xmax,ymax]
-        :param filename:
+        :param data_file:
         :param data_root:
+        :param label_index: label index
         :param shuffle:
         :param check:
         :return:
         """
-        data_list = self.load_dataset(filename, data_root=data_root)
+        data_list = self.load_dataset(data_file, data_root=data_root)
         if not self.class_name:
-            self.class_name = list(set([d[1] for d in data_list]))
+            self.class_name = list(set([d[label_index] for d in data_list]))
             self.class_name, self.class_dict = self.parser_classes(self.class_name)
         item_list = []
         for data in data_list:
-            label = data[1]
+            label = data[label_index]
             if label not in self.class_dict: continue
-            data[1] = self.class_dict[label]
+            data[label_index] = self.class_dict[label]
             item_list.append(data)
         if check: item_list = self.check_item(item_list)
         assert self.class_name, f"类别为空，请检查，class_name={self.class_name}"
-        assert item_list, f"文件列表为空，请检查输入数据，filename={filename}"
+        assert item_list, f"文件列表为空，请检查输入数据，data_file={data_file}"
         if shuffle:
             random.seed(100)
             random.shuffle(item_list)
         return item_list
 
-    def load_dataset(self, filename, data_root=""):
+    def load_dataset(self, data_file, data_root="", **kwargs):
         """
         保存格式：[path,label] 或者 [path,label,xmin,ymin,xmax,ymax]
-        :param filename:
+        :param data_file:
         :param data_root:
-        :return: [path,label] 或者 [path,label,xmin,ymin,xmax,ymax]
+        :return: item_list [{"file":file,"label":label},"bbox":[]]
         """
-        if isinstance(filename, str): filename = [filename]
+        if isinstance(data_file, str): data_file = [data_file]
         item_list = []
-        for file in filename:
+        for file in data_file:
             root = data_root if data_root else os.path.dirname(file)
-            data = file_utils.read_data(file, split=",")
-            data = [[os.path.join(root, d[0])] + d[1:] for d in data]
+            content = file_utils.read_data(file, split=",")
+            data = []
+            for line in content:
+                if len(line) == 2:
+                    data.append({"file": os.path.join(root, line[0]), "label": line[1]})
+                elif len(line) == 6:
+                    data.append({"file": os.path.join(root, line[0]), "label": line[1], "bbox": line[2:]})
+            print("loading data from:{},have {}".format(file, len(data)))
             item_list += data
         return item_list
 
@@ -148,7 +159,7 @@ class TextDataset(Dataset):
         dst_list = []
         print("Please wait, it's in checking")
         for item in tqdm(item_list):
-            file, label = item[0], item[1]
+            file, label, bbox = item["file"], item[self.label_index], item.get("bbox", [])
             if not os.path.exists(file):
                 print("no file:{}".format(file))
                 continue
@@ -162,9 +173,8 @@ class TextDataset(Dataset):
         :return: {"image": image, "label": label}
         """
         item = self.item_list[index]
-        bbox = item[2:] if len(item) == 6 else []
-        image_file, label = item[0], item[1]
-        image = self.read_image(image_file, use_rgb=self.use_rgb)
+        file, label, bbox = item["file"], item[self.label_index], item.get("bbox", [])
+        image = self.read_image(file, use_rgb=self.use_rgb)
         image = self.crop_image(image, bbox=bbox, **self.kwargs) if bbox else image
         if self.transform:
             image = Image.fromarray(image)
@@ -172,7 +182,7 @@ class TextDataset(Dataset):
         if image is None:
             index = int(random.uniform(0, self.num_images))
             return self.__getitem__(index)
-        return {"image": image, "label": label}
+        return {"image": image, "label": label, "file": file}
 
     def __len__(self):
         if self.resample:
@@ -226,17 +236,17 @@ class TextDataset(Dataset):
         return image
 
     @staticmethod
-    def count_class_info(item_list, class_name=None, index=1):
+    def count_class_info(item_list, class_name=None, label_index="label"):
         """
         统计类别信息
-        item_list=[[filename,label,...],[filename,label,...]]
+        item_list=[[file,label,...],[file,label,...]]
         :param item_list:
         :param class_name:
         :return:
         """
         count = {}
         for item in item_list:
-            label = item[index]
+            label = item[label_index]
             count[label] = count[label] + 1 if label in count else 1
         if class_name: count = {class_name[k]: v for k, v in count.items()}
         return count
@@ -246,8 +256,8 @@ if __name__ == '__main__':
     from pybaseutils import image_utils
     from torchvision import transforms
 
-    filenames = [
-        '/home/PKing/nasdata/tmp/tmp/RealFakeFace/anti-spoofing-images-v1/train.txt',
+    data_files = [
+        '/home/PKing/nasdata/tmp/tmp/RealFakeFace/anti-spoofing-images-v2/train.txt',
     ]
     class_name = None
     input_size = [112, 112]
@@ -258,18 +268,20 @@ if __name__ == '__main__':
         transforms.ToTensor(),
         transforms.Normalize(mean=rgb_mean, std=rgb_std),
     ])
-    dataset = TextDataset(filename=filenames,
+    class_name = ['fake', 'real']
+    dataset = TextDataset(data_file=data_files,
                           transform=transform,
                           class_name=class_name,
-                          resample=False,
+                          resample=True,
                           shuffle=True,
+                          check=False,
                           crop_scale=(1.5, 1.5),
                           disp=True)
     for i in range(len(dataset)):
         data_info = dataset.__getitem__(i)
-        image, label = data_info["image"], data_info["label"]
+        image, label, file = data_info["image"], data_info["label"], data_info["file"]
         image = np.asarray(image).transpose(1, 2, 0)  # 通道由[c,h,w]->[h,w,c]
         image = np.asarray(image * 255, dtype=np.uint8)
         label = np.asarray(label, dtype=np.int32)
-        print("batch_image.shape:{},batch_label:{}".format(image.shape, label))
+        print("{},batch_image.shape:{},batch_label:{}".format(file, image.shape, label))
         image_utils.cv_show_image("image", image)

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/file_utils.py

@@ -24,7 +24,7 @@ from datetime import datetime
 from tqdm import tqdm
 
 IMG_POSTFIX = ['*.jpg', '*.jpeg', '*.png', '*.tif', "*.JPG", "*.bmp"]
-VIDEO_POSTFIX = ['*.mp4', '*.avi', '*.mov']
+VIDEO_POSTFIX = ['*.mp4', '*.avi', '*.mov', "*.flv"]
 
 
 def str2bool(v):

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/image_utils.py

@@ -380,19 +380,19 @@ def image_unnormalize(image, mean=None, std=None):
 image_unnormalization = image_unnormalize
 
 
-def data_unnormalize(data, omin, omax, imin=None, imax=None):
-    """
-    NORMALIZATION 将数据x归一化到任意区间[ymin,omax]范围的方法
-    :param data:  输入参数x：需要被归一化的数据,numpy
-    :param omin: 输入参数omin：归一化的区间[omin,omax]下限
-    :param omax: 输入参数ymax：归一化的区间[omin,omax]上限
-    :param imin: 输入参数imin的最小值
-    :param imax: 输入参数ymax的最大值
+def data_normalize(x, ymin=0, ymax=1.0, xmin=None, xmax=None):
+    """
+    NORMALIZATION 将数据x归一化到任意区间[ymin,ymax]范围的方法
+    :param x:  输入参数x：需要被归一化的数据,numpy
+    :param ymin: 输入参数ymin：归一化的区间[ymin,ymax]下限
+    :param ymax: 输入参数ymax：归一化的区间[ymin,ymax]上限
+    :param xmin: 输入参数xmin的最小值
+    :param xmax: 输入参数xmax的最大值
     :return: 输出参数y：归一化到区间[omin,omax]的数据
     """
-    imax = imax if imax is not None else np.max(data)  # %计算最大值
-    imin = imin if imin is not None else np.min(data)  # %计算最小值
-    y = (omax - omin) * (data - imin) / (imax - imin) + omin
+    xmax = np.max(x) if xmax is None else xmax  # %计算最大值
+    xmin = np.min(x) if xmin is None else xmin  # %计算最小值
+    y = (ymax - ymin) * (x - xmin) / (xmax - xmin) + ymin
     return y
 
 

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils/plot_utils.py

@@ -106,7 +106,50 @@ def plot_bar(x, y, xlabel="X", ylabel="Y", title="bar", bin_width=1, vis=True, s
     if vis: plt.savefig('out.png')
 
 
-def plot_multi_line(x_data_list, y_data_list, line_names=None, title="", xlabel="", ylabel=""):
+def plot_line(x, y, name=None, title="", xlabel="", ylabel="", color="b"):
+    """
+    :param x: List[]
+    :param y: List[]
+    :param names: List[]
+    :param title:
+    :param xlabel:
+    :param ylabel:
+    :return:
+    """
+    # 绘图
+    # plt.figure()
+    if x is None: x = list(range(0, len(y)))
+    lw = 2
+    plt.figure(figsize=(10, 10))
+    plt.plot(x, y, color=color, lw=lw, label=name)  # 假正率为横坐标，真正率为纵坐标做曲线
+    # plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
+    # plt.plot([0, 1], [1, 0], color='navy', lw=lw, linestyle='--')  # 绘制y=1-x的直线
+    # plt.xlim([xlim_min - 0.01 * x_deta, xlim_max + 0.1 * x_deta])
+    # plt.ylim([ylim_min - 0.01 * y_deta, ylim_max + 0.1 * y_deta])
+    # 设置横纵坐标的名称以及对应字体格式
+    font = {'family': 'Times New Roman',
+            'weight': 'normal',
+            'size': 20,
+            }
+    plt.xlabel(xlabel, font)
+    plt.ylabel(ylabel, font)
+    plt.title(title)
+    plt.legend(loc="lower right")  # "upper right"
+    # plt.legend(loc="upper right")#"upper right"
+    plt.grid(True)  # 显示网格;
+    plt.show()
+
+
+def plot_lines(X, Y, names=None, title="", xlabel="", ylabel=""):
+    """
+    :param X: List[List]
+    :param Y: List[List]
+    :param names: List[]
+    :param title:
+    :param xlabel:
+    :param ylabel:
+    :return:
+    """
     # 绘图
     # plt.figure()
     lw = 2
@@ -117,10 +160,9 @@ def plot_multi_line(x_data_list, y_data_list, line_names=None, title="", xlabel=
 
     xlim_min = 0
     ylim_min = 0
-    if not line_names:
-        line_names = " " * len(x_data_list)
-    for x, y, color, line_name in zip(x_data_list, y_data_list, colors, line_names):
-        plt.plot(x, y, color=color, lw=lw, label=line_name)  # 假正率为横坐标，真正率为纵坐标做曲线
+    if not names: names = " " * len(X)
+    for x, y, color, label in zip(X, Y, colors, names):
+        plt.plot(x, y, color=color, lw=lw, label=label)  # 假正率为横坐标，真正率为纵坐标做曲线
         if xlim_max < max(x):
             xlim_max = max(x)
         if ylim_max < max(y):
@@ -150,6 +192,9 @@ def plot_multi_line(x_data_list, y_data_list, line_names=None, title="", xlabel=
     plt.show()
 
 
+plot_multi_line = plot_lines
+
+
 def plot_skew_kurt(data, name="Title"):
     """
     https://blog.csdn.net/u012735708/article/details/84750295

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybaseutils
-Version: 2.1.3
+Version: 2.1.4
 Summary: pybaseutils
 Home-page: https://github.com/PanJinquan/base-utils
 Author: PanJinquan

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/pybaseutils.egg-info/SOURCES.txt

@@ -243,6 +243,10 @@ test_py/registry/base.py
 test_py/registry/component.py
 test_py/registry/main.py
 test_py/registry/register.py
+test_py/single_class/GRU.py
+test_py/single_class/TCN.py
+test_py/single_class/__init__.py
+test_py/single_class/demo.py
 test_py/test_fr/__init__.py
 test_py/test_fr/demo11.py
 test_py/test_fr/idcardocr.py

{pybaseutils-2.1.3 → pybaseutils-2.1.4}/test_py/demo1.py

@@ -49,4 +49,8 @@ class Promote():
 
 
 if __name__ == '__main__':
-    image_file = "/home/PKing/nasdata/dataset-dmai/AIJE/dataset/aije-action-cvlm-v2/第3批数据/aije-action-train-v22/江门_检查工器具_20240910_172411_6606_0000.jpg"
+    data = ["1.jpg", "2.jpg"]
+    label = [0, 1]
+    item_list = list(zip(data, label))
+    item_list = zip()
+    print(item_list)

pybaseutils-2.1.4/test_py/demo_video.py

@@ -0,0 +1,28 @@
+# -*-coding: utf-8 -*-
+"""
+    @Author : PKing
+    @E-mail : 390737991@qq.com
+    @Date   : 2022-12-31 11:37:30
+    @Brief  :
+"""
+import os
+import cv2
+import numpy as np
+from pybaseutils import file_utils, image_utils
+from pybaseutils.cvutils import video_utils
+
+
+def video2frames_demo(root, out):
+    files = file_utils.get_files_lists(root, postfix=file_utils.VIDEO_POSTFIX)
+    print("save:{}".format(out))
+    for video_file in files:
+        print(video_file)
+        # video_utils.video2frames_similarity(video_file, out_dir=out, func=None, interval=20, thresh=0.3, vis=True)
+        video_utils.video2frames(video_file, out_dir=out, func=None, interval=15, vis=True)
+
+
+if __name__ == "__main__":
+    root = "/home/PKing/nasdata/tmp/tmp/RealFakeFace/anti-spoofing-video-v1/test"
+    out = os.path.join(os.path.dirname(root), "frame")
+    out = file_utils.create_dir(out, os.path.basename(root))
+    video2frames_demo(root, out)

pybaseutils-2.1.4/test_py/single_class/GRU.py

@@ -0,0 +1,36 @@
+# -*-coding: utf-8 -*-
+"""
+    @Author : PKing
+    @E-mail :
+    @Date   : 2024-02-05 18:19:18
+    @Brief  : https://tianchi.aliyun.com/notebook/231732
+"""
+import torch
+from torch import nn
+
+
+class ModelGRU(nn.Module):
+    def __init__(self, input_size=1, output_size=4, hidden_size=300):
+        """
+        :param input_size: The number of expected features in the input `x`
+        :param output_size: num_class
+        :param hidden_size: The number of features in the hidden state `h`
+        """
+        super(ModelGRU, self).__init__()
+        self.hidden_layer_size = hidden_size
+        self.lstm = nn.GRU(
+            input_size=input_size,
+            hidden_size=hidden_size,
+            dropout=0.8,
+            batch_first=True
+        )
+        self.linear = nn.Linear(hidden_size, output_size)
+
+    def forward(self, inputs):
+        """
+        :param inputs: shape is (batch,dim-size,1)
+        :return:
+        """
+        r_out, h_c = self.lstm(inputs, None)
+        x = self.linear(r_out[:, -1, :])
+        return x