资源管理器中"桌面"文件夹变成 desktop 文件夹, 而其他文件夹中文翻译正常, 且桌面正常使用, 一般是文件夹属性出错导致的. 修复方法:

1. 打卡隐藏文件C:\Users\Administrator\desktop/desktop.ini(Administrator是管理员用户名, 根据你的实际用户名修改, 下同), 该文件夹不会显示在资源管理器中, 可在资源管理器里直接输入文件路径打开. 如果不存在, 可以直接创建.
2. 该文件夹里的内容必须和以下内容完全相同, 如果不同或为空, 请直接粘贴替换:

1
2
3

[.ShellClassInfo]
LocalizedResourceName=@%SystemRoot%\system32\shell32.dll,-21769
IconResource=%SystemRoot%\system32\imageres.dll,-183

3. 进入C:\Users\Administrator文件夹, 执行以下命令:

1
2

attrib +r Desktop
attrib +h +s Desktop\desktop.ini

如果没有出错就表示成功. 然后注销账户重新登录(无需重启), 就修改成功.

配置 PHP 环境

在 Navicat 根目录下 navicat/resource/httptunnel 有 ntunnel_sqlite.php 文件, 在 1Panel 面板中创建 PHP 环境, 其中 PHP 版本选择 5.6.40, 高版本可能会存在异常. 扩展模板与默认扩展均无需填写.

在网站选项卡中根据该环境创建 PHP 网页, 并进入网站设置, 添加密码访问. 将 ntunnel_sqlite.php 文件上传到该网站目录下. 直接访问该网站, 可以看到如下界面:

容器映射

1Panel 使用容器来管理 PHP 环境, 因此需要将 SQLite 数据库文件映射到容器中. 向容器编排中添加如下映射, 或直接在容器设置界面修改:

1

/<数据库所在文件夹路径>:/sqlite

其含义是将 SQLite 数据库文件映射到容器中的 /sqlite 目录下. 该目录中应该存在 *.db 文件.

在刚刚的网站中, 输入容器内数据库文件路径, 即 /sqlite/<数据库文件名>, 点击 Test Connection, 下方会显示连接成功.

Navicat 配置

在 Navicat 中, 添加一个 SQLite 数据库连接, 在 HTTP 一栏选择使用 HTTP 隧道, 并输入刚刚的网站地址, 如 https://example.com/ntunnel_sqlite.php, 并填写用户名与密码. 在常规选项中, 填写容器内数据库文件路径, 即 /sqlite/<数据库文件名>.

点击测试连接, 显示连接成功.

可能存在的问题

如果 ntunnel_sqlite.php 能够成功打开, 但连不上数据库, 建议排查以下问题:

1. 数据库路径是否正确, 检查容器中是否能找到该文件, 注意软链接无法被容器访问.
2. 是否具有读写权限, 建议将数据库所在文件夹, 和数据库文件的权限全部设置为 777.
3. PHP 版本是否是为 5.6.40, 高版本可能会存在异常.

下载

百度网盘链接: https://pan.baidu.com/s/1IPf_0bh9PXwZAGUiZuTFiA?pwd=0000

数据集采用 zip 分卷压缩形式存储, 如果服务器使用 Linux 系统, 可以使用 Bypy 工具通过命令行下载.

使用

部分数据集经过了微小的调整, 包括:

• 格式化文件名
• 调整了部分不匹配的标注框, 原 gt 文件添加backup后缀

正常情况下本数据集下载后可以直接使用, 如果出错, 请检查图像路径相关代码并进行调整. 个别图像本身存在损坏, 但不影响训练.

完整数据集列表

单目标跟踪

COCO, GOT-10K, LaSOT, TNL2K, TrackingNet, VastTrack

热红外(TIR)目标跟踪

LSOTB-TIR

多模态(RGB-X)目标跟踪

RGB-T:

GTOT, LasHeR, RGBT210, RGBT234, VTUAV

RGB-D:

DepthTrack, VOT2019-RGBD, DepthTrack-RGB

RGB-E:

VisEvent

其中 DepthTrack-RGB 为 DepthTrack 的补充, 将深度图转化为可见光形式便于观察, 直接覆盖到 DepthTrack 内即可, 不影响原数据集使用.

多目标跟踪(MOT)

MOT20, MOT17, CrowdHuman

今年参加了 CACC (CCF算法能力大赛) 和算法精英赛, 发现最近的比赛开始喜欢出工程题. 工程题和算法题不同, 工程题由于数据量极大, 参数极多, 关系复杂, 所以很难找到最优解, 需要通过各种巧妙的方法找到一个尽可能优的解. 常见的计分方式是给出一个没有任何优化, 纯粹暴力解决或顺序遍历的解作为基线, 其他解的得分均基于此基线进行换算.

工程题并没有最佳答案, 本文方法仅为自己个人思路, 一定存在更好的方法.

外卖配送 (算法精英赛)

题目

本题为无人机轨迹优化题, 简要题目描述如下:

在 x 轴上有 m 个城市, 每个城市里有多个不同高度的建筑 $(y_1, y_2, \cdot)$. 现有一无人机从任意一点起飞, 要求停经所有城市的任意一个建筑, 再飞回去. 无人机的能耗由上升斜率和移动距离组成, 当无人机下降时, 仅考虑移动距离能耗. 规划一条最佳线路使能耗尽可能少.

能耗可以表示为:

$$E = \frac{(1 - k) \cdot d}{D} + \frac{k * s}{S}$$

其中 $d$ 为路径距离, $s$ 为线路斜率, 当无人机下降时, $s$ 取 $0$. $k, D, S$ 为固定参数. 所有数字均为整数.

分析

首先由于固定线路后总路程与总上升斜率不变, 因此任意点作为起点都不影响能耗, 默认第一个城市为起点即可.

分析题意, 可以将其视为二维平面上的线路优化问题. 有若干个不重合点 $(x_i, y_i)$, 这些点的横坐标可能重复. 设计一条尽可能平稳的轨迹, 同时使路径尽可能短.

我直接将其视为路径规划问题来看待, 如上图所示, 显然第一步是找出最为平稳的点集, 第二步再规划顺序.

在路径规划阶段, 尝试遍历第一个城市的每个点作为起点, 执行:

1. 把当前点加入点集 $P$.
2. 计算点集 $P$ 的平均高度.
3. 指针移动到下一个城市, 并把最接近平均高度的点加入点集 $P$.
4. 回到第 2 步重复执行, 直到每个城市都遍历了一次

这样就可以得到一系列点集, 它们的起点分别是第一个城市的每个点. 然后通过计算方差, 最大落差等因素, 找出一个高度最集中, 最平稳的点集. 并且能够立即得到一条简单路径: 只需要按顺序连接点集 $P$ 中的点即可.

第二步, 使用 2-opt 方法, 随机反转一段路径, 看是否优. 如果是, 则直接替换当前路径; 如果不是, 则换一段路径, 重复执行直到不存在更优方法, 此时算法结束.

以下是伪代码和示意图:

1
2
3
4
5
6
7
8
9
10

