Upload 54 files

.gitattributes

@@ -57,3 +57,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+picture/annotation.pdf filter=lfs diff=lfs merge=lfs -text
+picture/dataset.pdf filter=lfs diff=lfs merge=lfs -text
+picture/detected-multi-obj.pdf filter=lfs diff=lfs merge=lfs -text

Anchor.py

@@ -0,0 +1,42 @@
+import numpy as np
+
+
+anchor_thetas = [x*0.2094 for x in range(15)]
+# anchor宽
+anchor_w = 85.72
+# anchor高
+anchor_h = 19.15
+# 每个grid cell 的anchor数
+num_anchors = 3
+# 输出层下采样次数
+times_of_down_sampling = 5
+# 输入图像尺寸
+img_size = 416
+# 防止角度偏移量为0
+Anchor_eps = 0.000001
+
+
+field_of_grid_cell = 2 ** times_of_down_sampling
+num_grid_cell = int(img_size / field_of_grid_cell)
+theta_margin = 180 / num_anchors
+
+
+# if __name__ == '__main__':
+#     print(field_of_grid_cell)
+#     print(anchor_thetas)
+#     print(3//0.2094)
+#     a = np.arange(16).reshape((4, 4))
+#     print(33.2%16.4)
+#     a = np.arange(10*26*26*15*6).reshape((10, 26, 26, 15, 6))
+#     b = []
+#     for i in a:
+#         b.append(i)
+#     # b = np.array(b)
+#     print(type(b[0]))
+#     # print(b.shape)
+#     c = np.arange(16).reshape((4, 4))
+#     d = []
+#     for i in c:
+#         d.append(i)
+#     print(d)
+#     print(np.array(d))

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 kimitlte
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,124 @@
----
-license: apache-2.0
----
+This is the repository for the **NBMOD** (Noisy Background Multi-Object Dataset for grasp detection) and the code of the paper [***NBMOD: Find It and Grasp It in Noisy Background***](https://arxiv.org/abs/2306.10265).
+
+
+# Introduction
+We propose a dataset called **NBMOD** (Noisy Background Multi-Object Dataset for grasp detection) consisting of **31,500 RGB-D images**, which is composed of three subsets: Simple background Single-object Subset (**SSS**), Noisy background Single-object Subset (**NSS**), and Multi-Object grasp detection Subset (**MOS**). Among them, the SSS subset consists of 13,500 images, the NSS subset consists of 13,000 images, and the MOS subset consists of 5,000 images.
+
+Unlike the renowned Cornell dataset, the NBMOD dataset differs in that its backgrounds are no longer simple whiteboards. The NSS and MOS subsets comprise a substantial number of images with noise, where this noise corresponds to interfering objects unrelated to the target objects for grasping detection. Moreover, in the MOS subset, each image encompasses multiple target objects for grasp detection, which closely resembles real-world working environments.
+
+To enhance the task of grasp detection, we propose a novel mechanism called **RAM** (Rotation Anchor Mechanism) and design three detection network architectures: **RARA** (network with Rotation Anchor and Region Attention), **RAST** (network with Rotation Anchor and Semi Transformer), and **RAGT** (network with Rotation Anchor and Global Transformer). These architectures aim to improve the accuracy and robustness of grasp detection by incorporating rotation anchor-based methods and attention mechanisms.
+
+Some samples of NBMOD are shown in the following figure:
+
+![image](picture/dataset.png) 
+
+Annotations of some samples in NBMOD are illustrated in the following figure as examples:
+
+![image](picture/annotation.png) 
+
+
+# Model Architectures
+The architectures of the RAST, RARA, and RAGT models are depicted in the following figures:
+
+**RAST:**
+
+![image](picture/RAST.png) 
+
+**RARA:**
+
+![image](picture/RARA.png) 
+
+**RAGT:**
+
+![image](picture/RAGT.png) 
+
+
+# Detection Results
+Detection results on SSS and NSS:
+
+![image](picture/detected-single-obj.png) 
+
+Detection results on MOS:
+
+![image](picture/detected-multi-obj.png) 
+
+
+# Requirements
+Our experimental setup is as follows:
+
+    python                    3.9.7
+    torch.version.cuda        11.3
+    torch                     1.12.1+cu113
+    torchaudio                0.12.1+cpu
+    torchdata                 0.6.0             
+    torchinfo                 1.7.2             
+    torchstat                 0.0.7                 
+    torchsummary              1.5.1                  
+    torchvision               0.13.1+cu113         
+    torchviz                  0.0.2                  
+    tornado                   6.2             
+    tqdm                      4.65.0         
+    thop                      0.1.1-2209072238       
+    tensorboard               2.9.1                 
+    tensorboard-data-server   0.6.1                 
+    tensorboard-plugin-wit    1.8.1              
+    tensorboardx              2.5.1                
+    opencv-contrib-python     4.7.0.72          
+    opencv-python             4.7.0.72   
+
+    CUDA Version              11.2
+
+
+# Download NBMOD and Model Weights
+Currently, the open-source code available is for the RAGT-3/3 model. You can modify the variable 'num_anchors' in the 'Anchor.py' file to change the number of anchors in each grid cell. The code for the RAST and RAGT models will be uploaded soon.
+
+The NBMOD is available at [NBMOD](https://pan.baidu.com/s/1kHtTKYkqFciJpfiMkEENaQ), with the password for extraction being 6666.
+
+The weights of models are available at [Weights](https://pan.baidu.com/s/18tAB5Yuu0yAJiyQvjE2vJw). The password for extraction is 6666.
+
+If you are unable to download the NBMOD dataset and model weights from the above link, you can try the following links: [NBMOD](https://drive.google.com/drive/folders/1zresLaQZc3DEP2m_Eo0w_kxT_6cHx9vN?usp=sharing) and [Weights](https://drive.google.com/drive/folders/1VKq7kK126RB0kNulP9JeY6soFN9sRp5O?usp=sharing).
+
+
+# Training & Testing
+The images in NBMOD have a resolution of 640x480, and the label files are in XML format.
+
+If you want to utilize our code, you can refer to our training and testing process as follows:
+
+1) The 640x480 images are padded with zeros to a size of 640x640 and then resized to 416x416. You can use the `resize_to_416.py` file in the `\data_preprocess\` directory to complete this step.
+
+2) Use the `original_img.py` file in the `\data_preprocess\data_augmentation\label\` directory to parse the coordinates of oriented bounding boxes from XML files into TXT files. In the TXT file, the coordinates are in the format of nx5, where "n" represents the number of annotation bounding boxes contained in the image, and "5" denotes the five coordinate parameters of the five-dimensional grasp representation.
+
+    For example:
+
+        x1 y1 w1 h1 theta1
+        x2 y2 w2 h2 theta2
+        x3 y3 w3 h3 theta3
+        ......
+        xn yn wn hn thetan
+
+   During the experiment, to accelerate the training process, we employed a strategy of performing data augmentation before training rather than augmenting the data during the training process. Under the `\data_preprocess\data_augmentation` directory, there are additional code files for data augmentation, which perform transformations on both images and coordinates. If you need to perform data augmentation, you can refer to these Python programs.
+
+   The purpose of the `rearrangement.py` file in the `\data_preprocess\` directory is to renumber the augmented data after the augmentation process.
+
+3) To start the training process, you can modify the paths of the dataset's images and labels in the `train_grasp.py` file. Additionally, you can set your desired batch size, loss function weights, and the number of training epochs. Once these modifications are done, you can run the `train_grasp.py` file to begin the training.
+
+    In the experiment, we employed the AdamW optimizer with its default training parameters. You can modify the `train_grasp.py` file to implement a more fine-grained training strategy according to your requirements.
+
+4) The `evaluate_acc.py` file is used to test the accuracy of the model. After modifying the paths of the test dataset's images and labels, as well as the model's weight path, you can run the file to evaluate the accuracy of the model.
+
+    Please ensure that the test dataset's image and label data formats remain consistent with those of the training dataset.
+
+   The `draw_single_box.py` script is used to visualize the detection results by drawing only the bounding box with the highest confidence. On the other hand, `grasp_detect_multibox.py` can be used to visualize all prediction boxes with confidence scores greater than a specified threshold.
+
+
+# Citation
+You can find a paper for explaining the NBMOD and our models on [arXiv](https://arxiv.org/abs/2306.10265).
+
+If you use this library or find the documentation useful for your research, please consider citing:
+
+    @article{cao2023nbmod,
+      title={NBMOD: Find It and Grasp It in Noisy Background},
+      author={Cao, Boyuan and Zhou, Xinyu and Guo, Congmin and Zhang, Baohua and Liu, Yuchen and Tan, Qianqiu},
+      journal={arXiv preprint arXiv:2306.10265},
+      year={2023}
+    }

data_preprocess/Anchor_mean_w_h.py

@@ -0,0 +1,29 @@
+import os
+import numpy as np
+
+
+def compute_column_mean(folder_path):
+    column_sum_3 = 0
+    column_sum_4 = 0
+    total_rows = 0
+
+    for file_name in os.listdir(folder_path):
+        if file_name.endswith('.txt'):
+            file_path = os.path.join(folder_path, file_name)
+            data = np.loadtxt(file_path)
+
+            column_sum_3 += np.sum(data[:, 2])  # 第3列的和
+            column_sum_4 += np.sum(data[:, 3])  # 第4列的和
+            total_rows += data.shape[0]  # 累加行数
+
+    mean_3 = column_sum_3 / total_rows
+    mean_4 = column_sum_4 / total_rows
+
+    return mean_3, mean_4
+
+
+if __name__ == "__main__":
+    folder_path = r"J:\experiment_data\1 origin\label"
+    mean_3, mean_4 = compute_column_mean(folder_path)
+    print("第3列的均值: ", mean_3)
+    print("第4列的均值: ", mean_4)

data_preprocess/Move_img.py

@@ -0,0 +1,19 @@
+import os
+import shutil
+
+def copy_png_files(src_folder, dest_folder):
+    if not os.path.exists(dest_folder):
+        os.makedirs(dest_folder)
+
+    for file_name in os.listdir(src_folder):
+        if file_name.endswith(".png"):
+            src_file_path = os.path.join(src_folder, file_name)
+            dest_file_path = os.path.join(dest_folder, file_name)
+            shutil.copy(src_file_path, dest_file_path)
+            print(f'复制文件: {src_file_path} 到 {dest_file_path}')
+
+if __name__ == "__main__":
+    source_folder = r'D:\Fruit_rd\img\a_bunch_of_bananas'
+    destination_folder = r'J:\data1-RGB\img\a_bunch_of_bananas'
+    
+    copy_png_files(source_folder, destination_folder)

data_preprocess/copy_files.py

@@ -0,0 +1,22 @@
+import os
+import shutil
+
+
+def copy_files(src_folder, dest_folder):
+    if not os.path.exists(dest_folder):
+        os.makedirs(dest_folder)
+
+    for file_name in os.listdir(src_folder):
+        print(file_name)
+        src_file_path = os.path.join(src_folder, file_name)
+        dest_file_path = os.path.join(dest_folder, file_name)
+
+        if os.path.isfile(src_file_path):
+            shutil.copy2(src_file_path, dest_file_path)
+
+
+if __name__ == "__main__":
+    src_folder = r"J:\experiment_data\8 r270\label"  # 替换为源文件夹的路径
+    dest_folder = r"J:\experiment_data\Train_Augmented_data\label"  # 替换为目标文件夹的路径
+
+    copy_files(src_folder, dest_folder)

data_preprocess/data_augmentation/img/PCA.py

@@ -0,0 +1,71 @@
+import os
+import cv2
+import numpy as np
+from numpy import linalg
+import random
+from PIL import Image
+from sklearn.decomposition import PCA
+
+
+def pca_color_augmentation(image_array):
+    '''
+    image augmention: PCA jitter
+    :param image_array: 图像array
+    :return img2: 经过PCA-jitter增强的图像array
+    '''
+    assert image_array.dtype == 'uint8'
+    assert image_array.ndim == 3
+    # 输入的图像应该是 (w, h, 3)这样的三通道分布
+
+    img1 = image_array.astype('float32') / 255.0
+    # 分别计算R，G，B三个通道的方差和均值
+    mean = img1.mean(axis=0).mean(axis=0)
+    std = img1.reshape((-1, 3)).std()  # 不可以使用img1.std(axis = 0).std(axis = 0)
+
+    # 将图像标按channel标准化（均值为0，方差为1）
+    img1 = (img1 - mean) / (std)
+
+    # 将图像按照三个通道展成三个长条
+    img1 = img1.reshape((-1, 3))
+
+    # 对矩阵进行PCA操作
+    # 求矩阵的协方差矩阵
+    cov = np.cov(img1, rowvar=False)
+    # 求协方差矩阵的特征值和向量
+    eigValue, eigVector = linalg.eig(cov)
+
+    # 抖动系数（均值为0，方差为0.1的标准分布）
+    rand = np.array([random.normalvariate(0, 0.08) for i in range(3)])
+    jitter = np.dot(eigVector, eigValue * rand)
+
+    jitter = (jitter * 255).astype(np.int32)[np.newaxis, np.newaxis, :]
+
+    img2 = np.clip(image_array + jitter, 0, 255)
+
+    return img2
+
+
+def process_images(input_folder, output_folder, alpha_std=0.1, seed=None):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    file_list = [f for f in os.listdir(input_folder) if f.endswith(".png")]
+
+    for file_name in file_list:
+        input_image_path = os.path.join(input_folder, file_name)
+        output_image_path = os.path.join(output_folder, file_name)
+
+        image = cv2.imread(input_image_path)
+        augmented_image = pca_color_augmentation(image)
+
+        cv2.imwrite(output_image_path, augmented_image)
+        print(output_image_path)
+
+
+if __name__ == "__main__":
+    input_folder = r'J:\experiment_data\1 origin\img'
+    output_folder = r'J:\experiment_data\3 PCA_illumination\img'
+    alpha_std = 0.1  # 根据需求调整光照强度的变化程度
+    seed = 42  # 可以修改为任意整数以改变随机种子，或设置为None以使用随机种子
+
+    process_images(input_folder, output_folder, alpha_std, seed)

data_preprocess/data_augmentation/img/gaussian_noise.py

@@ -0,0 +1,36 @@
+import os
+import cv2
+import numpy as np
+
+
+def add_gaussian_noise(image, mean=0, sigma=25):
+    height, width, channels = image.shape
+    noise = np.random.normal(mean, sigma, (height, width, channels))
+    noisy_image = image + noise
+    noisy_image = np.clip(noisy_image, 0, 255).astype(np.uint8)
+    return noisy_image
+
+
+def add_noise_to_folder(input_folder, output_folder, mean=0, sigma=25):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    file_list = [f for f in os.listdir(input_folder) if f.endswith(".png")]
+
+    for file_name in file_list:
+        input_image_path = os.path.join(input_folder, file_name)
+        output_image_path = os.path.join(output_folder, file_name)
+
+        image = cv2.imread(input_image_path)
+        noisy_image = add_gaussian_noise(image, mean, sigma)
+
+        cv2.imwrite(output_image_path, noisy_image)
+
+
+if __name__ == "__main__":
+    input_folder = r'J:\experiment_data\0 train_test_split\train\img'
+    output_folder = r'J:\experiment_data\2 Gs_noise\img'
+    mean = 0
+    sigma = 25  # 根据需求调整噪声强度
+
+    add_noise_to_folder(input_folder, output_folder, mean, sigma)

data_preprocess/data_augmentation/img/horizontal_flip.py

@@ -0,0 +1,29 @@
+import os
+import cv2
+
+
+def horizontal_flip(image):
+    return cv2.flip(image, 1)
+
+
+def process_images(input_folder, output_folder):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    file_list = [f for f in os.listdir(input_folder) if f.endswith(".png")]
+
+    for file_name in file_list:
+        input_image_path = os.path.join(input_folder, file_name)
+        output_image_path = os.path.join(output_folder, file_name)
+
+        image = cv2.imread(input_image_path)
+        flipped_image = horizontal_flip(image)
+
+        cv2.imwrite(output_image_path, flipped_image)
+
+
+if __name__ == "__main__":
+    input_folder = r'J:\experiment_data\1 origin\img'
+    output_folder = r'J:\experiment_data\4 horizontal\img'
+
+    process_images(input_folder, output_folder)

data_preprocess/data_augmentation/img/rotate_image.py

@@ -0,0 +1,25 @@
+import os
+from PIL import Image
+
+
+def rotate_images(input_folder, output_folder):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    file_list = [f for f in os.listdir(input_folder) if f.endswith(".png")]
+
+    for file_name in file_list:
+        print(file_name)
+        src_image_path = os.path.join(input_folder, file_name)
+        dest_image_path = os.path.join(output_folder, file_name)
+
+        img = Image.open(src_image_path)
+        rotated_img = img.rotate(-270)  # 顺时针旋转90度
+        rotated_img.save(dest_image_path)
+
+
+if __name__ == "__main__":
+    input_folder = r'J:\experiment_data\1 origin\img'
+    output_folder = r'J:\experiment_data\8 r270\img'
+
+    rotate_images(input_folder, output_folder)

data_preprocess/data_augmentation/img/vertical_flip.py

@@ -0,0 +1,29 @@
+import os
+import cv2
+
+
+def vertical_flip(image):
+    return cv2.flip(image, 0)
+
+
+def process_images(input_folder, output_folder):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    file_list = [f for f in os.listdir(input_folder) if f.endswith(".png")]
+
+    for file_name in file_list:
+        input_image_path = os.path.join(input_folder, file_name)
+        output_image_path = os.path.join(output_folder, file_name)
+
+        image = cv2.imread(input_image_path)
+        flipped_image = vertical_flip(image)
+
+        cv2.imwrite(output_image_path, flipped_image)
+
+
+if __name__ == "__main__":
+    input_folder = r'J:\experiment_data\1 origin\img'
+    output_folder = r'J:\experiment_data\5 vertical\img'
+
+    process_images(input_folder, output_folder)

data_preprocess/data_augmentation/label/horizontal_flip.py

@@ -0,0 +1,93 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename[2:]
+        # s = s.zfill(5)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+            angle = 3.1415926 - angle  # 左右对称
+            x = 416 - x  # 左右对称
+            # angle = np.tan(angle)
+            # if angle<0:
+            #    angle = max(-15,angle)
+            # if angle>=0:
+            #    angle = min(15,angle)
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+            
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+
+
+if __name__ == '__main__':
+    xml_path = r'J:\experiment_data\0 train_test_split\train\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\4 horizontal\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)

data_preprocess/data_augmentation/label/original_img.py

@@ -0,0 +1,94 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename
+        # s = filename[2:]
+        # s = s.zfill(6)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+            
+            # angle = np.tan(angle)
+            # if angle<0:
+            #     angle = max(-15,angle)
+            # if angle>=0:
+            #     angle = min(15,angle)
+            
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+            
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+            
+
+if __name__ == '__main__':
+    xml_path = r'J:\experiment_data\0 train_test_split\test\single-complex\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\0.1 test\single-complex\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)

data_preprocess/data_augmentation/label/rotate_180.py

@@ -0,0 +1,95 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename[2:]
+        # s = s.zfill(5)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+
+            x = 416 - x  # 中心对称
+            y = 416 - y  # 中心对称
+            # angle = np.tan(angle)
+            # if angle<0:
+            #    angle = max(-15,angle)
+            # if angle>=0:
+            #    angle = min(15,angle)
+            
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+            
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+
+
+if __name__ == "__main__":
+    xml_path = r'J:\experiment_data\0 train_test_split\train\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\6 r180\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)

data_preprocess/data_augmentation/label/rotate_270.py

@@ -0,0 +1,100 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename[2:]
+        # s = s.zfill(5)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+
+            exchange = x
+            x = y
+            y = 416 - exchange  # 顺时针旋转270度
+            angle = angle + 3.1415926 * 1.5
+            while angle >= 3.1415926:
+                angle = angle - 3.1415926
+
+            # angle = np.tan(angle)
+            # if angle<0:
+            #    angle = max(-15,angle)
+            # if angle>=0:
+            #    angle = min(15,angle)
+            
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+            
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+
+
+if __name__ == "__main__":
+    xml_path = r'J:\experiment_data\0 train_test_split\train\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\8 r270\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)

data_preprocess/data_augmentation/label/rotate_90.py

@@ -0,0 +1,102 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename[2:]
+        # s = s.zfill(6)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+
+            # 顺时针转动90度
+            exchange = y
+            y = x
+            x = 416 - exchange
+            angle = angle + 3.1415926/2
+            while angle >= 3.1415926:
+                angle = angle - 3.1415926
+
+            # angle = np.tan(angle)
+            # if angle<0:
+            #    angle = max(-15,angle)
+            # if angle>=0:
+            #    angle = min(15,angle)
+
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+
+
+if __name__ == '__main__':
+    xml_path = r'J:\experiment_data\0 train_test_split\train\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\7 r90\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)
+

data_preprocess/data_augmentation/label/vertical_flip.py

@@ -0,0 +1,93 @@
+import os
+import os.path
+import xml.etree.ElementTree as ET
+import glob
+import numpy as np
+
+
+def center_to_vertice(x, y, w, h, angle):  # 将抓取参数转化为抓取框用以显示
+    theta = angle
+    vertice = np.zeros((4, 2))
+    vertice[0] = (x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[1] = (x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta))
+    vertice[2] = (x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    vertice[3] = (x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta), y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta))
+    for i in range(0, 2):
+        for j in range(0, 4):
+            vertice[j][i] = round(vertice[j][i], 3)
+    return vertice
+
+
+def xml_to_txt(xml_path, txt_path):
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    fileList = os.listdir(xml_path)
+    print(fileList)
+    k = 0
+    # enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列
+    for i, file in enumerate(annotations):
+        in_file = open(file)  # 打开xml文件
+        tree = ET.parse(in_file)  # 用ElementTree表示xml文件
+        root = tree.getroot()  # 返回树的根节点
+        # filename = root.find('filename').text
+        # s = filename[2:]
+        # s = s.zfill(6)
+        # file_save = s + '.txt'
+        # file_save = filename + '.txt'
+        file_save = fileList[k][:-4] + '.txt'
+        k = k + 1
+        print(file_save)
+        file_txt = os.path.join(txt_path, file_save)
+        f_w = open(file_txt, 'w')
+        for obj2 in root.iter('object'):
+            # current = list()
+            # class_num = class_names.index(name)
+            xmlbox1 = obj2.find('robndbox')
+            x = xmlbox1.find('cx').text
+            y = xmlbox1.find('cy').text
+            width = xmlbox1.find('w').text
+            height = xmlbox1.find('h').text
+            angle = xmlbox1.find('angle').text
+            x = float(x)
+            x = x * 0.65
+            y = float(y)
+            y = y * 0.65
+            width = float(width)
+            width = width * 0.65
+            height = float(height)
+            height = height * 0.65
+            angle = float(angle)
+            if height > width:
+                exchange = width
+                width = height
+                height = exchange
+                angle = angle + 3.1415926/2
+                if angle >= 3.1415926:
+                    angle = angle - 3.1415926
+            angle = 3.1415926 - angle  # 上下对称
+            y = 416 - y  # 上下对称
+            # angle = np.tan(angle)
+            # if angle<0:
+            #    angle = max(-15,angle)
+            # if angle>=0:
+            #    angle = min(15,angle)
+            f_w.write(str(x) + ' ' + str(y) + ' ' + str(width) + ' ' + str(height) + ' ' + str(angle) + '\n')
+
+            # f_w.write(str(bbox[0][0]) + ' ' + str(bbox[0][1]) + '\n' +
+            #           str(bbox[1][0]) + ' ' + str(bbox[1][1]) + '\n' +
+            #           str(bbox[2][0]) + ' ' + str(bbox[2][1]) + '\n' +
+            #           str(bbox[3][0]) + ' ' + str(bbox[3][1]) + '\n')
+
+
+if __name__ == '__main__':
+    xml_path = r'J:\experiment_data\0 train_test_split\train\label'  # xml文件路径
+    txt_path = r'J:\experiment_data\5 vertical\label'  # txt文件路径
+
+    os.chdir(xml_path)  # 将当前的工作目录转到该目录下
+    annotations = os.listdir('.')  # 返回指定路径下的文件和文件夹列表
+    annotations = glob.glob(str(annotations) + '*.xml')  # 返回所有匹配的文件路径列表
+    # for i, element in enumerate(annotations):
+    #     print(i, element)
+
+    xml_to_txt(xml_path, txt_path)

data_preprocess/rearrangement.py

@@ -0,0 +1,33 @@
+import os
+
+
+# 初始值
+path = r'J:\experiment_data\8 r270\label'
+
+start_num = 178501  # 命名起点
+
+
+file_type = "png" if path[-3:] == 'img' else "txt"
+
+
+# 获取该目录下所有文件，存入列表中
+fileList = os.listdir(path)
+
+
+n = 0
+for i in fileList:
+    
+    # 设置旧文件名（就是路径+文件名）
+    oldname = path + os.sep + fileList[n]   # os.sep添加系统分隔符
+    
+    s = str(start_num)
+    s = s.zfill(7)
+    
+    newname = path + os.sep + s + "r." + file_type
+    
+    os.rename(oldname, newname)   # 用os模块中的rename方法对文件改名
+    print(oldname, '======>', newname)
+
+    start_num = start_num + 1
+    n = n+1
+

data_preprocess/resize_to_416.py

@@ -0,0 +1,39 @@
+import os
+import cv2
+
+
+def pad_and_resize_image(image):
+    # 创建一个黑色的640x640背景图像
+    padded_image = cv2.copyMakeBorder(image, 0, 160, 0, 0, cv2.BORDER_CONSTANT, value=0)
+
+    # 缩放图像到416x416
+    resized_image = cv2.resize(padded_image, (416, 416), interpolation=cv2.INTER_AREA)
+
+    return resized_image
+
+
+def process_images(src_folder, dest_folder):
+    if not os.path.exists(dest_folder):
+        os.makedirs(dest_folder)
+
+    for file_name in os.listdir(src_folder):
+        if file_name.endswith(".png"):
+            src_file_path = os.path.join(src_folder, file_name)
+            dest_file_path = os.path.join(dest_folder, file_name)
+
+            # 读取图像
+            image = cv2.imread(src_file_path)
+
+            # 调用 pad_and_resize_image 函数处理图像
+            processed_image = pad_and_resize_image(image)
+
+            # 保存处理后的图像
+            cv2.imwrite(dest_file_path, processed_image)
+            print(f'处理并保存图像: {src_file_path} 到 {dest_file_path}')
+
+
+if __name__ == "__main__":
+    source_folder = r'D:\cornell_data\img'
+    destination_folder = r'J:\cornell_dataset\img'
+
+    process_images(source_folder, destination_folder)

data_preprocess/segment_img.py

@@ -0,0 +1,20 @@
+import cv2
+import numpy as np
+
+
+def partition_img(img_dir, img_name):
+    img_path = img_dir + '\\' + img_name
+    img = cv2.imread(img_path, -1)
+    print(img.shape)
+    h, w, _ = img.shape
+    win_w, win_h = w//4, h//4
+    k = 1
+    for i in range(4):
+        for j in range(4):
+            sub_img = img[win_h*i:win_h*(i+1), win_w*j:win_w*(j+1), :]
+            cv2.imwrite(img_dir + '\\' + str(k) + '.png', sub_img)
+            k = k + 1
+
+
+if __name__ == '__main__':
+    partition_img(r'C:\Users\CBY\Desktop\manuscript\picture', 'jige.png')

data_preprocess/train_test_split.py

@@ -0,0 +1,54 @@
+import os
+import shutil
+import random
+
+
+def split_dataset(image_folder, label_folder,
+                  train_image_folder, train_label_folder, test_image_folder, test_label_folder, ratio, seed):
+    if not os.path.exists(train_image_folder):
+        os.makedirs(train_image_folder)
+
+    if not os.path.exists(train_label_folder):
+        os.makedirs(train_label_folder)
+
+    if not os.path.exists(test_image_folder):
+        os.makedirs(test_image_folder)
+
+    if not os.path.exists(test_label_folder):
+        os.makedirs(test_label_folder)
+
+    file_list = [f for f in os.listdir(image_folder) if f.endswith(".png")]
+
+    random.seed(seed)
+    random.shuffle(file_list)
+
+    train_size = int(len(file_list) * ratio)
+
+    for idx, file_name in enumerate(file_list):
+        src_image_path = os.path.join(image_folder, file_name)
+        src_label_path = os.path.join(label_folder, file_name.replace(".png", ".xml"))
+
+        if idx < train_size:
+            dest_image_path = os.path.join(train_image_folder, file_name)
+            dest_label_path = os.path.join(train_label_folder, file_name.replace(".png", ".xml"))
+        else:
+            dest_image_path = os.path.join(test_image_folder, file_name)
+            dest_label_path = os.path.join(test_label_folder, file_name.replace(".png", ".xml"))
+
+        shutil.copy(src_image_path, dest_image_path)
+        shutil.copy(src_label_path, dest_label_path)
+
+
+if __name__ == "__main__":
+    images_folder = r'J:\data_resized_to_416\img\single-complex'
+    labels_folder = r'J:\data_resized_to_416\label\single-complex'
+    train_images_folder = r'J:\experiment_data\train_test_split\train\img\single-complex'
+    train_labels_folder = r'J:\experiment_data\train_test_split\train\label\single-complex'
+    test_images_folder = r'J:\experiment_data\train_test_split\test\img\single-complex'
+    test_labels_folder = r'J:\experiment_data\train_test_split\test\label\single-complex'
+
+    split_ratio = 1 - 500 / 13000  # 训练集所占的比例
+    random_seed = 42  # 随机数种子
+
+    split_dataset(images_folder, labels_folder,
+                  train_images_folder, train_labels_folder, test_images_folder, test_labels_folder, split_ratio, random_seed)

draw_function.py

@@ -0,0 +1,71 @@
+import cv2
+from PIL import Image
+import numpy as np
+
+
+def draw_function(picture_path, save_dir, model, transform):
+    for i in picture_path:
+        # img = cv2.imread(i)
+        img = Image.open(i)
+        img = img.convert('RGB')
+        img1 = img.copy()
+        img1 = np.array(img1)
+        # img = cv2.resize(img,(400,300))
+        img = transform(img)
+        img = img.unsqueeze(dim=0)
+        # img = img/255
+        # img = img.reshape((1,300,400,3))
+
+        # out1, out2, out3, out4, out5 = model.predict(img)
+        predict_grasp = model(img)
+        x = predict_grasp[1].item()  # x取第一个预测值
+        y = predict_grasp[2].item()  # y取第二个预测值
+        w = predict_grasp[3].item()  # w取第三个预测值
+        h = predict_grasp[4].item()  # h取第四个预测值
+        theta = predict_grasp[5].item()  # theta取第五个预测值
+        center = (x, y)
+        size = (w, h)
+        angle = theta
+        box = cv2.boxPoints((center, size, angle))
+        box = np.int64(box)
+        # predict_grasp = predict_grasp.cpu().detach().numpy()
+        # vertice = np.zeros((4, 2))
+        # x = predict_grasp[1]
+        # y = predict_grasp[2]
+        # w = predict_grasp[3]
+        # h = predict_grasp[4]
+        # theta = predict_grasp[5] / 180 * 3.1415927
+        # vertice[0][0] = x - w / 2 * np.cos(theta) + h / 2 * np.sin(theta)
+        # vertice[0][1] = y - w / 2 * np.sin(theta) - h / 2 * np.cos(theta)
+        # vertice[1][0] = x + w / 2 * np.cos(theta) + h / 2 * np.sin(theta)
+        # vertice[1][1] = y + w / 2 * np.sin(theta) - h / 2 * np.cos(theta)
+        # vertice[2][0] = x + w / 2 * np.cos(theta) - h / 2 * np.sin(theta)
+        # vertice[2][1] = y + w / 2 * np.sin(theta) + h / 2 * np.cos(theta)
+        # vertice[3][0] = x - w / 2 * np.cos(theta) - h / 2 * np.sin(theta)
+        # vertice[3][1] = y - w / 2 * np.sin(theta) + h / 2 * np.cos(theta)
+        # p1 = (int(vertice[0][0]), int(vertice[0][1]))
+        # p2 = (int(vertice[1][0]), int(vertice[1][1]))
+        # p3 = (int(vertice[2][0]), int(vertice[2][1]))
+        # p4 = (int(vertice[3][0]), int(vertice[3][1]))
+
+        point_color1 = (255, 255, 0)  # BGR
+        point_color2 = (255, 0, 255)  # BGR
+        # point_color1 = (255, 255, 0)  # BGR
+        # point_color2 = (255, 255, 0)  # BGR
+
+        thickness = 2
+        lineType = 4
+        # img_p = k.numpy()
+        # img = img.reshape((300,400,3))
+        img_p = cv2.cvtColor(img1, cv2.COLOR_RGB2BGR)
+        # img_p = img1
+
+        cv2.line(img_p, box[0], box[3], point_color1, thickness, lineType)
+        cv2.line(img_p, box[3], box[2], point_color2, thickness, lineType)
+        cv2.line(img_p, box[2], box[1], point_color1, thickness, lineType)
+        cv2.line(img_p, box[1], box[0], point_color2, thickness, lineType)
+
+        picture_name = i.split('\\')[-1]
+        save_path = save_dir + '\\' + picture_name
+        cv2.imwrite(save_path, img_p)
+

draw_single_box.py

@@ -0,0 +1,76 @@
+import glob
+
+import numpy as np
+import torch
+from torch import nn
+from model import mobile_vit_small
+from Anchor import *
+import cv2
+from torchvision import transforms
+from grasp_detect_singlebox import DetectSingleImage
+from draw_function import draw_function
+
+
+def draw_one_box(img, coordinate):
+    # center = (cx, cy)
+    # size = (w, h)
+    # angle = theta
+    center = (coordinate[1].item(), coordinate[2].item())
+    size = (coordinate[3].item(), coordinate[4].item())
+    angle = coordinate[5].item()
+    box = cv2.boxPoints((center, size, angle))
+    box = np.int64(box)
+    # print(box)
+    # Font = cv2.FONT_HERSHEY_SIMPLEX
+    # cv2.putText(img, 'c: ' + str(round(coordinate[0].item(), 3)), (box[3][0], box[3][1]), Font, 0.5, (0, 0, 255), 1)
+    cv2.drawContours(img, [box], -1, (0, 255, 0), 2)
+
+    cv2.imshow("Image", img)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+
+def draw_pictures(imgs_path, save_dir):
+    for i in imgs_path:
+        img = cv2.imread(i)
+        img2 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img2 = transform(img2).unsqueeze(dim=0).to(device)
+        box = inference_single_image(img2)
+        center = (box[1].item(), box[2].item())
+        size = (box[3].item(), box[4].item())
+        angle = box[5].item()
+        box = cv2.boxPoints((center, size, angle))
+        box = np.int64(box)
+        cv2.drawContours(img, [box], -1, (0, 255, 0), 2)
+        cv2.imwrite(save_dir + '\\' + i.split('\\')[-1], img)
+
+
+if __name__ == '__main__':
+    # 权重路径
+    weights_path = r'weights\epoch6_loss_8.045684943666645.pth'
+
+    # 图像文件夹路径
+    imgs_path = glob.glob(r'J:\experiment_data\0.1 test\single-complex\img\*.png')
+
+    # 保存路径
+    save_dir = r'detected_img\complex'
+
+    # 指定设备
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    device = 'cpu'
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+    ])
+
+    inference_single_image = DetectSingleImage(device=device, weights_path=weights_path)
+
+    draw_function(picture_path=imgs_path, save_dir=save_dir, model=inference_single_image, transform=transform)
+
+    # draw_pictures(imgs_path=imgs_path, save_dir=save_dir)
+
+    # print('置信度：', box[0].data.item())
+
+    # draw_one_box(img,
+    #              confidence.data.item(),
+    #              cx.data.item(), cy.data.item(), w.data.item(), h.data.item(), theta.data.item())
+

evaluate_acc.py

@@ -0,0 +1,152 @@
+import cv2
+import numpy as np
+from shapely.geometry import Polygon
+import glob
+import torch
+from torch import nn
+import torchvision
+from PIL import Image
+from grasp_detect_singlebox import *
+
+
+# 图像预处理方式
+transform = torchvision.transforms.Compose([
+    transforms.ToTensor(),
+    # transforms.Resize((300, 400))
+])
+
+
+# 五维抓取坐标转四点坐标
+def grasp_to_point(predict_grasp, radian=False):  # 输入抓取框的五维表示
+    # vertice = np.zeros((4, 2))  # 生成一个4*2的数组用于保存四个点的八个坐标值
+    x = predict_grasp[0].item()  # x取第一个预测值
+    y = predict_grasp[1].item()  # y取第二个预测值
+    w = predict_grasp[2].item()  # w取第三个预测值
+    h = predict_grasp[3].item()  # h取第四个预测值
+    theta = predict_grasp[4].item()  # theta取第五个预测值
+    center = (x, y)
+    size = (w, h)
+    if radian:
+        angle = theta / 3.1415927 * 180
+    else:
+        angle = theta
+    box = cv2.boxPoints((center, size, angle))
+
+    return box
+
+
+# 计算jaccard指数
+def intersection(g, p):  # 输入标签的四点坐标和预测的四点坐标
+    g = np.asarray(g)
+    p = np.asarray(p)
+    g = Polygon(g[:8].reshape((4, 2)))
+    p = Polygon(p[:8].reshape((4, 2)))
+    if not g.is_valid or not p.is_valid:
+        return 0
+    inter = Polygon(g).intersection(Polygon(p)).area
+    union = g.area + p.area - inter
+    if union == 0:
+        return 0
+    else:
+        return inter / union
+
+
+# 判断单个框与单个框之间是否抓取有效
+def judge_availabel(predict_grasp, ground_truth):  # 输入五维抓取表示：预测的、标签的。       有效返回1，无效返回0
+    predict_point = grasp_to_point(predict_grasp)  # 预测的五维抓取转四点坐标
+    ground_truth_point = grasp_to_point(ground_truth, radian=True)  # 标签的五维抓取转四点坐标
+    jaccard = intersection(ground_truth_point, predict_point)  # 计算二者的jaccard指数
+    theta_predict = predict_grasp[-1].data.item()  # 取出预测的角度值
+    theta_ground_truth = ground_truth[-1] / 3.1415927 * 180  # 取出标签的角度值
+    
+    # 以下代码将预测角度和Ground Truth转化到0-180度之间
+    if theta_predict >= 180:
+        theta_predict -= 180
+    if theta_ground_truth >= 180:
+        theta_ground_truth -= 180
+    if theta_predict < 0:
+        theta_predict += 180
+    if theta_ground_truth < 0:
+        theta_ground_truth += 180
+    # 判定1
+    distance_of_theta1 = abs(theta_predict - theta_ground_truth)
+    # 以下代码将角度转化到-pi/2到+pi/2之间
+    if theta_predict > 90:
+        theta_predict -= 180
+    if theta_ground_truth > 90:
+        theta_ground_truth -= 180
+    # 判定2
+    distance_of_theta2 = abs(theta_predict - theta_ground_truth)
+    # 综合判定
+    distance_of_theta = min(distance_of_theta1, distance_of_theta2)  # 计算角度差
+
+    if jaccard >= 0.25 and distance_of_theta <= 30:  # 符合有效抓取的条件
+        available = 1
+    else:
+        available = 0
+    return available
+
+
+# 判断一张图是否抓取有效
+def judge_picture(picture_path, text_path):   # 图片地址，标签地址。       有效返回1，无效返回0
+    img = Image.open(picture_path)  # 读入单张要预测的图片
+    img = img.convert('RGB')
+    img = transform(img)
+    img = img.unsqueeze(dim=0)
+    img = img.to(device)
+    predict_grasp = inference_single_image(img)  # 预测抓取位置的五维表示
+    predict_grasp = predict_grasp[1:]
+    # predict_grasp = predict_grasp.cpu().detach().numpy()
+    # print(predict_grasp)
+    # print(predict_grasp[0].detach().numpy())
+    ground_truth = np.loadtxt(text_path)  # 读入标签文件
+    flag = 0  # 标志位置0
+    for i in range(len(ground_truth)):  # 遍历每一个标签中的抓取位置
+        if judge_availabel(predict_grasp, ground_truth[i]) == 1:
+            flag = 1
+            break
+    return flag
+
+
+# 计算正确率
+def evaluate_grasp(picture_dir_path, text_dir_path):  # 输入图片文件夹路径，标签文件夹路径
+    text_path_s = glob.glob(text_dir_path + '\\' + '*.txt')  # 获取全部标签文件的路径
+    text_path_s.sort(key=lambda x: x.split('\\')[-1].split('.txt')[0])  # 根据文件名进行排序
+    img_path_s = glob.glob(picture_dir_path + '\\' + '*.png')  # 获取全部图片文件的路径
+    img_path_s.sort(key=lambda x: x.split('\\')[-1].split('.png')[0])  # 根据文件名进行排序
+    yes = 0
+    total = 0
+    for i in range(len(text_path_s)):
+        available = judge_picture(img_path_s[i], text_path_s[i])  # 判断该图是否有效检测出有效抓取
+        if available == 1:
+            yes = yes + 1
+            total = total + 1
+            # print(img_path_s[i][-9:]+':Right')  #输出该图片检测正确的信息
+        else:
+            print(img_path_s[i].split('\\')[-1] + ':False')  # 输出该图片检测错误的信息
+            total = total + 1
+    print('检测总图片数：'+str(total))
+    print('检测有效抓取数：'+str(yes))
+    print('准确率：', yes/total)
+    return yes / total
+
+
+if __name__ == '__main__':
+    # 权重文件路径 & 测试图片、标签文件夹地址
+    weights_path = r'weights\epoch6_loss_8.045684943666645.pth'
+
+    picture_dir_path = r'J:\experiment_data\0.1 test\single-simple\img'
+    text_dir_path = r'J:\experiment_data\0.1 test\single-simple\label'
+
+    # 指定测试评价设备
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # 是否多卡训练
+    multi_GPU = False
+
+    # 定义模型
+    inference_single_image = DetectSingleImage(device=device, weights_path=weights_path)
+
+    # 测试模型
+    evaluate_grasp(picture_dir_path, text_dir_path)
+

grasp_detect_multibox.py

@@ -0,0 +1,111 @@
+import numpy as np
+import torch
+from torch import nn
+from model import get_model
+from Anchor import *
+import cv2
+from torchvision import transforms
+import torch.nn.functional as F
+
+
+class DetectMultiImage(nn.Module):
+    def __init__(self, device, weights_path, multi_gpu=False, weights=True):
+        super(DetectMultiImage, self).__init__()
+        self.net = get_model().to(device)
+        if multi_gpu:
+            self.net = nn.DataParallel(self.net)
+        if weights:
+            self.net.load_state_dict(torch.load(weights_path))
+        self.net.eval()
+
+    def get_index_and_bias(self, output, confidence_threshold):
+        N, C, H, W = output.shape
+        # N 90 26 26 ----> N 26 26 90
+        output = output.permute(0, 2, 3, 1)
+        # N 26 26 90 ----> N 26 26 15 6
+        output = output.reshape(N, H, W, num_anchors, -1)
+        # 取出置信度大于设定阈值confidence_threshold的所有box, mask_obj的shape：N W H num_anchors
+        mask_obj = (F.sigmoid(output[..., 0]) >= confidence_threshold)
+        # 返回mask_obj中为True的坐标索引，index的shape：为True的个数 x 4  （4的含义：N H W num_anchors的索引）
+        index = mask_obj.nonzero()
+        # 获得偏移量：confidence，tx，ty，tw，th，t_theta，bias的shape：为True的个数 x 6  （6的含义：box的6个属性值）
+        bias = output[mask_obj]
+        return index, bias
+
+    def get_coordinate(self, index, bias):
+        # 以下，confidence, cx, cy, w, h, theta的shape都是：为True的个数 x 1
+        confidence = torch.sigmoid(bias[:, 0])
+        # cx = index * field + sigmoid(bias) * filed
+        cx = (index[:, 2] + torch.sigmoid(bias[:, 1])) * field_of_grid_cell
+        cy = (index[:, 1] + torch.sigmoid(bias[:, 2])) * field_of_grid_cell
+        w = anchor_w * torch.exp(bias[:, 3])
+        h = anchor_h * torch.exp(bias[:, 4])
+        # theta已经转换为角度制
+        theta = (index[:, 3] + torch.sigmoid(bias[:, 5])) * theta_margin
+        return confidence, cx, cy, w, h, theta
+
+    def forward(self, input, confidence_threshold):
+        output = self.net(input)
+        index, bias = self.get_index_and_bias(output, confidence_threshold)
+        confidence, cx, cy, w, h, theta = self.get_coordinate(index, bias)
+        # 返回shape：为True的个数 x 6
+        return torch.cat([confidence.unsqueeze(1),
+                          cx.unsqueeze(1), cy.unsqueeze(1), w.unsqueeze(1), h.unsqueeze(1), theta.unsqueeze(1)], dim=1)
+
+
+# def draw_multi_box(img, box_coordinates):
+#     for i in range(box_coordinates.shape[0]):
+#         center = (box_coordinates[i, 1].item(), box_coordinates[i, 2].item())
+#         size = (box_coordinates[i, 3].item(), box_coordinates[i, 4].item())
+#         angle = box_coordinates[i, 5].item()
+#         box = cv2.boxPoints((center, size, angle))
+#         box = np.int64(box)
+#         cv2.drawContours(img, [box], -1, (0, 255, 0), 2)
+#     cv2.imshow("Image", img)
+#     cv2.waitKey(0)
+#     cv2.destroyAllWindows()
+
+
+def draw_multi_box(img, box_coordinates):
+    point_color1 = (255, 255, 0)  # BGR
+    point_color2 = (255, 0, 255)  # BGR
+    thickness = 2
+    lineType = 4
+    for i in range(box_coordinates.shape[0]):
+        center = (box_coordinates[i, 1].item(), box_coordinates[i, 2].item())
+        size = (box_coordinates[i, 3].item(), box_coordinates[i, 4].item())
+        angle = box_coordinates[i, 5].item()
+        box = cv2.boxPoints((center, size, angle))
+        box = np.int64(box)
+        cv2.line(img, box[0], box[3], point_color1, thickness, lineType)
+        cv2.line(img, box[3], box[2], point_color2, thickness, lineType)
+        cv2.line(img, box[2], box[1], point_color1, thickness, lineType)
+        cv2.line(img, box[1], box[0], point_color2, thickness, lineType)
+    cv2.imshow("Image", img)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    weights_path = 'weights/epoch6_loss_8.045684943666645.pth'
+
+    img = cv2.imread(r'J:\experiment_data\MOS\img\002243r.png')
+
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+    ])
+
+    inference_multi_image = DetectMultiImage(device=device, weights_path=weights_path)
+
+    img2 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)  # 转BGR格式为RGB格式
+    img2 = transform(img2).unsqueeze(dim=0).to(device)
+
+    boxes = inference_multi_image(img2, 0.9999)
+
+    print(boxes.shape)
+    print(boxes[:, 0].data[:5])
+
+    draw_multi_box(img, boxes.data)  # 此处传入的img是OpenCV的BGR格式的
+

grasp_detect_singlebox.py

@@ -0,0 +1,100 @@
+import numpy as np
+import torch
+from torch import nn
+from model import get_model
+from Anchor import *
+import cv2
+from torchvision import transforms
+
+
+class DetectSingleImage(nn.Module):
+    def __init__(self, device, weights_path, multi_gpu=False, weights=True):
+        super(DetectSingleImage, self).__init__()
+        self.net = get_model().to(device)
+        if multi_gpu:
+            self.net = nn.DataParallel(self.net)
+        if weights:
+            self.net.load_state_dict(torch.load(weights_path))
+            print('载入权重完成')
+        self.net.eval()
+
+    def get_index_and_bias(self, output):
+        N, C, H, W = output.shape
+        # N C H W ----> N H W C
+        output = output.permute(0, 2, 3, 1)
+        # N H W C ----> N H W num_anchors 6
+        output = output.reshape(N, H, W, num_anchors, -1)
+        # 只取出置信度最大的box
+        select_box = torch.max(output[..., 0])
+        # mask_obj的shape：N H W num_anchors，只取出置信度最大的box
+        mask_obj = (output[..., 0] == select_box)
+        # 返回mask_obj中为True的坐标索引，这里指定第一个元素，因为可能出现多个box置信度相同且都是最大的情况，index：N H W num_anchors
+        index = mask_obj.nonzero()[0]
+        # index = mask_obj.nonzero()
+        # 获得偏移量：confidence，tx，ty，tw，th，t_theta
+        # bias = output[index[0]][index[1]][index[2]][index[3]]
+        bias = output[mask_obj][0]
+        return index, bias
+
+    def get_coordinate(self, index, bias):
+        confidence = torch.sigmoid(bias[0])
+        cx = (index[2] + torch.sigmoid(bias[1])) * field_of_grid_cell
+        cy = (index[1] + torch.sigmoid(bias[2])) * field_of_grid_cell
+        w = anchor_w * torch.exp(bias[3])
+        h = anchor_h * torch.exp(bias[4])
+        theta = (index[3] + torch.sigmoid(bias[5])) * theta_margin
+        return confidence, cx, cy, w, h, theta
+
+    def forward(self, input):
+        output = self.net(input)
+        index, bias = self.get_index_and_bias(output)
+        confidence, cx, cy, w, h, theta = self.get_coordinate(index, bias)
+        return torch.cat([confidence.unsqueeze(0),
+                          cx.unsqueeze(0), cy.unsqueeze(0), w.unsqueeze(0), h.unsqueeze(0), theta.unsqueeze(0)], dim=0)
+
+
+def draw_one_box(img, coordinate):
+    # center = (cx, cy)
+    # size = (w, h)
+    # angle = theta
+    center = (coordinate[1].item(), coordinate[2].item())
+    size = (coordinate[3].item(), coordinate[4].item())
+    angle = coordinate[5].item()
+    box = cv2.boxPoints((center, size, angle))
+    box = np.int64(box)
+    # print(box)
+    # Font = cv2.FONT_HERSHEY_SIMPLEX
+    # cv2.putText(img, 'c: ' + str(round(coordinate[0].item(), 3)), (box[3][0], box[3][1]), Font, 0.5, (0, 0, 255), 1)
+    cv2.drawContours(img, [box], -1, (0, 255, 0), 2)
+
+    cv2.imshow("Image", img)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    weights_path = r'weights\Feature_Concat\epoch12_loss_424.52915453940744.pth'
+
+    img = cv2.imread(r'J:\experiment_data\0.1 test\single-complex\img\000009r.png')
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+    ])
+
+    inference_single_image = DetectSingleImage(device=device, weights_path=weights_path)
+
+    # img = np.random.randn(416, 416, 3).astype(np.float32)
+    img2 = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img2 = transform(img2).unsqueeze(dim=0).to(device)
+
+    box = inference_single_image(img2)
+    print(box.shape)
+    print('置信度：', box[0].data.item())
+
+    draw_one_box(img, box)
+
+    # draw_one_box(img,
+    #              confidence.data.item(),
+    #              cx.data.item(), cy.data.item(), w.data.item(), h.data.item(), theta.data.item())

model.py

@@ -0,0 +1,884 @@
+"""
+original code from apple:
+https://github.com/apple/ml-cvnets/blob/main/cvnets/models/classification/mobilevit.py
+"""
+
+from typing import Optional, Tuple, Union, Dict
+import math
+import torch
+import torch.nn as nn
+from torch import Tensor
+from torch.nn import functional as F
+
+from transformer import TransformerEncoder
+from model_config import get_config
+
+from torchinfo import summary
+from thop import profile
+
+from Anchor import num_anchors
+
+
+def make_divisible(
+    v: Union[float, int],
+    divisor: Optional[int] = 8,
+    min_value: Optional[Union[float, int]] = None,
+) -> Union[float, int]:
+    """
+    This function is taken from the original tf repo.
+    It ensures that all layers have a channel number that is divisible by 8
+    It can be seen here:
+    https://github.com/tensorflow/models/blob/master/research/slim/nets/mobilenet/mobilenet.py
+    :param v:
+    :param divisor:
+    :param min_value:
+    :return:
+    """
+    if min_value is None:
+        min_value = divisor
+    new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
+    # Make sure that round down does not go down by more than 10%.
+    if new_v < 0.9 * v:
+        new_v += divisor
+    return new_v
+
+
+class ConvLayer(nn.Module):
+    """
+    Applies a 2D convolution over an input
+
+    Args:
+        in_channels (int): :math:`C_{in}` from an expected input of size :math:`(N, C_{in}, H_{in}, W_{in})`
+        out_channels (int): :math:`C_{out}` from an expected output of size :math:`(N, C_{out}, H_{out}, W_{out})`
+        kernel_size (Union[int, Tuple[int, int]]): Kernel size for convolution.
+        stride (Union[int, Tuple[int, int]]): Stride for convolution. Default: 1
+        groups (Optional[int]): Number of groups in convolution. Default: 1
+        bias (Optional[bool]): Use bias. Default: ``False``
+        use_norm (Optional[bool]): Use normalization layer after convolution. Default: ``True``
+        use_act (Optional[bool]): Use activation layer after convolution (or convolution and normalization).
+                                Default: ``True``
+
+    Shape:
+        - Input: :math:`(N, C_{in}, H_{in}, W_{in})`
+        - Output: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+    .. note::
+        For depth-wise convolution, `groups=C_{in}=C_{out}`.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        kernel_size: Union[int, Tuple[int, int]],
+        stride: Optional[Union[int, Tuple[int, int]]] = 1,
+        groups: Optional[int] = 1,
+        bias: Optional[bool] = False,
+        use_norm: Optional[bool] = True,
+        use_act: Optional[bool] = True,
+    ) -> None:
+        super().__init__()
+
+        if isinstance(kernel_size, int):
+            kernel_size = (kernel_size, kernel_size)
+
+        if isinstance(stride, int):
+            stride = (stride, stride)
+
+        assert isinstance(kernel_size, Tuple)
+        assert isinstance(stride, Tuple)
+
+        padding = (
+            int((kernel_size[0] - 1) / 2),
+            int((kernel_size[1] - 1) / 2),
+        )
+
+        block = nn.Sequential()
+
+        conv_layer = nn.Conv2d(
+            in_channels=in_channels,
+            out_channels=out_channels,
+            kernel_size=kernel_size,
+            stride=stride,
+            groups=groups,
+            padding=padding,
+            bias=bias
+        )
+
+        block.add_module(name="conv", module=conv_layer)
+
+        if use_norm:
+            norm_layer = nn.BatchNorm2d(num_features=out_channels, momentum=0.1)
+            block.add_module(name="norm", module=norm_layer)
+
+        if use_act:
+            act_layer = nn.SiLU()
+            block.add_module(name="act", module=act_layer)
+
+        self.block = block
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.block(x)
+
+
+class InvertedResidual(nn.Module):
+    """
+    This class implements the inverted residual block, as described in `MobileNetv2 <https://arxiv.org/abs/1801.04381>`_ paper
+
+    Args:
+        in_channels (int): :math:`C_{in}` from an expected input of size :math:`(N, C_{in}, H_{in}, W_{in})`
+        out_channels (int): :math:`C_{out}` from an expected output of size :math:`(N, C_{out}, H_{out}, W_{out)`
+        stride (int): Use convolutions with a stride. Default: 1
+        expand_ratio (Union[int, float]): Expand the input channels by this factor in depth-wise conv
+        skip_connection (Optional[bool]): Use skip-connection. Default: True
+
+    Shape:
+        - Input: :math:`(N, C_{in}, H_{in}, W_{in})`
+        - Output: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+    .. note::
+        If `in_channels =! out_channels` and `stride > 1`, we set `skip_connection=False`
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        stride: int,
+        expand_ratio: Union[int, float],
+        skip_connection: Optional[bool] = True,
+    ) -> None:
+        assert stride in [1, 2]
+        hidden_dim = make_divisible(int(round(in_channels * expand_ratio)), 8)
+
+        super().__init__()
+
+        block = nn.Sequential()
+        if expand_ratio != 1:
+            block.add_module(
+                name="exp_1x1",
+                module=ConvLayer(
+                    in_channels=in_channels,
+                    out_channels=hidden_dim,
+                    kernel_size=1
+                ),
+            )
+
+        block.add_module(
+            name="conv_3x3",
+            module=ConvLayer(
+                in_channels=hidden_dim,
+                out_channels=hidden_dim,
+                stride=stride,
+                kernel_size=3,
+                groups=hidden_dim
+            ),
+        )
+
+        block.add_module(
+            name="red_1x1",
+            module=ConvLayer(
+                in_channels=hidden_dim,
+                out_channels=out_channels,
+                kernel_size=1,
+                use_act=False,
+                use_norm=True,
+            ),
+        )
+
+        self.block = block
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.exp = expand_ratio
+        self.stride = stride
+        self.use_res_connect = (
+            self.stride == 1 and in_channels == out_channels and skip_connection
+        )
+
+    def forward(self, x: Tensor, *args, **kwargs) -> Tensor:
+        if self.use_res_connect:
+            return x + self.block(x)
+        else:
+            return self.block(x)
+
+
+class MobileViTBlock(nn.Module):
+    """
+    This class defines the `MobileViT block <https://arxiv.org/abs/2110.02178?context=cs.LG>`_
+
+    Args:
+        opts: command line arguments
+        in_channels (int): :math:`C_{in}` from an expected input of size :math:`(N, C_{in}, H, W)`
+        transformer_dim (int): Input dimension to the transformer unit
+        ffn_dim (int): Dimension of the FFN block
+        n_transformer_blocks (int): Number of transformer blocks. Default: 2
+        head_dim (int): Head dimension in the multi-head attention. Default: 32
+        attn_dropout (float): Dropout in multi-head attention. Default: 0.0
+        dropout (float): Dropout rate. Default: 0.0
+        ffn_dropout (float): Dropout between FFN layers in transformer. Default: 0.0
+        patch_h (int): Patch height for unfolding operation. Default: 8
+        patch_w (int): Patch width for unfolding operation. Default: 8
+        transformer_norm_layer (Optional[str]): Normalization layer in the transformer block. Default: layer_norm
+        conv_ksize (int): Kernel size to learn local representations in MobileViT block. Default: 3
+        no_fusion (Optional[bool]): Do not combine the input and output feature maps. Default: False
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        transformer_dim: int,
+        ffn_dim: int,
+        n_transformer_blocks: int = 2,
+        head_dim: int = 32,
+        attn_dropout: float = 0.0,
+        dropout: float = 0.0,
+        ffn_dropout: float = 0.0,
+        patch_h: int = 8,
+        patch_w: int = 8,
+        conv_ksize: Optional[int] = 3,
+        *args,
+        **kwargs
+    ) -> None:
+        super().__init__()
+
+        conv_3x3_in = ConvLayer(
+            in_channels=in_channels,
+            out_channels=in_channels,
+            kernel_size=conv_ksize,
+            stride=1
+        )
+        conv_1x1_in = ConvLayer(
+            in_channels=in_channels,
+            out_channels=transformer_dim,
+            kernel_size=1,
+            stride=1,
+            use_norm=False,
+            use_act=False
+        )
+
+        conv_1x1_out = ConvLayer(
+            in_channels=transformer_dim,
+            out_channels=in_channels,
+            kernel_size=1,
+            stride=1
+        )
+        conv_3x3_out = ConvLayer(
+            in_channels=2 * in_channels,
+            out_channels=in_channels,
+            kernel_size=conv_ksize,
+            stride=1
+        )
+
+        self.local_rep = nn.Sequential()
+        self.local_rep.add_module(name="conv_3x3", module=conv_3x3_in)
+        self.local_rep.add_module(name="conv_1x1", module=conv_1x1_in)
+
+        assert transformer_dim % head_dim == 0
+        num_heads = transformer_dim // head_dim
+
+        global_rep = [
+            TransformerEncoder(
+                embed_dim=transformer_dim,
+                ffn_latent_dim=ffn_dim,
+                num_heads=num_heads,
+                attn_dropout=attn_dropout,
+                dropout=dropout,
+                ffn_dropout=ffn_dropout
+            )
+            for _ in range(n_transformer_blocks)
+        ]
+        global_rep.append(nn.LayerNorm(transformer_dim))
+        self.global_rep = nn.Sequential(*global_rep)
+
+        self.conv_proj = conv_1x1_out
+        self.fusion = conv_3x3_out
+
+        self.patch_h = patch_h
+        self.patch_w = patch_w
+        self.patch_area = self.patch_w * self.patch_h
+
+        self.cnn_in_dim = in_channels
+        self.cnn_out_dim = transformer_dim
+        self.n_heads = num_heads
+        self.ffn_dim = ffn_dim
+        self.dropout = dropout
+        self.attn_dropout = attn_dropout
+        self.ffn_dropout = ffn_dropout
+        self.n_blocks = n_transformer_blocks
+        self.conv_ksize = conv_ksize
+
+    def unfolding(self, x: Tensor) -> Tuple[Tensor, Dict]:
+        patch_w, patch_h = self.patch_w, self.patch_h
+        patch_area = patch_w * patch_h
+        batch_size, in_channels, orig_h, orig_w = x.shape
+
+        new_h = int(math.ceil(orig_h / self.patch_h) * self.patch_h)
+        new_w = int(math.ceil(orig_w / self.patch_w) * self.patch_w)
+
+        interpolate = False
+        if new_w != orig_w or new_h != orig_h:
+            # Note: Padding can be done, but then it needs to be handled in attention function.
+            x = F.interpolate(x, size=(new_h, new_w), mode="bilinear", align_corners=False)
+            interpolate = True
+
+        # number of patches along width and height
+        num_patch_w = new_w // patch_w  # n_w
+        num_patch_h = new_h // patch_h  # n_h
+        num_patches = num_patch_h * num_patch_w  # N
+
+        # [B, C, H, W] -> [B * C * n_h, p_h, n_w, p_w]
+        x = x.reshape(batch_size * in_channels * num_patch_h, patch_h, num_patch_w, patch_w)
+        # [B * C * n_h, p_h, n_w, p_w] -> [B * C * n_h, n_w, p_h, p_w]
+        x = x.transpose(1, 2)
+        # [B * C * n_h, n_w, p_h, p_w] -> [B, C, N, P] where P = p_h * p_w and N = n_h * n_w
+        x = x.reshape(batch_size, in_channels, num_patches, patch_area)
+        # [B, C, N, P] -> [B, P, N, C]
+        x = x.transpose(1, 3)
+        # [B, P, N, C] -> [BP, N, C]
+        x = x.reshape(batch_size * patch_area, num_patches, -1)
+
+        info_dict = {
+            "orig_size": (orig_h, orig_w),
+            "batch_size": batch_size,
+            "interpolate": interpolate,
+            "total_patches": num_patches,
+            "num_patches_w": num_patch_w,
+            "num_patches_h": num_patch_h,
+        }
+
+        return x, info_dict
+
+    def folding(self, x: Tensor, info_dict: Dict) -> Tensor:
+        n_dim = x.dim()
+        assert n_dim == 3, "Tensor should be of shape BPxNxC. Got: {}".format(
+            x.shape
+        )
+        # [BP, N, C] --> [B, P, N, C]
+        x = x.contiguous().view(
+            info_dict["batch_size"], self.patch_area, info_dict["total_patches"], -1
+        )
+
+        batch_size, pixels, num_patches, channels = x.size()
+        num_patch_h = info_dict["num_patches_h"]
+        num_patch_w = info_dict["num_patches_w"]
+
+        # [B, P, N, C] -> [B, C, N, P]
+        x = x.transpose(1, 3)
+        # [B, C, N, P] -> [B*C*n_h, n_w, p_h, p_w]
+        x = x.reshape(batch_size * channels * num_patch_h, num_patch_w, self.patch_h, self.patch_w)
+        # [B*C*n_h, n_w, p_h, p_w] -> [B*C*n_h, p_h, n_w, p_w]
+        x = x.transpose(1, 2)
+        # [B*C*n_h, p_h, n_w, p_w] -> [B, C, H, W]
+        x = x.reshape(batch_size, channels, num_patch_h * self.patch_h, num_patch_w * self.patch_w)
+        if info_dict["interpolate"]:
+            x = F.interpolate(
+                x,
+                size=info_dict["orig_size"],
+                mode="bilinear",
+                align_corners=False,
+            )
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        res = x
+
+        fm = self.local_rep(x)
+
+        # convert feature map to patches
+        patches, info_dict = self.unfolding(fm)
+
+        # learn global representations
+        for transformer_layer in self.global_rep:
+            patches = transformer_layer(patches)
+
+        # [B x Patch x Patches x C] -> [B x C x Patches x Patch]
+        fm = self.folding(x=patches, info_dict=info_dict)
+
+        fm = self.conv_proj(fm)
+
+        fm = self.fusion(torch.cat((res, fm), dim=1))
+        return fm
+
+
+# 将四倍下采样特征与五倍下采样特征融合
+# 将模型改为单分支输出预测
+# S版本，4倍下采样输出128通道，5倍下采样输出160通道
+class ResidualConvBlock(nn.Module):
+    def __init__(self,
+                 in_channels: int,
+                 middle_channels: int,
+                 ) -> None:
+        super().__init__()
+        self.res_conv_block = nn.Sequential(
+            nn.Conv2d(in_channels=in_channels, out_channels=middle_channels,
+                      kernel_size=(3, 3), stride=(1, 1), padding=1,
+                      bias=False),
+            nn.BatchNorm2d(num_features=middle_channels),
+            nn.SiLU(),
+            nn.Conv2d(in_channels=middle_channels, out_channels=in_channels,
+                      kernel_size=(3, 3), stride=(1, 1), padding=1,
+                      bias=False),
+            nn.BatchNorm2d(num_features=in_channels),
+        )
+        
+    def forward(self, x: Tensor) -> Tensor:
+        x = F.silu(self.res_conv_block(x) + x)
+        return x
+
+
+class ConvSet(nn.Module):
+    def __init__(self,
+                 in_channels: int,
+                 middle_channels: int,
+                 out_channels: int,
+                 ) -> None:
+        super(ConvSet, self).__init__()
+        self.convset = nn.Sequential()
+        self.convset.add_module(name='res_conv_block1',
+                                module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.convset.add_module(name='res_conv_block2',
+                                module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.convset.add_module(name='res_conv_block3',
+                                module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.convset.add_module(name='res_conv_block4',
+                                module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.convset.add_module(name='conv_3x3',
+                                module=nn.Conv2d(in_channels=in_channels, out_channels=out_channels,
+                                                 kernel_size=(3, 3), stride=(1, 1), padding=1,
+                                                 bias=False))
+        self.convset.add_module(name='bn', module=nn.BatchNorm2d(num_features=out_channels))
+        self.convset.add_module(name='SiLU', module=nn.SiLU())
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.convset(x)
+        return x
+
+
+class ConvDownSampling(nn.Module):
+    def __init__(self,
+                 in_channels: int,
+                 out_channels: int,
+                 ) -> None:
+        super().__init__()
+        self.convdownsampling = nn.Sequential()
+        # 3x3卷积
+        self.convdownsampling.add_module(name='conv1_3x3', module=nn.Conv2d(in_channels=in_channels,
+                                                                            out_channels=2*in_channels,
+                                                                            kernel_size=(3, 3),
+                                                                            stride=(2, 2),
+                                                                            padding=1,
+                                                                            bias=False))
+        self.convdownsampling.add_module(name='bn1', module=nn.BatchNorm2d(num_features=2*in_channels))
+        self.convdownsampling.add_module(name='SiLU1', module=nn.SiLU())
+        # 3x3卷积
+        self.convdownsampling.add_module(name='conv2_3x3', module=nn.Conv2d(in_channels=2*in_channels,
+                                                                            out_channels=out_channels,
+                                                                            kernel_size=(3, 3),
+                                                                            stride=(1, 1),
+                                                                            padding=1,
+                                                                            bias=False))
+        self.convdownsampling.add_module(name='bn2', module=nn.BatchNorm2d(num_features=out_channels))
+        self.convdownsampling.add_module(name='SiLU2', module=nn.SiLU())
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.convdownsampling(x)
+        return x
+
+
+class PositionalEncoding(nn.Module):
+    def __init__(self,
+                 d_model: int,
+                 max_len: int,
+                 ) -> None:
+        super(PositionalEncoding, self).__init__()
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        # # pe: [max_len, d_model] -> [1, max_len, d_model] -> [max_len, 1, d_model]
+        # pe = pe.unsqueeze(0).transpose(0, 1)
+        # pe: [max_len, d_model] -> [1, max_len, d_model]
+        pe = pe.unsqueeze(0)
+        # pe.requires_grad = False
+        self.register_buffer('pe', pe)
+
+    def forward(self, x: Tensor) -> Tensor:
+        # # x: [max_len, N, d_model]
+        # return x + self.pe[:x.size(0), :]
+        # x: [N, max_len, d_model]
+        # broadcast: pe: [1, max_len, d_model] -> [N, max_len, d_model]
+        return x + self.pe[:, :x.size(1), :]
+
+
+class GlobalTransformerEncoder(nn.Module):
+    def __init__(self,
+                 # in_channels: int,
+                 d_model: int,
+                 n_head: int,
+                 ffn_dim: int,
+                 encoder_layers: int,
+                 ) -> None:
+        super().__init__()
+
+        # if in_channels != d_model:
+        #     # 调整维度到d_model
+        #     self.conv1_1x1 = nn.Conv2d(in_channels=in_channels, out_channels=d_model,
+        #                             kernel_size=(1, 1), stride=(1, 1), padding=0)
+        #     # 调整维度到in_channels
+        #     self.conv2_1x1 = nn.Conv2d(in_channels=d_model, out_channels=in_channels,
+        #                             kernel_size=(1, 1), stride=(1, 1), padding=0)
+            
+        # 位置编码
+        self.position_encoding = PositionalEncoding(d_model=d_model, max_len=169)
+        # Transformer Encoder全局表征
+        self.transformer_encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=n_head,
+                                                                    dim_feedforward=ffn_dim,
+                                                                    batch_first=True,
+                                                                    norm_first=True)
+        self.transformer_encoder = nn.TransformerEncoder(self.transformer_encoder_layer,
+                                                         num_layers=encoder_layers, norm=nn.LayerNorm(d_model))
+        
+    def sequentialize(self, x: Tensor) -> Tuple[Tensor, dict]:
+        N, C, H, W = x.shape
+        # [N C H W] -> [N H W C]
+        x = x.permute(0, 2, 3, 1)
+        # [N H W C] -> [N H*W C]
+        x = x.reshape(N, H*W, C)
+        shape_dict = {
+            'origin_N': N,
+            'origin_C': C,
+            'origin_H': H,
+            'origin_W': W,
+        }
+        return x, shape_dict
+
+    def unsequentialize(self, x: Tensor, dim_dict: dict) -> Tensor:
+        # [N H*W C] -> [N H W C]
+        x = x.contiguous().view(dim_dict['origin_N'], dim_dict['origin_H'], dim_dict['origin_W'], dim_dict['origin_C'])
+        # [N H W C] -> [N C H W]
+        x = x.permute(0, 3, 1, 2)
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        # x = self.conv1_1x1(x)
+        x, shape_dict = self.sequentialize(x)
+        x = self.position_encoding(x)
+        x = self.transformer_encoder(x)
+        x = self.unsequentialize(x, dim_dict=shape_dict)
+        # x = self.conv2_1x1(x)
+        # x = F.interpolate(x, scale_factor=2, mode='bilinear', align_corners=False)
+        return x
+
+
+# class TransposeConv(nn.Module):
+#     def __init__(self,
+#                  in_channels,
+#                  out_channels
+#                  ):
+#         super(TransposeConv, self).__init__()
+#         self.transpose_conv = nn.Sequential()
+#         self.transpose_conv.add_module(name='conv_3x3', module=nn.Conv2d(in_channels=in_channels,
+#                                                                          out_channels=in_channels,
+#                                                                          kernel_size=(3, 3), stride=(1, 1), padding=1,
+#                                                                          bias=False))
+#         self.transpose_conv.add_module(name='bn1', module=nn.BatchNorm2d(in_channels))
+#         self.transpose_conv.add_module(name='SiLU1', module=nn.SiLU())
+#         self.transpose_conv.add_module(name='conv_1x1', module=nn.Conv2d(in_channels=in_channels,
+#                                                                          out_channels=out_channels,
+#                                                                          kernel_size=(1, 1), stride=(1, 1), padding=0,
+#                                                                          bias=False))
+#         self.transpose_conv.add_module(name='bn2', module=nn.BatchNorm2d(out_channels))
+#         self.transpose_conv.add_module(name='SiLU2', module=nn.SiLU())
+#         self.transpose_conv.add_module(name='transpose_conv', module=nn.ConvTranspose2d(in_channels=out_channels,
+#                                                                                         out_channels=out_channels,
+#                                                                                         kernel_size=(2, 2),
+#                                                                                         stride=(2, 2), padding=(0, 0),
+#                                                                                         output_padding=(0, 0)))
+#         self.transpose_conv.add_module(name='bn3', module=nn.BatchNorm2d(out_channels))
+#         self.transpose_conv.add_module(name='SiLU3', module=nn.SiLU())
+
+#     def forward(self, x):
+#         x = self.transpose_conv(x)
+#         return x
+
+
+# class SpatialPyramidPoolingFast(nn.Module):
+#     def __init__(
+#             self,
+#             in_channels
+#     ):
+#         super(SpatialPyramidPoolingFast, self).__init__()
+#         # 降维1*1卷积
+#         self.conv1_1_1 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels//4,
+#                                    kernel_size=(1, 1), stride=(1, 1),
+#                                    bias=False)
+#         self.bn1 = nn.BatchNorm2d(num_features=in_channels//4)
+#         self.SiLU1 = nn.SiLU()
+#         # 最大池化
+#         self.MaxPool_5_5 = nn.MaxPool2d(kernel_size=(5, 5), stride=(1, 1), padding=2)
+#         self.MaxPool1_3_3 = nn.MaxPool2d(kernel_size=(3, 3), stride=(1, 1), padding=1)
+#         self.MaxPool2_3_3 = nn.MaxPool2d(kernel_size=(3, 3), stride=(1, 1), padding=1)
+#         # 特征融合
+#         self.conv2_1_1 = nn.Conv2d(in_channels=in_channels, out_channels=in_channels,
+#                                    kernel_size=(1, 1), stride=(1, 1),
+#                                    bias=False)
+#         self.bn2 = nn.BatchNorm2d(num_features=in_channels)
+#         self.SiLU2 = nn.SiLU()
+
+#     def forward(self, x):
+#         x1 = self.conv1_1_1(x)
+#         x1 = self.bn1(x1)
+#         x1 = self.SiLU1(x1)
+#         x2 = self.MaxPool_5_5(x1)
+#         x3 = self.MaxPool1_3_3(x2)
+#         x4 = self.MaxPool2_3_3(x3)
+#         x = torch.concat([x1, x2, x3, x4], dim=1)
+#         x = self.conv2_1_1(x)
+#         x = self.bn2(x)
+#         x = self.SiLU2(x)
+#         return x
+
+
+class Detector(nn.Module):
+    def __init__(self,
+                 in_channels: int,
+                 middle_channels: int,
+                 out_channels: int,
+                 ) -> None:
+        super(Detector, self).__init__()
+        self.detector = nn.Sequential()
+        self.detector.add_module(name='res_conv_block1',
+                                 module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.detector.add_module(name='res_conv_block2',
+                                 module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.detector.add_module(name='res_conv_block3',
+                                 module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.detector.add_module(name='res_conv_block4',
+                                 module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        self.detector.add_module(name='res_conv_block5',
+                                 module=ResidualConvBlock(in_channels=in_channels, middle_channels=middle_channels))
+        # 输出
+        self.detector.add_module(name='conv2_1x1', module=nn.Conv2d(in_channels=in_channels,
+                                                                    out_channels=out_channels,
+                                                                    kernel_size=(1, 1), stride=(1, 1), padding=0,
+                                                                    bias=True))
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.detector(x)
+        return x
+
+
+class MobileViT(nn.Module):
+    """
+    This class implements the `MobileViT architecture <https://arxiv.org/abs/2110.02178?context=cs.LG>`_
+    """
+    def __init__(self, model_cfg: Dict, num_classes: int = 1000):
+        super().__init__()
+
+        image_channels = 3
+        out_channels = 16
+
+        self.conv_1 = ConvLayer(
+            in_channels=image_channels,
+            out_channels=out_channels,
+            kernel_size=3,
+            stride=2
+        )
+
+        self.layer_1, out_channels = self._make_layer(input_channel=out_channels, cfg=model_cfg["layer1"])
+        self.layer_2, out_channels = self._make_layer(input_channel=out_channels, cfg=model_cfg["layer2"])
+        self.layer_3, out_channels = self._make_layer(input_channel=out_channels, cfg=model_cfg["layer3"])
+        self.layer_4, out_channels = self._make_layer(input_channel=out_channels, cfg=model_cfg["layer4"])
+        self.layer_5, out_channels = self._make_layer(input_channel=out_channels, cfg=model_cfg["layer5"])
+
+        # exp_channels = min(model_cfg["last_layer_exp_factor"] * out_channels, 960)
+        # self.conv_1x1_exp = ConvLayer(
+        #     in_channels=out_channels,
+        #     out_channels=exp_channels,
+        #     kernel_size=1
+        # )
+        #
+        # self.classifier = nn.Sequential()
+        # self.classifier.add_module(name="global_pool", module=nn.AdaptiveAvgPool2d(1))
+        # self.classifier.add_module(name="flatten", module=nn.Flatten())
+        # if 0.0 < model_cfg["cls_dropout"] < 1.0:
+        #     self.classifier.add_module(name="dropout", module=nn.Dropout(p=model_cfg["cls_dropout"]))
+        # self.classifier.add_module(name="fc", module=nn.Linear(in_features=exp_channels, out_features=num_classes))
+
+        # 信息融合、检测模块
+        self.conv_downsampling1 = ConvDownSampling(in_channels=96, out_channels=128)
+        self.convset1 = ConvSet(in_channels=256, middle_channels=128, out_channels=120)
+        self.conv_downsampling2 = ConvDownSampling(in_channels=120, out_channels=160)
+        self.convset2 = ConvSet(in_channels=320, middle_channels=160, out_channels=240)
+        self.transformer_encoder = GlobalTransformerEncoder(d_model=240, n_head=4, ffn_dim=480, encoder_layers=4)
+        self.detector = Detector(in_channels=240, middle_channels=120, out_channels=num_anchors*6)
+
+        # weight init
+        self.apply(self.init_parameters)
+
+    def _make_layer(self, input_channel, cfg: Dict) -> Tuple[nn.Sequential, int]:
+        block_type = cfg.get("block_type", "mobilevit")
+        if block_type.lower() == "mobilevit":
+            return self._make_mit_layer(input_channel=input_channel, cfg=cfg)
+        else:
+            return self._make_mobilenet_layer(input_channel=input_channel, cfg=cfg)
+
+    @staticmethod
+    def _make_mobilenet_layer(input_channel: int, cfg: Dict) -> Tuple[nn.Sequential, int]:
+        output_channels = cfg.get("out_channels")
+        num_blocks = cfg.get("num_blocks", 2)
+        expand_ratio = cfg.get("expand_ratio", 4)
+        block = []
+
+        for i in range(num_blocks):
+            stride = cfg.get("stride", 1) if i == 0 else 1
+
+            layer = InvertedResidual(
+                in_channels=input_channel,
+                out_channels=output_channels,
+                stride=stride,
+                expand_ratio=expand_ratio
+            )
+            block.append(layer)
+            input_channel = output_channels
+
+        return nn.Sequential(*block), input_channel
+
+    @staticmethod
+    def _make_mit_layer(input_channel: int, cfg: Dict) -> Tuple[nn.Sequential, int]:
+        stride = cfg.get("stride", 1)
+        block = []
+
+        if stride == 2:
+            layer = InvertedResidual(
+                in_channels=input_channel,
+                out_channels=cfg.get("out_channels"),
+                stride=stride,
+                expand_ratio=cfg.get("mv_expand_ratio", 4)
+            )
+
+            block.append(layer)
+            input_channel = cfg.get("out_channels")
+
+        transformer_dim = cfg["transformer_channels"]
+        ffn_dim = cfg.get("ffn_dim")
+        num_heads = cfg.get("num_heads", 4)
+        head_dim = transformer_dim // num_heads
+
+        if transformer_dim % head_dim != 0:
+            raise ValueError("Transformer input dimension should be divisible by head dimension. "
+                             "Got {} and {}.".format(transformer_dim, head_dim))
+
+        block.append(MobileViTBlock(
+            in_channels=input_channel,
+            transformer_dim=transformer_dim,
+            ffn_dim=ffn_dim,
+            n_transformer_blocks=cfg.get("transformer_blocks", 1),
+            patch_h=cfg.get("patch_h", 2),
+            patch_w=cfg.get("patch_w", 2),
+            dropout=cfg.get("dropout", 0.1),
+            ffn_dropout=cfg.get("ffn_dropout", 0.0),
+            attn_dropout=cfg.get("attn_dropout", 0.1),
+            head_dim=head_dim,
+            conv_ksize=3
+        ))
+
+        return nn.Sequential(*block), input_channel
+
+    @staticmethod
+    def init_parameters(m):
+        if isinstance(m, nn.Conv2d):
+            if m.weight is not None:
+                nn.init.kaiming_normal_(m.weight, mode="fan_out")
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        elif isinstance(m, (nn.LayerNorm, nn.BatchNorm2d)):
+            if m.weight is not None:
+                nn.init.ones_(m.weight)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        elif isinstance(m, (nn.Linear,)):
+            if m.weight is not None:
+                nn.init.trunc_normal_(m.weight, mean=0.0, std=0.02)
+            if m.bias is not None:
+                nn.init.zeros_(m.bias)
+        else:
+            pass
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = self.conv_1(x)
+        x = self.layer_1(x)
+        x = self.layer_2(x)
+
+        x = self.layer_3(x)  # 下采样率8，输出维度：52x52x96
+        x1 = self.layer_4(x)  # 下采样率16，输出维度：26x26x128
+        x2 = self.layer_5(x1)  # 下采样率32，输出维度：13x13x160
+
+        x = self.conv_downsampling1(x)
+        x = torch.concat([x, x1], dim=1)
+        x = self.convset1(x)
+        x = self.conv_downsampling2(x)
+        x = torch.concat([x, x2], dim=1)
+        x = self.convset2(x)
+        x = self.transformer_encoder(x)
+        x = self.detector(x)  # 需要提取倒数第二层的特征图时，注释改行，使用下面的代码
+        # for i, module in enumerate(self.detector.detector):
+        #     x = module(x)
+        #
+        #     if i == 4:
+        #         # print(module)
+        #         break
+        return x
+
+
+def mobile_vit_xx_small(num_classes: int = 1000):
+    # pretrain weight link
+    # https://docs-assets.developer.apple.com/ml-research/models/cvnets/classification/mobilevit_xxs.pt
+    config = get_config("xx_small")
+    m = MobileViT(config, num_classes=num_classes)
+    return m
+
+
+def mobile_vit_x_small(num_classes: int = 1000):
+    # pretrain weight link
+    # https://docs-assets.developer.apple.com/ml-research/models/cvnets/classification/mobilevit_xs.pt
+    config = get_config("x_small")
+    m = MobileViT(config, num_classes=num_classes)
+    return m
+
+
+def mobile_vit_small(num_classes: int = 1000):
+    # pretrain weight link
+    # https://docs-assets.developer.apple.com/ml-research/models/cvnets/classification/mobilevit_s.pt
+    config = get_config("small")
+    m = MobileViT(config, num_classes=num_classes)
+    return m
+
+
+def get_model():
+    model = mobile_vit_small()
+    return model
+
+
+if __name__ == '__main__':
+    def count_parameters(model):
+        return sum(p.numel() for p in model.parameters() if p.requires_grad)
+
+    model = get_model()
+    x = torch.randn(1, 3, 416, 416)
+    params = count_parameters(model)
+    flops, parameters = profile(model, inputs=(x,))
+    total_params = sum(p.numel() for p in model.parameters())
+    print(x.shape)
+    print(model(x).shape)
+    print(summary(model, input_size=(1, 3, 416, 416)))
+    print(f"Total Params: {total_params / 1e6:.2f} M")
+    print(f"Total trainable Params: {params / 1e6:.2f} M")
+    print(f"FLOPs: {flops / 1e9:.2f} GFLOPs")
+
+    # print(model(x)[1].shape)
+    # print(model)
+
+

model_config.py

@@ -0,0 +1,176 @@
+def get_config(mode: str = "xxs") -> dict:
+    if mode == "xx_small":
+        mv2_exp_mult = 2
+        config = {
+            "layer1": {
+                "out_channels": 16,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 1,
+                "stride": 1,
+                "block_type": "mv2",
+            },
+            "layer2": {
+                "out_channels": 24,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 3,
+                "stride": 2,
+                "block_type": "mv2",
+            },
+            "layer3": {  # 28x28
+                "out_channels": 48,
+                "transformer_channels": 64,
+                "ffn_dim": 128,
+                "transformer_blocks": 2,
+                "patch_h": 2,  # 8,
+                "patch_w": 2,  # 8,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer4": {  # 14x14
+                "out_channels": 64,
+                "transformer_channels": 80,
+                "ffn_dim": 160,
+                "transformer_blocks": 4,
+                "patch_h": 2,  # 4,
+                "patch_w": 2,  # 4,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer5": {  # 7x7
+                "out_channels": 80,
+                "transformer_channels": 96,
+                "ffn_dim": 192,
+                "transformer_blocks": 3,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "last_layer_exp_factor": 4,
+            "cls_dropout": 0.1
+        }
+    elif mode == "x_small":
+        mv2_exp_mult = 4
+        config = {
+            "layer1": {
+                "out_channels": 32,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 1,
+                "stride": 1,
+                "block_type": "mv2",
+            },
+            "layer2": {
+                "out_channels": 48,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 3,
+                "stride": 2,
+                "block_type": "mv2",
+            },
+            "layer3": {  # 28x28
+                "out_channels": 64,
+                "transformer_channels": 96,
+                "ffn_dim": 192,
+                "transformer_blocks": 2,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer4": {  # 14x14
+                "out_channels": 80,
+                "transformer_channels": 120,
+                "ffn_dim": 240,
+                "transformer_blocks": 4,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer5": {  # 7x7
+                "out_channels": 96,
+                "transformer_channels": 144,
+                "ffn_dim": 288,
+                "transformer_blocks": 3,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "last_layer_exp_factor": 4,
+            "cls_dropout": 0.1
+        }
+    elif mode == "small":
+        mv2_exp_mult = 4
+        config = {
+            "layer1": {
+                "out_channels": 32,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 1,
+                "stride": 1,
+                "block_type": "mv2",
+            },
+            "layer2": {
+                "out_channels": 64,
+                "expand_ratio": mv2_exp_mult,
+                "num_blocks": 3,
+                "stride": 2,
+                "block_type": "mv2",
+            },
+            "layer3": {  # 28x28
+                "out_channels": 96,
+                "transformer_channels": 144,
+                "ffn_dim": 288,
+                "transformer_blocks": 2,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer4": {  # 14x14
+                "out_channels": 128,
+                "transformer_channels": 192,
+                "ffn_dim": 384,
+                "transformer_blocks": 4,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "layer5": {  # 7x7
+                "out_channels": 160,
+                "transformer_channels": 240,
+                "ffn_dim": 480,
+                "transformer_blocks": 3,
+                "patch_h": 2,
+                "patch_w": 2,
+                "stride": 2,
+                "mv_expand_ratio": mv2_exp_mult,
+                "num_heads": 4,
+                "block_type": "mobilevit",
+            },
+            "last_layer_exp_factor": 4,
+            "cls_dropout": 0.1
+        }
+    else:
+        raise NotImplementedError
+
+    for k in ["layer1", "layer2", "layer3", "layer4", "layer5"]:
+        config[k].update({"dropout": 0.1, "ffn_dropout": 0.0, "attn_dropout": 0.0})
+
+    return config

picture/annotation.pdf

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

picture/dataset.pdf

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

picture/detected-multi-obj.pdf

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

pretrained_weights/mobilevit_s.pt

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

similarity.py

@@ -0,0 +1,76 @@
+import torch
+from torch import nn
+from model import get_model
+import glob
+import os
+import torch.nn.functional as F
+from torchvision import transforms
+import cv2
+import numpy as np
+
+
+transform = transforms.Compose([
+    transforms.ToTensor(),
+])
+
+
+def cosine_similarity(v, M):
+    # 计算向量v的模
+    v_norm = np.linalg.norm(v)
+
+    # 计算矩阵M每一列的模
+    M_norm = np.linalg.norm(M, axis=0)
+
+    # 计算向量v和矩阵M每一列的点积
+    dot_product = np.dot(v, M)
+
+    # 计算余弦相似度
+    similarity = dot_product / (v_norm * M_norm)
+
+    return similarity
+
+
+if __name__ == '__main__':
+    weights_path = 'weights/epoch6_loss_8.045684943666645.pth'
+    img_dir = r'J:\experiment_data\0.1 test\test_img'
+    target_img_index = 500
+
+    img_path = glob.glob(img_dir + os.sep + '*.png')
+    model = get_model()
+    model.load_state_dict(torch.load(weights_path))
+    model.eval()
+
+    vectors = []
+    for i in img_path:
+        print(i)
+        img = cv2.imread(i, -1)
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = transform(img).unsqueeze(0)
+        vector = model(img)
+        vector = vector.squeeze().reshape(-1).detach().numpy()
+        vector = vector.tolist()
+        vectors.append(vector)
+    vectors = np.array(vectors, dtype=np.float32).transpose()
+    print(f'特征矩阵维度是：\n  {vectors.shape}')
+
+    target_img = cv2.imread(img_path[target_img_index], -1)
+    target_img = cv2.cvtColor(target_img, cv2.COLOR_BGR2RGB)
+    target_img = transform(target_img).unsqueeze(0)
+    target_vector = model(target_img)
+    target_vector = target_vector.squeeze().reshape(1, -1).detach().numpy()
+    target_vector = target_vector.astype(np.float32)
+
+    cos_similarity = cosine_similarity(target_vector, vectors)
+    sorted_indices = np.argsort(-cos_similarity)
+    v_sorted = np.take(cos_similarity, sorted_indices)
+    # print(f'相似度向量：\n  {v_sorted}')
+    # print(f'相似度序号向量：\n  {sorted_indices}')
+    print(f'排序向量维度：\n  {sorted_indices.shape}')
+
+    print(f'前10的相似度：\n  {v_sorted[0, :10]}')
+    print(f'前10的图像：\n  {sorted_indices[0, :10]}')
+
+    print(f'最后10个的相似度：\n  {v_sorted[0, -10:]}')
+    print(f'最后10个的图像：\n  {sorted_indices[0, -10:]}')
+
+

to_yolo_dataset.py

@@ -0,0 +1,99 @@
+from torch.utils.data import Dataset
+import numpy as np
+from Anchor import anchor_w, anchor_h, theta_margin, Anchor_eps, num_anchors, num_grid_cell, field_of_grid_cell, anchor_thetas
+from PIL import Image
+from torchvision import transforms
+import glob
+from torch.utils.data import DataLoader
+import pandas as pd
+import math
+
+
+def get_one_label(label_path):
+    # 每行标签的顺序是x, y, w, h, theta
+    # 最终输出的下采样倍数是4倍，每个grid cell对应原图上16*16的位置
+    labels = np.loadtxt(label_path)
+    # labels = pd.read_csv(label_path, header=None, sep=' ').to_numpy()
+    # tensor的每个box的标签值顺序是：confidence、bx、by、bw、bh、theta
+    tensor = np.zeros((num_grid_cell, num_grid_cell, num_anchors, 6))
+    for box in labels:
+        x = int(box[0] // field_of_grid_cell)
+        bx = (box[0] % field_of_grid_cell) / field_of_grid_cell
+        # bx = sigmoid(tx)
+        tx = math.log((bx + Anchor_eps) / (1 - bx))
+        y = int(box[1] // field_of_grid_cell)
+        by = (box[1] % field_of_grid_cell) / field_of_grid_cell
+        # by = sigmoid(ty)
+        ty = math.log((by + Anchor_eps) / (1 - by))
+        bw = box[2] / anchor_w
+        # bw = exp(tw)
+        tw = math.log(bw + Anchor_eps)
+        bh = box[3] / anchor_h
+        # bh = exp(th)
+        th = math.log(bh + Anchor_eps)
+        # 这里theta是弧度制，需要转换为角度制
+        while box[4] >= 3.1415927:
+            box[4] -= 3.1415927
+        theta = box[4] / 3.1415927 * 180
+        theta_anchor_match = int(theta // theta_margin)
+        b_theta = (theta % theta_margin) / theta_margin
+        # b_theta = sigmoid(t_theta)
+        t_theta = math.log((b_theta + Anchor_eps) / (1 - b_theta))
+        # 赋值
+        tensor[y][x][theta_anchor_match][0] = 1
+        tensor[y][x][theta_anchor_match][1] = tx
+        tensor[y][x][theta_anchor_match][2] = ty
+        tensor[y][x][theta_anchor_match][3] = tw
+        tensor[y][x][theta_anchor_match][4] = th
+        tensor[y][x][theta_anchor_match][5] = t_theta
+
+    tensor = tensor.astype(np.float32)
+    return tensor
+
+
+def get_label(label_path):
+    labels = []
+    for i in label_path:
+        label = get_one_label(i)
+        labels.append(label)
+    return np.array(labels)
+
+
+transform = transforms.Compose([
+    transforms.ToTensor()
+])
+
+
+class YoloDataset(Dataset):
+    def __init__(self, img_path, label_path):
+        self.img_path = img_path
+        self.label_path = label_path
+
+    def __getitem__(self, index):
+        x = self.img_path[index]
+        x = Image.open(x)
+        x = x.convert('RGB')
+        x = transform(x)
+        y = self.label_path[index]
+        y = get_one_label(y)
+        return x, y
+
+    def __len__(self):
+        return len(self.img_path)
+
+
+if __name__ == '__main__':
+    img_path = glob.glob(r'data\train_data\img\*.png')
+    label_path = glob.glob(r'data\train_data\label\*.txt')
+
+    dataset = YoloDataset(img_path, label_path)
+    dataloader = DataLoader(
+        dataset,
+        batch_size=4,
+        shuffle=False
+    )
+    img, label = next(iter(dataloader))
+    print(img.shape)
+    print(label.shape)
+    print(label[0][int(195.579085//32)][int(160.0963//32)])
+    # 160.0963 195.579085