needSwap = True // 需要进行交换 
while needSwap: 
    needSwap = False // 先置为False, 如果没有发生交换说明无法优化 
        for i in [2, 3, …, pathList.len-2]: 
            for j [i+1, i+2, …, pathList.len-1] 
                oldDis = Distance([i-1, i, i+1, …, j-1, j, j+1]) // 交换之前的路径距离
                newDis = Distance([i-1, j, j-1, …, i+1, i, j+1]) // 交换之后的距离路径 
                if newDis < oldDis: // 如果交换后距离更短 
                    swap(pathList, i, j)
                    needSwap = True // 产生了交换, 说明存在优化可能, 继续循环尝试

数据采集

6. 小E的怪物挑战

问题描述

小E在一个游戏中遇到了 $n$ 个按顺序出现的怪物. 每个怪物都有其特定的血量 $h_i$ 和攻击力 $a_i$. 小E的初始血量为攻击力为. 游戏规则如下:

1.小E可以击败血量和攻击力都小于她当前属性的怪物
2.对于每只怪物, 小E可以选择与它战斗或者跳过这只怪物
3.为了保持战斗节奏, 要求击败的怪物序列中, 后一个怪物的血量和攻击力都必须严格大于前一个怪物

小E想知道, 她最多能击败多少怪物.

输入

n: 怪物的数量
H: 小E的血量
A: 小E的攻击力
h[i]: 第i个怪物的血量
a[i]: 第i个怪物的攻击力

输出

返回小E最多能击败的怪物数量

约束条件

• 1 < n < 100
• 1 < H, A, h[i], a[i] < 1000

测试样例

输入: n = 3, H = 4, A = 5, h = [1, 2, 3], a = [3, 2, 1]
输出: 1

输入: n = 5, H = 10, A = 10, h = [6, 9, 12, 4, 7], a = [8, 9, 10, 2, 5]
输出: 2

输入: n = 4, H = 20, A = 25, h = [10, 15, 18, 22], a = [12, 18, 20, 26]
输出: 3

输入: n = 4, H = 20, A = 25, h = [22, 18, 15, 10], a = [26, 20, 18, 12]
输出: 1

解题思路

经典的单调递增子序列问题. 首先打不过的怪物一定会跳过, 所以直接删除打不过的怪物, 最后再选出一条最长的单调递增序列. 定义 dp[i] 表示在 i 位置结束, 可以达到的最长序列. 首先 dp[i] 至少为 1, 因为可以直接打败当前位置怪物. 然后逐个比较之前位置的怪物 j, 如果怪物 i 比怪物 j 更强, 那么可以在打败怪物 j 之后打败怪物 i, 则 dp[i] = max(dp[i], dp[j] + 1).

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <iostream>
#include <vector>
using namespace std;

int solution(int n, int H, int A, vector<int> h, vector<int> a) {
    // 删除打不过的怪物
    int h_list[100];
    int a_list[100];
    int k=0;
    for(int i=0;i<n;i++){
        if(h[i]<H && a[i]<A){
            h_list[k] = h[i];
            a_list[k] = a[i];
            ++k;
        }
    }
    int dp[k];
    dp[0] = 1;
    int _max = 1;
    for(int i=1; i<k;i++){
        dp[i] = 1;
        for(int j=0; j<i;j++){
            if (h_list[i]>h_list[j] && a_list[i]>a_list[j]){
                dp[i] = max(dp[i], dp[j] + 1);
                _max = max(_max, dp[i]);
            }
        }
    }
    return _max;
}

int main() {
    cout << (solution(3, 4, 5, {1, 2, 3}, {3, 2, 1}) == 1) << endl;
    cout << (solution(5, 10, 10, {6, 9, 12, 4, 7}, {8, 9, 10, 2, 5}) == 2) << endl;
    cout << (solution(4, 20, 25, {10, 15, 18, 22}, {12, 18, 20, 26}) == 3) << endl;
    return 0;
}

7. 创意标题匹配

题目描述

在广告平台中, 为了给广告主一定的自由性和效率, 允许广告主在创造标题的时候以通配符的方式进行创意提交. 线上服务的时候, 会根据用户的搜索词触发的 bidword 对创意中的通配符(通配符是用成对 {} 括起来的字符串, 可以包含 0 个或者多个字符)进行替换, 用来提升广告投放体验. 例如: “{末日血战} 上线送 SSR 英雄, 三天集齐无敌阵容!”, 会被替换成“帝国时代游戏下载上线送 SSR 英雄, 三天集齐无敌阵容!”. 给定一个含有通配符的创意和n个标题, 判断这句标题是否从该创意替换生成的.

测试样例

输入: n = 4, template = "ad{xyz}cdc{y}f{x}e", titles = ["adcdcefdfeffe", "adcdcefdfeff", "dcdcefdfeffe", "adcdcfe"]
输出: "True,False,False,True"

解题思路

本题实际上是通配符匹配, {}中的内容可以任意替换, 所以可以将其看作一个通配符. 例如 ad{xyz}cdc{y}f{x}e 可以看作 ad*cdc*f*e. 我们只需要将通配符替换为 * 然后进行通配符匹配即可.

定义 dp[i][j] 表示字符串 str 的第 i 个字符和模板 p 的第 j 个字符是否匹配. 如果匹配, 则 dp[i][j] = 1, 否则为 -1. 因此会出现以下 3 种情况.

1. p[j] == '*', 则可以匹配 0 个字符, 模板指针后移, dp[i][j] = dp[i][j+1], 也可以匹配 1 个字符, 字符串指针后移, dp[i][j] = dp[i+1][j].
2. p[j] == str[i], 则可以匹配, 检查下一个字符是否匹配, dp[i][j] = dp[i+1][j+1].
3. p[j] != str[i], 则不匹配, dp[i][j] = -1.

另外还有一种情况, 如果模板被匹配完了, 那么字符串必须同时结束, 否则说明模板不够长, 不匹配.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#include <iostream>
#include <string>
#include <vector>
#define MAX_SIZE 1000
using namespace std;

string p, s;
int dp[MAX_SIZE][MAX_SIZE];

int isMatch(int i, int j) {
  if (j == p.size()) {
    return i == s.size() ? 1 : -1;
  }
  if (dp[i][j] != 0) {
    return dp[i][j];
  }
  if (p[j] == '*') {
    // 匹配 0 个字符
    int s1 = isMatch(i, j + 1);
    // 匹配 1 个字符
    int s2;
    if (i < s.size()) {
      s2 = isMatch(i + 1, j);
    } else {
      s2 = -1;
    }
    dp[i][j] = max(s1, s2);
  } else if (s[i] == p[j]) {
    dp[i][j] = isMatch(i + 1, j + 1);
  } else {
    dp[i][j] = -1;
  }
  return dp[i][j];
}

std::string solution(int n, std::string template_,
                     std::vector<std::string> titles) {
  p = "";
  string results = "";
  for (int i = 0; i < template_.size(); i++) {
    if (template_[i] == '{') {
      while (template_[i] != '}') {
        ++i;
      }
      p.push_back('*');
    } else {
      p.push_back(template_[i]);
    }
  }
  for (string _s : titles) {
    s = _s;
    for (int i = 0; i <= _s.size(); i++) {
      for (int j = 0; j <= p.size(); j++) {
        dp[i][j] = 0;
      }
    }
    if (isMatch(0, 0) == 1) {
      results += "True,";
    } else {
      results += "False,";
    }
  }
  return results.substr(0, results.size() - 1);
}

int main() {
  //  You can add more test cases here
  std::vector<std::string> testTitles1 = {"adcdcefdfeffe", "adcdcefdfeff",
                                          "dcdcefdfeffe", "adcdcfe"};
  std::vector<std::string> testTitles2 = {
      "CLSomGhcQNvFuzENTAMLCqxBdj", "CLSomNvFuXTASzENTAMLCqxBdj",
      "CLSomFuXTASzExBdj",          "CLSoQNvFuMLCqxBdj",
      "SovFuXTASzENTAMLCq",         "mGhcQNvFuXTASzENTAMLCqx"};
  std::vector<std::string> testTitles3 = {"abcdefg", "abefg", "efg"};

  std::cout << (solution(4, "ad{xyz}cdc{y}f{x}e", testTitles1) ==
                "True,False,False,True")
            << std::endl;
  std::cout << (solution(6, "{xxx}h{cQ}N{vF}u{XTA}S{NTA}MLCq{yyy}",
                         testTitles2) == "False,False,False,False,False,True")
            << std::endl;
  std::cout << (solution(3, "a{bdc}efg", testTitles3) == "True,True,False")
            << std::endl;

  return 0;
}

8. 找出整数里超过一般的数

题目描述

小R从班级中抽取了一些同学, 每位同学都会给出一个数字. 已知在这些数字中, 某个数字的出现次数超过了数字总数的一半. 现在需要你帮助小R找到这个数字.

测试样例

输入: array = [1, 3, 8, 2, 3, 1, 3, 3, 3]
输出: 3

解题思路

直接排序, 取中位数. 或者一个一个统计, 找到出现次数超过一半的数.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

#include <iostream>
#include <vector>
#include <bits/stdc++.h>

using namespace std;

int solution1(vector<int> array) {
    map<int, int> m;
    for(int num: array){
        m[num]++;
    }
    for(auto s = m.begin(); s != m.end(); s++){
        if(s->second > array.size() / 2){
            return s->first;
        }
    }
    return 0;
}

int solution2(vector<int> array) {
    sort(array.begin(), array.end());
    return array[array.size() / 2];
}

int solution(vector<int> array) {
    return solution1(array);
}

int main() {
    // Add your test cases here
    
    cout << (solution({1, 3, 8, 2, 3, 1, 3, 3, 3}) == 3) << endl;
    return 0;
}

9. 超市里的货物架调整

题目描述

在一个超市里, 有一个包含 n 个格子的货物架, 每个格子中放有一种商品, 商品用小写字母 a 到 z 表示. 当顾客进入超市时, 他们会依次从第一个格子查找到第 n 个格子, 寻找自己想要购买的商品. 如果在某个格子中找到该商品, 顾客就会购买它并离开；如果中途遇到一个空格子, 或查找完所有格子还没有找到想要的商品, 顾客也会离开.

作为超市管理员, 你可以在顾客到来之前重新调整商品的顺序, 以便尽可能多地出售商品. 当第一个顾客进入后, 商品位置不能再调整. 你需要计算在最优调整下, 最多可以卖出多少件商品. 输入变量说明:

• n: 货物架的格子数
• m: 顾客想要购买的商品种类数
• s: 货物架上商品的初始顺序
• c: 顾客想要购买的商品种类

测试样例

输入: n = 3 ,m = 4 ,s = "abc" ,c = "abcd"
输出: 3

解题思路

看似很复杂, 实际上看完题目非常简单. 只需要把客户想要购买的商品倒序排列就可以让每个顾客都能买到. 因此只需要统计货架上的商品够不够就行.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int solution(int n, int m, string s, string c) {
    int list[26] = {0};
    for(char ch: s){
        list[ch - 'a']++;
    }
    int t = 0;
    for(char ch: c){
        if(list[ch - 'a'] != 0){
            t++;
            list[ch - 'a']--;
        }
    }
    return t;
}

int main() {
    cout << (solution(3, 4, "abc", "abcd") == 3) << endl;
    cout << (solution(4, 2, "abbc", "bb") == 2) << endl;
    cout << (solution(5, 4, "bcdea", "abcd") == 4) << endl;
    return 0;
}

10. 小F的永久代币回本计划

问题描述

小F最近迷上了玩一款游戏, 她面前有一个永久代币卡的购买机会. 该卡片的价格为 a 勾玉, 每天登录游戏可以返还 b 勾玉. 小F想知道她至少需要登录多少天, 才能让购买的永久代币卡回本.

测试样例

输入: a = 10, b = 1
输出: 10

解题思路

无

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <iostream>
using namespace std;

int solution(int a, int b) {
    return a / b + (a % b != 0);
}

int main() {
    cout << (solution(10, 1) == 10) << endl;
    cout << (solution(10, 2) == 5) << endl;
    cout << (solution(10, 3) == 4) << endl;
    return 0;
}

1. 找单独的数

问题描述

在一个班级中, 每位同学都拿到了一张卡片, 上面有一个整数. 有趣的是, 除了一个数字之外, 所有的数字都恰好出现了两次. 现在需要你帮助班长小C快速找到那个拿了独特数字卡片的同学手上的数字是什么.

要求：

1. 设计一个算法, 使其时间复杂度为 O(n), 其中 n 是班级的人数.
2. 尽量减少额外空间的使用, 以体现你的算法优化能力.

测试样例

输入：cards = [1, 1, 2, 2, 3, 3, 4, 5, 5]
输出：4
解释：拿到数字 4 的同学是唯一一个没有配对的.

解题思路

由于数据范围较小, 可以直接使用数组统计所有数字出现次数, 但不符合优化要求. 这种数字重复出现的情况一般可以通过异或来计算.

异或运算规律:

• 任何数和 0 做异或运算, 结果仍然是原来的数, 即 a^0=a.
• 任何数和其自身做异或运算, 结果是 0, 即 a^a=0.
• 异或运算满足交换律和结合律, 即 a^b^a=(a^a)^b=0^b=b.

因此只需要将所有数字异或运算一次, 重复出现的数就会因异或两次变为 0, 最后剩下的就是单独的数. 如果单独的是 0, 由于其它数字全部出现两次都被抵消了, 因此最后剩下的还是 0.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <iostream>
#include <vector>

int solution(std::vector<int> cards) {
    int a = 0;
    for(int i=0;i<cards.size();++i){
        a = a ^ cards[i];
    }
    return a;
}

int main() {
    // Add your test cases here
    
    std::cout << (solution({1, 1, 2, 2, 3, 3, 4, 5, 5}) == 4) << std::endl;
    std::cout << (solution({0, 1, 0, 1, 2}) == 2) << std::endl;
    
    return 0;
}

2. 徒步旅行中的补给问题

问题描述

小R正在计划一次从地点A到地点B的徒步旅行, 总路程需要 N 天. 为了在旅途中保持充足的能量, 小R每天必须消耗1份食物. 幸运的是, 小R在路途中每天都会经过一个补给站, 可以先购买完食物后再消耗今天的1份食物. 然而, 每个补给站的食物每份的价格可能不同, 并且小R在购买完食物后最多只能同时携带 K 份食物.

现在, 小R希望在保证每天食物消耗的前提下, 以最小的花费完成这次徒步旅行. 你能帮助小R计算出最低的花费是多少吗？

输入

• n 总路程需要的天数
• k 小R最多能同时携带食物的份数
• data[i] 第i天补给站每份食物的价格

输出

返回完成这次徒步旅行的最小花费

约束条件

• 1 < n,k < 1000
• 1 < data[i] < 10000

测试样例

输入：n = 5 ,k = 2 ,data = [1, 2, 3, 3, 2]
输出：9

输入：n = 6 ,k = 3 ,data = [4, 1, 5, 2, 1, 3]
输出：9

输入：n = 4 ,k = 1 ,data = [3, 2, 4, 1]
输出：10

解题思路

先转换思路, 把小R能够携带 k 个食物转化为小R能够买到前 k 天的食物, 这与携带 k 个食物是等价的. 设定 dp 数组为第 i 天的最小花费 (注意第一天实际是 i==0), 则有

• 第 0 天必须购买第 0 个食物.
• 第 i 天可以选择购买第 i 个食物, 也可以选择购买前 k 天的食物, 取两者最小值.
• 第 i 天的最小花费与第 i-1 天的最小花费有关, 与第 i+1 天无关.

因此只需要在第 i-1 天的最小花费的基础上, 计算吃前 k 天哪一天的食物最优惠即可.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include <vector>

int solution(int n, int k, std::vector<int> data) {
  int dp[n];
  dp[0] = data[0];
  for (int i = 1; i < n; i++) {
    int min = data[i];
    for (int j = 1; j < k && i - j >= 0; j++) {
      if (data[i - j] < min) {
        min = data[i - j];
      }
    }
    dp[i] = dp[i - 1] + min;
  }
  return dp[n - 1];
}

int main() {
  // Add your test cases here
  std::cout << (solution(5, 2, {1, 2, 3, 3, 2}) == 9) << std::endl;
  return 0;
}

3. 数字字符串格式化

问题描述

小M在工作时遇到了一个问题, 他需要将用户输入的不带千分位逗号的数字字符串转换为带千分位逗号的格式, 并且保留小数部分. 小M还发现, 有时候输入的数字字符串前面会有无用的 0, 这些也需要精简掉. 请你帮助小M编写程序, 完成这个任务.

测试样例

输入：s = "1294512.12412"
输出：'1,294,512.12412'

输入：s = "0000123456789.99"
输出：'123,456,789.99'

输入：s = "987654321"
输出：'987,654,321'

解题思路

先找第一个非 0 数字, 再找第一个小数点, 最后格式化输出即可.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <iostream>
#include <string>

using namespace std;

std::string solution(const std::string &s) {
  // 查找第一个非0
  int len = s.size();
  int first_non_zero = 0;
  int first_point = 0;
  while (s[first_non_zero] == '0' && first_point < len) {
    first_non_zero++;
  }
  while (s[first_point] != '.' && first_point < len) {
    first_point++;
  }
  int num_len = (first_point - first_non_zero) % 3;
  string result = "";
  result.push_back(s[first_non_zero]);
  num_len = (num_len + 2) % 3;
  for (int i = first_non_zero + 1; i < first_point && i < len; i++) {
    if (num_len == 0) {
      result.push_back(',');
    }
    result.push_back(s[i]);
    num_len = (num_len + 2) % 3;
  }
  for (int i = first_point; i < len; i++) {
    result.push_back(s[i]);
  }
  return result;
}

int main() {
  std::cout << (solution("1294512.12412") == "1,294,512.12412") << std::endl;
  std::cout << (solution("0000123456789.99") == "123,456,789.99") << std::endl;
  std::cout << (solution("987654321") == "987,654,321") << std::endl;
}

4. 数字分组求偶数和

问题描述

小M面对一组从 1 到 9 的数字, 这些数字被分成多个小组, 并从每个小组中选择一个数字组成一个新的数. 目标是使得这个新数的各位数字之和为偶数. 任务是计算出有多少种不同的分组和选择方法可以达到这一目标.

• numbers: 一个由多个整数字符串组成的列表, 每个字符串可以视为一个数字组. 小M需要从每个数字组中选择一个数字.
  例如对于 [123, 456, 789] , 14个符合条件的数为：147 149 158 167 169 248 257 259 268 347 349 358 367 369.

测试样例

输入：numbers = [123, 456, 789]
输出：14

输入：numbers = [123456789]
输出：4

输入：numbers = [14329, 7568]
输出：10

解题思路

首先, 本题与具体数字无关, 只需要统计每个类别里的奇偶数个数即可. 对于第 i 组, 想要得到偶数, 只有两种情况:

1. 前 i-1 组之和为奇数, 第 i 组选择奇数.
2. 前 i-1 组之和为偶数, 第 i 组选择偶数.

因此在每次遍历时, 只需要根据上一次遍历结果, 直接计算当前组合的奇偶数个数即可.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <iostream>
#include <vector>

int solution(std::vector<int> numbers) {
  int len = numbers.size();
  int total_odd = 0;
  int total_even = 1;

  for (int i = 0; i < len; i++) {
    int odd_num = 0;
    int even_num = 0;
    // 统计奇偶数个数
    int t = numbers[i];
    while (t != 0) {
      int k = t % 10;
      t /= 10;
      if (k % 2) {
        odd_num++;
      } else {
        even_num++;
      }
    }

    // 前 i-1 组为奇数
    int _total_odd = total_odd * even_num + total_even * odd_num;
    // 前 i-1 组为偶数
    int _total_even = total_odd * odd_num + total_even * even_num;

    total_odd = _total_odd;
    total_even = _total_even;
  }
  return total_even;
}

int main() {
  // You can add more test cases here
  std::cout << (solution({123, 456, 789}) == 14) << std::endl;
  std::cout << (solution({123456789}) == 4) << std::endl;
  std::cout << (solution({14329, 7568}) == 10) << std::endl;
  return 0;
}

5. 寻找最大葫芦

题目描述

在一场经典的德州扑克游戏中, 有一种牌型叫做“葫芦”. “葫芦”由五张牌组成, 其中包括三张相同牌面值的牌 a 和另外两张相同牌面值的牌 b. 如果两个人同时拥有“葫芦”, 我们会优先比较牌 a 的大小, 若牌 a 相同则再比较牌 b 的大小, 牌面值的大小规则为：1 (A) > K > Q > J > 10 > 9 > … > 2, 其中 1 (A) 的牌面值为1, K 为13, 依此类推.

在这个问题中, 我们对“葫芦”增加了一个限制：组成“葫芦”的五张牌牌面值之和不能超过给定的最大值 max.

给定一组牌, 你需要找到符合规则的最大的“葫芦”组合, 并输出其中三张相同的牌面和两张相同的牌面. 如果找不到符合条件的“葫芦”, 则输出 “0, 0”.

测试样例

输入：n = 9, max = 34, array = [6, 6, 6, 8, 8, 8, 5, 5, 1]
输出：[8, 5]
说明：array数组中可组成4个葫芦, 分别为[6,6,6,8,8],[6,6,6,5,5],[8,8,8,6,6],[8,8,8,5,5]. 其中[8,8,8,6,6]的牌面值为36, 大于34不符合要求. 剩下的3个葫芦的大小关系为[8,8,8,5,5]>[6,6,6,8,8]>[6,6,6,5,5],故返回[8,5]

解题思路

本体没啥难度, 测试样例懒得复制粘贴了. 首先遍历卡牌, 统计卡牌数量. 由于总共就 13 张牌, 直接暴力循环, 尝试所有组合. 因为这里的比大小规则比较杂, 所以直接把卡牌按顺序从小到大存为数组 order, 然后按照数组顺序来一个一个尝试, 遇到第一个符合条件的直接输出.

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

#include <iostream>
#include <vector>

std::vector<int> solution(int n, int max, const std::vector<int>& array) {
    int card[14] = {0};
    int order[] = {1, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
    for(int num: array){
        card[num]++;
    }
    for(int i: order){
        for(int j: order){
            // 牌面相同
            if (i == j){
                continue;
            // 无法组成葫芦
            } else if (card[i] < 3 || card[j] < 2) {
                continue;
            // 超过最大值
            } else if (i * 3 + j * 2 > max) {
                continue;
            } else {
                return {i, j};
            }
        }
    }

    return {0, 0};
}

int main() {
    // Add your test cases here
    
    std::vector<int> result1 = solution(9, 34, {6, 6, 6, 8, 8, 8, 5, 5, 1});
    std::cout << (result1 == std::vector<int>{8, 5}) << std::endl;

    std::vector<int> result2 = solution(9, 37, {9, 9, 9, 9, 6, 6, 6, 6, 13});
    std::cout << (result2 == std::vector<int>{6, 9}) << std::endl;

    std::vector<int> result3 = solution(9, 40, {1, 11, 13, 12, 7, 8, 11, 5, 6});
    std::cout << (result3 == std::vector<int>{0, 0}) << std::endl;

    return 0;
}

DepthTrack 是 RGB-D 目标跟踪的数据集之一, 但作者并未提供完整数据集下载链接, 网上也未能找到百度网盘链接, 同时VOT toolkit工具配置极其恶心, 故写了个小工具来帮助环境搭建.

DepthTrack数据集下载

原 Github 仓库给出的是每个序列的下载链接, 因此可以使用 Python 自动获取压缩包路径, 实现下载.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177

import hashlib
import json
import os
import requests
import zipfile
from tqdm import tqdm
from concurrent.futures import ThreadPoolExecutor, as_completed

download_folder = r'./DepthTrack'

def download_file(file_info):
    file_name = file_info['name']
    url = file_info['url']
    file_path = os.path.join(download_folder, file_name)
    try:
        response = requests.get(url, stream=True)
        total_size = int(response.headers.get('content-length', 0))
        block_size = 1024  # 1 Kibibyte
        progress_bar = tqdm(total=total_size, unit='iB', unit_scale=True, desc=file_name)

        with open(file_path, 'wb') as file:
            for data in response.iter_content(block_size):
                progress_bar.update(len(data))
                file.write(data)
        progress_bar.close()
        return file_name, True
    except Exception as e:
        print(f"Error downloading {file_name}: {e}")
        return file_name, False

def download_files(file_infos, max_workers=5):
    print(f'start downloading {len(file_infos)} files')
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_file = {executor.submit(download_file, file_info): file_info for file_info in file_infos}
        for future in as_completed(future_to_file):
            file_info = future_to_file[future]
            try:
                file_name, success = future.result()
                results.append((file_name, success))
            except Exception as exc:
                print(f"{file_info['name']} error: {exc}")
    return results

def generate_download_items(json_record: int | list) -> list:
    if isinstance(json_record, list):
        download_items = []
        for record in json_record:
            download_items.extend(generate_download_items(record))
        return download_items

    json_url = f'https://zenodo.org/records/{json_record}/export/json'
    save_to = os.path.join(download_folder, f'{json_record}.json')
    if not os.path.exists(save_to):
        response = requests.get(json_url, stream=True)
        if response.status_code == 200:
            with open(save_to, 'wb') as file:
                for chunk in response.iter_content(chunk_size=1024):
                    if chunk:
                        file.write(chunk)
        else:
            raise Exception(f"Failed to download file from {json_url}")
    with open(save_to, 'r', encoding='utf-8') as file:
        data = json.load(file)
    # 生成下载列表
    download_items = []
    entries = data['files']['entries']
    for entry in entries:
        dic = entries[entry]
        item = {
            'name': dic['key'],
            'url': dic['links']['content'],
            'size': dic['size'],
            'md5': dic['checksum'][4:]
        }
        download_items.append(item)
    return download_items

def generate_split_txt(download_item: list, item_type: str) -> None:
    txt_file_path = os.path.join(download_folder, f'depthtrack_{item_type}.txt')
    if not os.path.exists(txt_file_path):
        with open(txt_file_path, 'w', encoding='utf-8') as file:
            file.write('\n'.join([item['name'].split('.')[0] for item in download_item]))

def check_exists(download_items: list) -> list:
    exist_item_list = [item for item in download_items if os.path.exists(os.path.join(download_folder, item['name']))]
    need_to_download = [item for item in download_items if item not in exist_item_list]
    print(f'find {len(exist_item_list)} exist files')
    if len(exist_item_list) == 0:
        return download_items
    with tqdm(total=len(exist_item_list), desc='checking exist') as pbar:
        correct_zip = 0
        wrong_zip = 0
        for item in exist_item_list:
            file_path = os.path.join(download_folder, item['name'])
            if item['md5'] == hashlib.md5(open(file_path, 'rb').read()).hexdigest():
                correct_zip += 1
            else:
                need_to_download.append(item)
                wrong_zip += 1
            pbar.update(1)
            pbar.desc = f'correct: {correct_zip}, wrong: {wrong_zip}'
    print(f'remove {correct_zip} files')
    return need_to_download

def task_download(total_download_items) -> list:
    need_to_download = check_exists(total_download_items)
    download_files(need_to_download)
    return need_to_download

def task_check_zip(check_download_items):
    with tqdm(total=len(check_download_items), desc='checking files') as pbar:
        correct_zip = 0
        wrong_zip = 0
        for item in check_download_items:
            file_path = os.path.join(download_folder, item['name'])
            if os.path.exists(file_path) and item['md5'] == hashlib.md5(open(file_path, 'rb').read()).hexdigest():
                check_download_items.remove(item)
                correct_zip += 1
            else:
                wrong_zip += 1
            pbar.update(1)
            pbar.desc = f'correct: {correct_zip}, wrong: {wrong_zip}'
    return check_download_items

def task_unzip(download_items):
    wrong_items = []
    success_num = 0
    with tqdm(total=len(download_items), desc='unzip files') as pbar:
        for item in download_items:
            pbar.desc = f'success: {success_num}, unziping: {item["name"]}'
            file_path = os.path.join(download_folder, item['name'])
            try:
                with zipfile.ZipFile(file_path, 'r') as zip_ref:
                    zip_ref.extractall(download_folder)
                success_num += 1
            except:
                wrong_items.append(item)
                print(f'failed to unzip {file_path}')
            pbar.update(1)
    print(f'{len(wrong_items)} files failed to unzip:')
    for item in wrong_items:
        print(item['name'])


if __name__ == "__main__":
    auto_unzip = True

    json_train_records = [5794115, 5837926]
    json_val_records = [5792146]

    print(f'generate download items')
    download_item_train = generate_download_items(json_train_records)
    download_item_val = generate_download_items(json_val_records)
    generate_split_txt(download_item_train, 'train')
    generate_split_txt(download_item_val, 'val')

    total_download_items = [*download_item_train, *download_item_val]
    total_download_items.sort(key=lambda x: x['name'])
    print(f'find {len(total_download_items)} zip files')

    # start download
    need_to_download_items = task_download(total_download_items)
    need_to_download_items = task_check_zip(need_to_download_items)

    # check
    while len(need_to_download_items) > 0:
        print(f'{len(need_to_download_items)} files are wrong, try to download again')
        task_download(need_to_download_items)
        need_to_download_items = task_check_zip(need_to_download_items)

    if auto_unzip:
        print(f'start unzip')
        task_unzip(total_download_items)

    # finish
    print(f'finish')

展开后可复制, 程序会先下载文件列表, 然后多线程下载压缩包. 若已有部分压缩包, 会验证 MD5 并跳过已下载的完整文件. 最后还附上了解压代码.

VOT toolkit 替代品

原工具配置了半天配不出来, 后续选择了另一个替代品 PYSOT toolkit.

直接按照文档安装即可, 注意要严格按照文档要求来, 有一步是要自己在本地构建包的.

该工具需要用到 json 文件来存标注框信息, 但作者没给 DepthTrack 的 json, 下面是本人写的 json 生成脚本, 从 depthtrack.txt 中自动读取序列名, 然后生成 DepthTrack.json.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

import os
import numpy as np
import pandas
from tqdm import tqdm

dataset_root = './../data'
dataset_name = 'DepthTrack'
gt_file_name = 'groundtruth.txt'
gt_split_char = ','

data_dic = {}

# circle all video
txt_file = os.path.join(dataset_root, dataset_name, 'depthtrack.txt')
with open(txt_file, 'r') as f:
    seq_names = f.read().splitlines()
    seq_names = [s.strip().split('.')[0] for s in seq_names]

for seq_name in tqdm(seq_names):
    seq_dir = os.path.join(dataset_root, dataset_name, seq_name)
    # gt file
    gt_file_path = os.path.join(seq_dir, gt_file_name)
    with open(gt_file_path, 'r') as f:
        gt_lines = f.read()
    gt_lines = gt_lines.replace('nan', '0', -1)
    gt_lines = gt_lines.splitlines()
    gt_lines = [s.strip().split(gt_split_char) for s in gt_lines]
    gt_lines = np.array(gt_lines, dtype=np.int32).tolist()
    # img path
    img_dir = os.path.join(seq_dir, 'color')
    img_list = [f for f in os.listdir(img_dir) if f.endswith('.png') or f.endswith('.jpg')]
    # sort
    img_list.sort(key=lambda x: int(x.split('.')[0]))
    img_list = [f'{seq_name}/color/{f}' for f in img_list]
    # attr
    attr = [attr.split('.')[0] for attr in os.listdir(seq_dir) if attr.endswith('.tag')]
    # absent
    absent = [1] * len(img_list)

    seq_dic = {
        'video_dir': seq_name,
        'init_rect': gt_lines[0],
        'img_names': img_list,
        'gt_rect': gt_lines,
        'attr': attr,
        'absent': absent
    }
    data_dic[seq_name] = seq_dic

# save to json
json_path = os.path.join(dataset_root, dataset_name, 'DepthTrack.json')
pandas.DataFrame(data_dic).to_json(json_path)

问题

使用 pytracking 框架的跟踪器, 在训练时控制台无报错, 但也没有任何反应. 强行停止后发现卡在 ltr_trainer.py 的 enumerate 处, 疑似死循环.

调试

请按照教程自行调试, 不要直接照我的改.

准备

在调试前, 请确保你是直接运行 project/lib/train/run_training.py 文件, 而不是 project/tracking/train.py. 否则你将无法调试, 你应该在 train.py 里打印出命令行语句, 然后添加到 PyCharm 的运行配置里.

按照上图打印出运行指令, 修改后的配置如下:

复现

CV库会使用多线程来加载图片, 不利于调试, 在 project/experiments 文件夹里修改跟踪器配置文件, 将 NUM_WORKER 改为 0. 注意是你运行的那个配置, 不要改错了.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

TRAIN:
  BACKBONE_MULTIPLIER: 0.1
  DROP_PATH_RATE: 0.1
  BATCH_SIZE: 1
  EPOCH: 240
  GIOU_WEIGHT: 2.0
  L1_WEIGHT: 0.0
  GRAD_CLIP_NORM: 0.1
  LR: 0.00008
  LR_DROP_EPOCH: 192
  NUM_WORKER: 0  # 在这里
  OPTIMIZER: ADAMW
  PRINT_INTERVAL: 10
  SCHEDULER:
    TYPE: step
    DECAY_RATE: 0.1
  VAL_EPOCH_INTERVAL: 20
  WEIGHT_DECAY: 0.0001
  AMP: False

然后运行代码, 等一会儿, 当控制台没有输出后, 直接强制停止. 此时应该已经卡在死循环内. 你会看到控制台有 KeyboardInterrupt 报错，然后顺着这个报错去找死循环位置.

定位死循环

你会在控制台看到以下报错:

点击最底下的, 且位于项目目录内的报错行. 我的报错最后一项恰好在项目目录内, 你的可能不是, 如 site-packages 是库文件, 请直接跳过. 点击后会直接跳转到中断处, 为这一行打断点, 点击左侧的行号即可.

接下来调试运行, 程序暂停在断点处. 如果你的程序没有暂停, 说明你运行的是 project/tracking/train.py, 请查看 准备 一节.

正常情况如下图所示.

可以看到现在调用的是 _read_target_visible() 函数, 左下角是调用栈, 可以查看当前线程和变量, 也可以切换到控制台. 多次点击右上角的 “恢复” 按钮(红圈里的), 然后切换到控制台选项卡, 如果每次都在这里中断, 没有进入死循环, 并且控制台没有输出, 说明当前断点位置就在死循环里.

但是这个函数里并没有 while 出现, 说明死循环在外部. 现在转到图片左下角调用栈, 按照从上往下的顺序逐个查看代码. 你只需要查看项目代码, 库文件已经自动变灰, 不用查看.

我在查看到第 3 层时, 发现 while 循环.

为了判断此处是否是死循环, 我们取消之前的断点, 在此处重新打一个断点, 然后单步运行(F8). 我们发现程序可以正常离开循环, 说明此处不是死循环.

于是我们在左下角继续查找, 发现第 4 层也是 while 循环. 同理, 我们取消掉之前的断点, 在这一层打一个新断点, 然后单步运行(F8).

此时我们发现程序无法离开循环, 并且执行到了 except 语句, 说明此处是死循环.

解决问题

我们发现此处使用了 except 语句, 这会导致控制台没有报错. 现在我们要查看具体的报错, 直接在这里打印即可.

1
2
3
4
5
6
7

import traceback

...
except Exception as ex:
    traceback.print_exc()
    valid = False
...

再次运行(现在不用调试了), 控制台会打印出一堆报错. 由于是死循环, 报错会重复打印.

定位至报错点, 打上断点, 进行调试.

现在只需要按照正常流程解决 bug 即可.

分析可知此处使用 / 来分割字符串, 但字符串里实际上反斜杠 \, 因此出错, 只需要将代码修改为反斜杠即可解决.

Fourier 变换

基本概念

若函数 $f(t)$ 在 $(-\infty, \infty)$ 上满足条件:

1. $f(t)$ 在任一有限区间满足 $Dirichlet$ 条件.
2. $f(t)$ 在 $(-\infty, \infty)$ 上绝对可积.

则:

$$F(\omega) = \int_{-\infty}^{+\infty}f(t)e^{-j\omega t}dt$$

$$f(t) = \frac 1 {2\pi} \int_{-\infty}^{+\infty}F(\omega)e^{j\omega t}d\omega$$

其中, $F(\omega)$ 称为 $f(t)$ 的 $Fourier$ 变换, 记为 $F(\omega) = \mathscr{F}[f(t)]$, 逆变换记为 $f(t) = \mathscr{F}^{-1}[F(\omega)]$.

常见公式

$$\begin{array}{ll}\displaystyle \mathscr{F}[1] = 2\pi\delta(\omega) \\\\\displaystyle \mathscr{F}[\delta(t)] = 1 \\\\\displaystyle \mathscr{F}[\cos \omega_0 t] = \pi [\delta(\omega + \omega_0) + \delta(\omega - \omega_0)] \\\\\displaystyle \mathscr{F}[\sin \omega_0 t] = \pi j [\delta(\omega + \omega_0) - \delta(\omega - \omega_0)]\end{array}$$

性质

线性性质

$$\mathscr{F}[\alpha f_1(t) + \beta f_2(t)] = \alpha F_1(\omega) + \beta F_2(\omega)$$

$$\mathscr{F}^{-1}[\alpha F_1(\omega) + \beta F_2(\omega)] = \alpha f_1(t) + \beta f_2(t)$$

位移性质

$$\mathscr{F}[f(t \pm t_0)] = F(\omega) e^{\pm j \omega_0 t}$$

$$\mathscr{F}^{-1}[F(\omega \pm \omega_0)] = f(t)e^{\mp j \omega_0 t}$$

卷积性质

$$\mathscr{F}[f_1(t) * f_2(t)] = F_1(\omega) \cdot F_2(\omega)$$

$$\mathscr{F}[f_1(t) \cdot f_2(t)] = \frac1 {2\pi} F_1(\omega) * F_2(\omega)$$

Parsevel 等式

$$\int_{-\infty}^{+\infty} \left[ f(t) \right]^2 dt = \frac 1{2\pi} \int_{-\infty}^{+\infty} \left[ F(\omega) \right]^2 d\omega$$

Laplace 变换

基本概念

设 $f(t)$ 在 $t \geq 0$ 上有定义, 且积分 $\displaystyle \int_0^{+\infty}f(t)e^{-st}dt$ ($s$ 是复参数) 关于某一范围内的 $s$ 收敛, 则由这个积分确定的函数

$$F(s) = \int_0^{+\infty}f(t)e^{-st}dt$$

称为 $f(t)$ 的 $Laplace$ 变换, 记为 $F(s) = \mathscr{L}[f(t)]$, 逆变换记为 $f(t) = \mathscr{L}^{-1}[F(s)]$.

常见公式

$$\begin{array}{ll}\displaystyle \mathscr{L}[1] = \frac1 {s} \\\\\displaystyle \mathscr{L}[e^{kt}] = \frac{1}{s-k} \\\\\displaystyle \mathscr{L}[\cos \omega t] = \frac{s}{s^2 + \omega^2} \\\\\displaystyle \mathscr{L}[\sin \omega t] = \frac{\omega}{s^2 + \omega^2}\end{array}$$

性质

线性性质

$$\mathscr{L}[\alpha f_1(t) + \beta f_2(t)] = \alpha F_1(s) + \beta F_2(s)$$

$$\mathscr{L}^{-1}[\alpha F_1(s) + \beta F_2(s)] = \alpha f_1(t) + \beta f_2(t)$$

微分性质

$$\mathscr{L}[f'(t)] = s F(s) - f(0)$$

$$\mathscr{L}[f^{(n)}(t)] = s^n F(s) - s^{n-1}f(0) - s^{n-2}f'(0) - \cdots - f^{(n-1)}(0)$$

$$F'(s) = -\mathscr{L}[tf(t)]$$

$$F^{(n)}(s) = (-1)^n \mathscr{L}[t^n f(t)]$$

积分性质

$$\mathscr{L}\left [\int_0^t f(t) dt \right] = \frac 1s F(s)$$

$$\mathscr{L}\left [\int_0^t dt \int_0^t dt \cdots \int_0^t f(t) dt \right] = \frac 1{s^n} F(s)$$

$$\int_s^{+\infty} F(u) du = \mathscr{L}\left [ \frac{f(t)}{t} \right ]$$

$$\mathscr{L}\left[ \frac{f(t)}{t^n} \right] = \int_s^{+\infty} ds \int_s^{+\infty} ds \cdots \int_s^{+\infty} F(s) ds$$

位移性质

$$\mathscr{L}[e^{at}f(t)] = F(s-a)$$

卷积性质

$$\mathscr{L}[f_1(t) * f_2(t)] = F_1(s) \cdot F_2(s)$$

$$\mathscr{L}^{-1}[F_1(s) \cdot F_2(s)] = f_1(t) * f_2(t)$$

逆变换

若 $s_1, s_2, \cdots, s_n$ 是函数 $F(s)$ 的所有孤立奇点(有限个), 除这些奇点外处处解析, 则

$$f(t) = \sum\limits_{k=1}^{n} \text{Res}[F(s)e^{st}, s_k]$$

即 $f(t)$ 是 $F(s)e^{st}$ 的所有留数之和.

Z 变换

基本概念

设 $x(n)$ 是无限序列, 则和式

$$X(z) = \sum\limits_{n=-\infty}^{+\infty} x(n) z^{-n}$$

是序列 $x(n)$ 的 $Z$ 变换, 记为 $x(z) = Z[x(n)]$, 其逆变换为

$$x(n) = \frac{1}{2\pi j}\oint_C X(z) z^{n-1} dz$$

记为 $x(n) = Z^{-1}[X(z)]$.

常见公式

$$\begin{array}{ll}\displaystyle Z[u(n)] = \frac{z}{z - 1} &, |z| > 1 \\\\\displaystyle Z[\alpha^n u(n)] = \frac{z}{z-\alpha} &, |z| > |\alpha| \\\\\displaystyle Z[n u(n)] = \frac{z}{(z-1)^2} &, |z| > 1 \\\\\displaystyle Z[n \alpha^n u(n)] = \frac{\alpha z}{(z - \alpha)^2} &, |z| > 1 \\\\\displaystyle Z[\sin \alpha n \cdot u(n)] = \frac{z \sin \alpha }{z^2 -2z \cos \alpha +1} &, |z| > 1 \\\\\displaystyle Z[\cos \alpha n \cdot u(n)] = \frac{z^2-z\cos \alpha}{z^2 - 2 z \cos \alpha + 1} &, |z| > 1 \\\\\displaystyle Z[\frac 1{n!}] = e^{\frac 1z} &, |z| \neq 0\end{array}$$

性质

线性性质

$$Z[\alpha x_1(n) + \beta x_2(n)] = \alpha Z[x_1(n)] + \beta Z[x_2(n)]$$

位移性质

$$Z[x(n \pm m)] = z^{\pm m} Z[x(n)]$$

微分性质

$$Z[nx(n)] = -zX'(z)$$

相似性质

$$Z[\alpha^nx(n)] = X\left( \frac z\alpha \right)$$

卷积性质

$$Z[x_1(n) * x_2(n)] = X_1(z) \cdot X_2(z)$$

简介

论文: Middle Fusion and Multi-Stage, Multi-Form Prompts for Robust RGB-T Tracking

RGBT 追踪主要受到以下两个阻碍: 1) 性能和效率之间的权衡; 2) 训练数据的稀缺. 为了解决后一个挑战, 一些方法采用提示来微调. 然而这些方法只考虑到模态相关的模式, 而忽略了模态无关的模式, 同时也忽略了开放场景中不同模态的动态可靠性. 本文将提出 M3PT, 一种 RGB-T 提示跟踪方法, 利用中间融合和多模式、多阶段视觉提升来克服上面的挑战, 并平衡性能与效率.

方法

在第一阶段, 使用双流网络分别提取两个单模态特征. 第二阶段主干是增强融合模式特征的单流网络. 中间融合模块位于两者之间, 作者使用了 4 种提示策略将预训练基础模型嵌入到本框架中, 以实现知识迁移. 这些策略分别是:

1. 将来自基础模型主干的 $L$ 个 Transformer Encoder 被分为两组, 分别是 $N$ 个和 $M$ 个 Encoder, 以用于两个阶段的特征提取.

2. 单模态探索提示(UEP)策略将第一组 Encoder 扩展为参数共享的双分支结构, 并逐层并行配置 UEP, 以探索模态无关信息并生成模态内和模态间提示, 使得 Encoder 更好地适应单模态特征建模.

3. 中间融合提示(MFP)策略用以聚合第一个主干输出的结果, 而自己的输出作为第二阶段主干的视觉提示.

4. 融合模态增强提示(FEP)策略逐层配置轻量级提示, 以获得更丰富的融合模态特征表示, 增强在主干网络中前向传播的融合模态特征.

5. 模态感知和阶段感知提示策略分两个阶段将 3 个可学习提示添加到主干输入中, 以指导它们更快地识别当前模态的分布特征.

6. 直接使用基础模型的预测头进行搜索.

单模态探索提示策略(UEP)

UEP 的具体结构如下所示:

输入的 Token 被记为 $E_X$, 它被 Reshape 为二维并映射到低维特征空间, 并用并行的 $1 \times 1$ 卷积和 DW 卷积(深度可分离卷积)组合成, 随后使用具有 $GELU$ 激活函数的 $1 \times 1$ 卷积层实现局部特征提取, 最后重新映射到高维空间, 并与输入值进行残差连接. 由于特征提取过程在低维进行, 因此 UEP 仅需要少量参数, 作者将热红外和可见光的低维特征空间维数分别设置为 $8, 16$. 除此之外, 还可根据 UEP 的输出生成两种视觉提示: 模态内提示和模态间提示. 以可见光分支为例, 首先提取模态无关特征:

$$P_{V, intra}^n = UEP_V^n(H_V^n) \\E_V^n = Encoder^n(H_V^n) + P_{V, intra}^n$$

其中下标 $V$ 表示可见光模态, 上标 $n$ 表示层数, $H$ 表示输入的 Token. 此时的 $E_V^n$ 维数是: $E_V^n \in \R^{(N_Z + N_X) \times D} $, 然后将模板 Token 拆出, 最为模板间提示逐元素加到另一模态模板. 下面是论文给出的公式.

$$[E_{V, Z}^n, E_{V, X}^n] = unconcaten(E_V^n) \\P_{V, inter}^n = E_{V, Z}^n \\H_{T, Z}^{n+1} = E_{T, Z}^n + P_{V, inter}^n \\$$

上述公式与结构图存在冲突, 若按照结构图, 则第三条公式应改为:

$$H_{T, Z}^n = E_{T, Z}^{n-1} + P_{V, inter}^n$$

中间融合提示策略(MFP)

MFP 的具体结构如下所示:

输入 $E_V, E_T$ 被 Reshape 为 $F_V, F_T$, 然后映射到维数为 $16$ 的低维特征空间. 注意这里的两个 $1 \times 1$ 卷积权值不共享, 随后将模态共享与模态无关信息分开:

$$F_S' = (F_{V, L} \times F_{T, L}) \\F_A' = (F_{V, L} + F_{T, L}) \\F_V' = Sigmoid(F_{V, L} - F_{T, L}) \\F_T' = Sigmoid(F_{T, L} - F_{V, L}) \\$$

其中 $F_{V, L}, F_{T, L}$ 分别表示被映射到低维空间的可见光和热红外特征, $F_S'$ 表示模态共享特征, $F_A'$ 表示整体特征. 上面的运算符号均表示逐元素运算. 随后连接以上元素.

$$F = concaten(F_V', F_S', F_A', F_S', F_T') \\[weight_V, weight_T] = Softmax(fc(F))$$

其中 $fc$ 表示全连接层, 最终融合过程如下:

$$F_{F, L} = F_S' + F_{V, L} \times weight_V + F_{T, L} \times weight_T$$

与一般的权重融合不同, 作者额外加上了 $F_S'$, 主要是为了防止低权重位置有用信息被抑制, 而这种低权重信息大都属于模态共享信息. 最后, 融合信息被重新映射回原始维数并整合成 Token.

融合模态增强提示策略(FEP)

FEP 模块的输入包括 Token 和编码器输出:

$$P^m = FEP^{m-N}(H^m, Encoder^m(H^m)), m=N+1 \\P^m = FEP^{m-N}(P^{m-1}, Encoder^m(H^m)), m>N+1 \\H^{m+1} = Encoder^m(H^m) + P^m, m>N+1$$

从上面的公式可以看出, 对于第一个 FEP 模块, 其输入是 Token 和第 $(N+1)$ 层 Encoder 输出(前 $N$ 个 Encoder 位于第一阶段主干中). 对于之后的 FEP 模块, 其输入是上一层 FEP 模块的输出和当前 Encoder 输出.

此处序号存在疑问, 按照论文所讲, Transformer 的 $L$ 个 Encoder 被分为 $N+M$ 个, 归为第一阶段和第二阶段主干使用. 而第二阶段 FEP 模块与 Encoder 是一一对应的, FEP 模块下标范围是 $1 \sim M$, 则 Encoder 的下标应对应 $(N+1) \sim (N+M)$, 即至少有 $M$ 个 Encoder 与 FEP 模块一一对应, 此时 $L$ 个 Encoder 已被全部分配完毕, 则最后一个 Encoder 是凭空多出来的.

模态感知和阶段感知提示策略

模型中一共出现 $3$ 次该类型提示, 分别是 $P_V, P_T, P_F$, 前两个在第一阶段特征提取, 后者在第二阶段特征提取. 三个提示均为可学习的, 并且不参与其他提示策略. 以可见光分支的 UEP 为例, 输入 Encoder 的参数为 $[E_V, P_V]$, 而进入 UEP 模块的则为 $P_V$, 若 UEP 模块输出为 $E_V'$, 则最终输出会被再次加上提示: $[E_V', P_V]$. 也就是说, 每当经过其他提示模块, $P$ 就会被分离出来, 最后添加到模块输出中.

损失函数

损失函数较为传统, 即 IoU 损失与 L1 损失.

$$L = L_{cls} + \lambda_{iou} L_{giou} + \lambda_{L1} L_{L1}$$