在audio DSP中， 软件的code和data主要放在3种不同的memory上，分别是片内的ITCM、DTCM和片外的memory（比如DDR）上。ITCM只能放code，DTCM只能放data，片外的memory既能放code也能放data。在写代码时要规划好哪些放片内，哪些放片外。上面说的这三种memory都属于RAM（random access memory， 随机访问存储器），可读可写。与之相对应的是ROM（read only memory，只读存储器），只能读。ROM相对RAM的优点之一是相同存储容量的情况下ROM的面积要比RAM小很多，在芯片上面积小就意味着成本低。为了降成本，有必要将部分audio的code放在ROM里，通常称为将软件固化。哪些code可以放进ROM呢？从ROM的只读特性知道放进ROM的code就不能改动了，因此放进ROM的code是经过充分验证的不会再改的代码，在音频领域主要是一些非常成熟的算法的代码，比如MP3解码算法的代码就适合放进ROM里。本文就以把MP3解码算法的代码放进ROM为例来讲讲是怎么一步步做的。

1，确定好哪些放进ROM里，即把哪些做固化。通常是一些非常成熟且不会再改的代码，多数是成熟算法的代码。确定前先要跟ASIC定好ROM的大小，比如128K或者256K。还要算好要放软件模块的code size和data size。要放进ROM的模块最好能把ROM塞满，充分利用ROM。本文就是把MP3解码算法的代码放进ROM里。

2，ROM在memory里是独立的一块。在芯片tape out 前软件工程师把用于ROM的二进制文件给ASIC工程师，ASIC工程师再将ROM文件里面的二进制数据放进ROM里。 开发ROM文件时，芯片还处于设计阶段，没法直接拿来用，只能在要设计芯片的相似芯片上去开发，用RAM中的一块独立的区域来模拟ROM。通常在片外memory上找一块独立的区域，因为内部memory的空间相对较小，不适合做。我在固化MP3解码code时就在DDR上找了一块独立的区域来放MP3解码算法的code和data。 即以前MP3解码的code和其他的code是放在一起的，以前MP3解码的data和其他的data是放在一起的，现在要把它们拿出来放在一个独立的区域。放在独立区域后开始调试，要确保MP3播放功能正常。调试时主要是修改LD（link descriptor）文件，改后用新生成的adsp.bin文件去播放MP3，正常播放就说明改对了。

3，ROM里的函数有可能调用其他函数，如libc里的库函数memset等。这些函数如果不放在ROM里，而是放在其他地方，它们的地址随着软件的开发就有可能发生变化（放进RAM的函数的地址是动态变化的）。而ROM里这些函数的地址还是先前做ROM时的地址，这些地址已经对应不上那些函数了，就不会得到正确的执行。因此要把这些函数排查出来，并放进ROM里。怎么排查呢？方法是在LD文件里定义一个rom_check_shift的变量，放在RAM上的code/data section的头部，好让code/data的地址产生偏移。刚开始设rom_check_shift为零，会生成ROM上code的一个反汇编文件。 然后不断增大rom_check_shift的值（比如从0到16、32、64、128等），同样会生成ROM上code的一个反汇编文件，将其与rom_check_shift为0时的反汇编文件进行比较，要确保代码的完全一样。如果不一样，看比较后不一样的地方，把找到的函数放进ROM里，直至完全一样。修改后也要确保播放MP3音乐功能完全正常。下图是比较反汇编文件时一处不一样的地方。

从上图看出，库函数memcpy()原先是放在RAM上的，由于rom_check_shift的改变，函数memcpy()的地址就不一样了。ROM里的函数调用函数memcpy()时，函数地址还是做ROM时的，可是后面随着软件的开发，memcpy()在RAM上的地址变了。ROM里的函数再去访问memcpy（）原先的地址已经不能正确调用memcpy（）了。因此要把memcpy()放进ROM里，确保它的地址永远不变。

4，ASIC的同学会告诉ROM的起始地址。先前是把要放在ROM上的先放在RAM里方便调试。现在调试OK了，就要把这部分放到ROM上去了。由于这部分放在ROM里就不能再包含在adsp.bin里，因此要修改生成adsp.bin的应用程序的代码，把放到ROM的部分生成单独的二进制文件，而不是放到adsp.bin里，这样adsp.bin就变小了。

5，得到用于ROM的二进制文件后，需要做格式转换，转成ASIC需要的格式。下图列出了软件生成的二进制格式以及ASIC需要的格式。

从上图看出，ASIC需要的格式是一行放8个字节，同时放在ROM里的数据是小端放的。知道怎么转换后，写个小应用程序，把我们生成的二进制文件转成ASIC需要的文件格式。

6，ASIC拿到需要的文件后，将数据放进ROM里，生成bitfile，让我们在FPGA上做验证，确保正确无误，如果有错误，这块ROM就废掉了。在FPGA上验证的通常是跟硬件相关的，如IPC通信等。要验证MP3解码功能不太方便，因此验证就变成了做数据内容的check，即ROM地址上的数据跟我们做ROM时生成的反汇编相同地址上的数据完全一致。做完FPGA验证后，ASIC就可以放心的把要做ROM的二进制数据放进ROM里了。

上面六步就是把软件模块固化的过程。

最新内容优先发布于个人博客：
小虎技术分享站
，随后逐步搬运到博客园。

通过WPF的按钮、文本输入框实现了一个简单的SpinBox数字输入用户组件并可以通过数据绑定数值和步长。本文中介绍了通过Xaml代码实现自定义组件的布局，依赖属性的定义和使用等知识点。

完整代码见
Github

组合Xaml组件实现基本的组件功能

SpinBox由一个文本输入框和两个箭头按钮组成，我们在
Xaml
代码中先把基本的布局做好。其实可以发现自定义用户控件布局和普通的窗体布局的
Xaml
代码差不多，只不过
Xaml
的根标签从
Window
变成了
UserControl
。

<UserControl x:Class="SpinBox.MySpinBox"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
             xmlns:local="clr-namespace:SpinBox"
             mc:Ignorable="d" 
             d:DesignHeight="36" d:DesignWidth="92">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="*"/>
            <ColumnDefinition Width="Auto"/>
        </Grid.ColumnDefinitions>

        <TextBox x:Name="txtBoxValue" Grid.Column="0"
                 TextAlignment="Center" VerticalContentAlignment="Center"/>
        <Grid Grid.Column="1">
            <Grid.RowDefinitions>
                <RowDefinition Height="5*"/>
                <RowDefinition Height="5*"/>
            </Grid.RowDefinitions>
            <Button Grid.Row="0" x:Name="btnPlus">&#x25B2;</Button>
            <Button Grid.Row="1" x:Name="btnMinor">&#x25BC;</Button>
        </Grid>
    </Grid>
</UserControl>

增加依赖属性

因为我们是WPF中制作的用户组件，因此希望输入的数值、步长的配置等可以在
Xaml
中实现。因此我们需要给我们新建的用户组件增加依赖属性。这里我们直接通过依赖属性值变化的回调函数来实现文本框信息的更新。

    /// <summary>
    /// SpinBox.xaml 的交互逻辑
    /// </summary>
    [ContentProperty("Value")]
    public partial class MySpinBox : UserControl
    {

        /// <summary>
        /// DepedencyProperty for Step
        /// </summary>
        public static readonly DependencyProperty StepProperty
            = DependencyProperty.Register("Step", typeof(double),
                typeof(MySpinBox), new PropertyMetadata(1.0));

        /// <summary>
        /// DepedencyProperty for Value
        /// </summary>
        public static readonly DependencyProperty ValueProperty
            = DependencyProperty.Register("Value", typeof(double),
                typeof(MySpinBox), new FrameworkPropertyMetadata(0.0,
                     FrameworkPropertyMetadataOptions.BindsTwoWayByDefault
                    | FrameworkPropertyMetadataOptions.Journal
                    | FrameworkPropertyMetadataOptions.AffectsRender,
                    new PropertyChangedCallback(OnValueChanged))
                );


        public double Value
        {
            get => (double)GetValue(ValueProperty);
            set
            {
                if (Value != value)
                {
                    SetValue(ValueProperty, value);
                }
            }
        }

        public double Step
        {
            get => (double)GetValue(StepProperty);
            set
            {
                if (Step != value)
                {
                    SetValue(StepProperty, value);
                }
            }
        }

        private static void OnValueChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var spinBox = d as MySpinBox;
            if (spinBox != null)
            {
                spinBox.txtBoxValue.Text = e.NewValue.ToString();
            }
        }
    }

接下来我们在
MainWindow.xaml
中增加刚刚编写好的
MySpinBox
组件

<Window x:Class="SpinBox.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:SpinBox"
        mc:Ignorable="d"
        Title="MainWindow" Height="450" Width="800">
    <Grid>
        <local:MySpinBox MaxHeight="64" MaxWidth="128" Step="2" Value="5"/>
    </Grid>
</Window>

增加事件处理

我们在自定义组件中增加按钮组件的响应

<Button Grid.Row="0" x:Name="btnPlus" Click="btnPlus_Click">&#x25B2;</Button>
<Button Grid.Row="1" x:Name="btnMinor" Click="btnMinor_Click">&#x25BC;</Button>

在C#代码中增加对应的响应逻辑就能实现完整的效果

private void btnPlus_Click(object sender, RoutedEventArgs e)
{
    Value += Step;
}

private void btnMinor_Click(object sender, RoutedEventArgs e)
{
    Value -= Step;
}

最后需要说明下的是按钮的Unicode值得十六进制表示分别是
0x25B2
和
0x25BC
。
Xaml
本质是一种
XML
文本，因此在其中表示Unicode要使用
XML
对应的语法格式。

最终效果

设想我们在一家很大的互联网公司做IT方面的规划、开发和维护，有以下这样的应用场景：

• 公司里有若干个不同的开发团队，开发语言有Java、.net、Python、C++....十来种，还有很多外包团队对项目进行开发，大中小系统已经多的数不过来；并且各个团队、系统间都需要进行海量数据的交换（比如搜索引擎实时的数据，GPS物联网实时数据，电站的实时监控数据等），如何定义一种数据格式，使得各种平台和语言都能够兼容，交换的成本最低？
• 如此多的结构化、非结构化数据都需要进行存储，有几百个哈杜集群、数十万台、百万台服务器，数据存储在Hbase、RocksDb或者其他自己开发的数据库结构中，对查询的实时性很高（内存表个位数毫秒、SSD十几毫秒等）。如何用一种较为统一的格式存放这些数据？

相信在大公司或者在大公司做过外包的童鞋，都接触过这样一种数据对象，那就是Bond格式，目前Bond由M$维护，官方网站：
https://github.com/microsoft/bond/
，上面提供了各种语言的示例、编译工具等。
一个基本的Bond文件如下所示：

namespace School

struct Student
{
    0: string Name;
    1: uint8 Age;
    2: bool IsBoy;
    3: optional vector<string> Interests;
}

这里定义了一个学校的命名空间，里面有个学生类，学生类里面有四个字段，依次是姓名、年龄、是否为男孩、兴趣爱好的列表(可选)。

很容易看出Bond结构实际是与平台和语言无关的，它是一个DSL，在不同的平台上，利用Bond编译工具
gbc
，可以把Bond文件编译成不同的类，然后就可以赋值、存储和传输了，编译好的Bond原生支持RPC调用。

Bond支持的数据类型有：

• 基本类型：int8, int16, int32, int64, uint8, uint16, uint32, uint64, float, double, bool, string, blob等，需要注意java平台没有uint类型，会编译成带有符号的同类型，数据会丢失精度（正数变成负数）；
• 列表 vector、字典 map
• 枚举 enum
• 默认值
• 可选字段 optional，必须字段 required
• 可空字段 nullable
• 支持类的继承
• 支持字段的修饰 Attribute，这对前端验证和数据库存储比较有用，能定义字段长度、范围、列族等

这些类型能很好的满足数据交换和存储的需要；除此以外，Bond是一种非常高效的数据存储格式，它的二进制序列化最大程度去除了元数据的影响，极其紧凑，我们来看一个示例：

ListingItem是一个Bond类型，它的结构定义如下：

struct ListingItem
{
    1: required uint64 xxxxxxxxx; 
    2: required uint8 xxxxxxxxx; 
    3: optional uint16 score;
    4: optional vector<xxxx> xxxxxxxxxxx;
    5: optional map<xxxxxx, uint16> xxxxxxxxx; 
    6: optional xxxxxx xxxxxxxxxxx = Exxxxx;
    7: optional bool IsDeleted;
    8: optional vector<xxxxxxxx> xxxxxxxxList = nothing;
}

由于牵涉到生产环境的真实数据，所以一些字段和引用使用xxxxx来代替了，这个类的大小中等，有各种字段，还有对其它类的引用和集合等等。

我们用随机化的方式生成一百万个类，类里面的字段和引用都不一样，数值都是随机生成的，然后用Bond序列化和Java中带的Gson序列化方式进行序列化后的二进制长度比较，渣代码如下：

    @Test
    public void ListingItemTest() throws IOException {
        int cycleLength = 1000000;
        Random random = new Random();
        // Create 1000000 listing item
        List<ListingItem> items = new ArrayList<>();
        for(int i = 0; i < cycleLength; i ++){
            ListingItem item = new ListingItem();
            // ... 
            //赋值省略，利用random.nextLong() nextInt()等给字段赋值
            // ...
            items.add(item);
        }

        StopWatch stopWatch = new StopWatch();
        int length = 0;
        stopWatch.start();
        //Serialization Bond Object for 1000000 times
        for(int i = 0; i < cycleLength; i ++){
            byte[] bytes = BondSerializationUtils.serializeBondToBytes(items.get(i), ProtocolType.MARSHALED_PROTOCOL);
            length += bytes.length;
        }
        stopWatch.stop();
        System.out.println(String.format("Bond Serialization %d objects cost %d ms, avg length in bytes is %d", cycleLength, stopWatch.getTime(), length / cycleLength));

        //Serialization as Json Object
        length = 0;
        stopWatch.reset();
        stopWatch.start();
        for(int i = 0; i < cycleLength; i ++){
            String json = gson.toJson(items.get(i));
            length += json.length();
        }
        stopWatch.stop();
        System.out.println(String.format("Json Serialization %d objects cost %d ms, avg length in string is %d", cycleLength, stopWatch.getTime(), length / cycleLength));
    }

在我的破笔记本(10代i5低功耗u)运行结果如下：

Bond Serialization 1000000 objects cost 1392 ms, avg length in bytes is 60
Json Serialization 1000000 objects cost 8837 ms, avg length in string is 310

由于Java字符串getBytes()后和原长度一样，所以我们可以把字符串长度看作二进制数组长度。

多运行几遍代码，可以看到，Bond序列化的速度比Gson序列化的速度快4到5倍，序列化后的大小也只有json的1/5。（使用不同的序列化协议，比如COMPACT_PROTOCOL可以进一步压缩结果大小和序列化时间，速度能比Json序列化快10倍以上）

这是个了不起的成绩，如果我们生产环境中每天产生上百亿条数据，这些数据用于各种转换、分析与统计，使用Bond结构存储只有使用字符串存储空间的1/5，能够省下4/5以EB、PB计的存储成本；而且由于数据量的减少，传输和计算的成本也进一步压缩，每年在IT基础设施上的投入能节约上百亿上千亿美元，这些节省的成本最后都是利润。

最后，由于Java平台没有自带二进制序列化框架，我们用.net自带的序列化框架测试下二进制序列化和Json序列化，序列化的类如下：

    [Serializable]
    public class TAListings
    {
        public string LxxxxxxxxList { get; set; }
        public string Titles { get; set; }
        public string CxxxxxxxxxxxxxxList { get; set; }
        public string CxxxxxxxxxxxxxxxxList { get; set; }
    }

代码如下：

TAListings listings = new TAListings() { CxxxxxxxxxxxxxxxxList= "5033333309:-:73333333333334,34444444442:-:744444444442,54444444449:-:744444444444444448,544444443:-:744444444444444" };

var binSerilization = BinaryHelper.Serialize(listings);
var jsonSerilization = JsonHelper.Serialize(listings);

Console.WriteLine(string.Join(" ", binSerilization.Select(f => f.ToString("x2"))));
Console.WriteLine("Binary Serilization Length: " + binSerilization.Length);
Console.WriteLine();
Console.WriteLine(jsonSerilization);
Console.WriteLine("Json Serilization UTF8 Length: " + Encoding.UTF8.GetByteCount(jsonSerilization));
Console.ReadLine();

结果如截图所示：

可以看到，如果只是普通的类，在.net使用二进制序列化后，反而比json序列化大了不少，增加的长度在二到四倍左右不等，这很反常识，是因为.net二进制序列化需要存储更多的元数据吗？

大家对我的文章有什么问题和建议，都希望能够参与讨论，谢谢大家！

DPP能够对目标检测proposal进行非统一处理，根据proposal选择不同复杂度的算子，加速整体推理过程。从实验结果来看，效果非常不错

来源：晓飞的算法工程笔记 公众号

论文: Should All Proposals be Treated Equally in Object Detection?

• 论文地址：
  https://arxiv.org/abs/2207.03520
• 论文代码：
  https://github.com/liyunsheng13/dpp

Introduction

在目标检测中，影响速度的核心主要是密集的proposal设计。所以，Faster RCNN → Cascade RCNN → DETR → Sparse RCNN的演变都是为了稀疏化proposal密度。虽然Sparse R-CNN成功地将proposal数量从几千个减少到几百个，但更复杂deation head导致减少proposal数量带来的整体计算收益有限。

复杂的deation head结构虽然能带来准确率的提升，但会抹杀轻量级设计带来的计算增益。对于仅有300个proposal的Sparse RCNN，deation head的计算量是主干网络MobileNetV2的4倍（25 GFLOPS 与 5.5 GFLOPS）。

为此，作者研究是否有可能在降低deation head计算成本的同时保留精度增益和proposal稀疏性。现有检测算法采用相同复杂度的操作处理所有proposal，在高质量proposal上花费大量的计算是合适的，但将相同的资源分配给低质量的proposal则是一种浪费。由于每个proposal的IoU在训练期间是已知的，所以可以让检测器学习为不同的proposal分配不同的计算量。

由于在推理时没有IoU，网络需要学习如何根据proposal本身进行资源分配。为此，作者提出了dynamic proposal processing（DPP），将detection head使用的单一算子替换为一个包含不同复杂度算子的算子集，允许检测器在复杂度-精度之间进行权衡。算子的选择通过增加一个轻量级选择模型来实现，该模型在网络的每个阶段选择适用于每个proposal的最佳算子。

Complexity and Precision of Proposals

假设主干网络产生了一组proposal
\(X = \{x_1, x_2, \cdots, x_N \}\)
，计算消耗主要来源于detection head而主干的计算消耗可忽略，并且将deation head的计算进一步分解为per-proposal的算子
h
（网络结构）以及对应的proposal间处理组件
p
（
NMS
操作或proposal之间的的自注意机制）。

• Complexity of unequally treated proposals

在之前的检测器中，所有的proposal都由同一个算子
h
处理：

其中
\(\psi = \{h, p\}\)
，
\(C_h\)
和
\(C_p\)
分别是
h
和
p
的 per-proposal 复杂度。

• Complexity of unequally treated proposals

与其将相同的算子
h
应用于所有proposal，作者建议使用包含
J
个具有不同复杂度算子的算子集
\(\mathcal{G} = \{h_j\}^J_{j=1}\)
，由动态选择器
s
选择具体的算子分配给proposal
\(x_i\)
：

其中
\(s_i = s(x_i)\)
，
\(h_{s_i}\in \mathcal{G}\)
表示来自
\(\mathcal{G}\)
的算子，由选择器
s
分配给的proposal
\(x_i\)
，
\(\psi = \{\{h_{s_i}\}_i, s, p\}\)
，
\(C_{h_{s_i}}\)
为整个per-proposal操作的计算复杂度。为简单起见，
p
的复杂度仍然视为常数。

• Precision over proposals

当deation head对proposal非统一处理时，给定复杂性约束
C
的最佳检测器精度可以通过优化算子对proposal的分配来提升：

其中
\(\mathcal{P}(\{h_{s_i}\}_i)\)
是分配的特定运算符
\(\{h_{s_i}\}_i\)
的精度。随着
C
的变化，
\(P(\psi^{∗}|C)\)
构建了复杂度-精度(C-P)曲线，该曲线表示了可使用
\(\mathcal{G}\)
实现的目标检测器在成本和精度之间trade-off的最佳性能。

Dynamic Proposal Processing

基于上面的背景，作者提出了一个动态proposal处理（DPP）。假设detection head由多个阶段(
\(\psi = \phi_1 \circ \cdots \circ \phi_K\)
)依次处理proposal，每个阶段
\(\varphi_K\)
由选择器
s
从
\(\mathcal{G}\)
中选择的运算符实现。为了最小化复杂性，选择器每次只应用于阶段子集
\(k \in K \subset \{1，\cdots，K\}\)
，其余阶段使用上一次处理选择的运算符，即
\(\phi_k = \phi_{k−1}, \forall k\notin K\)
。

Operator Set

作者提出了由三个计算成本差异较大的算子组成的算子集合
\(\mathcal{G} = \{g_0, g_1, g_2\}\)
：

• \(g_0\)
  是高复杂度的算子，由一个参数与proposal相关的动态卷积层(DyConv)和一个前馈网络(FFN)来实现，类似于Sparse R-CNN采用的动态Head结构。
• \(g_1\)
  是一个中等复杂度的算子，由FFN实现。
• \(g_2\)
  是一个由identity block构建的轻量级算子，只是简单地传递proposal而无需进一步提取特征。

Selector

在DPP中，通过控制操作符对proposal的分配，选择器是控制精度和复杂性之间权衡的关键组件。定义
\(z^k_i\)
是proposal
\(x_i\)
在阶段
\(\phi_k\)
的输入特征，选择器由3层MLP实现，输出与关联
\(z^k_i\)
的3维向量
\(\epsilon^k_i \in [0, 1]^3\)
：

其中
\(\epsilon^k_{i,j}\)
是
\(\epsilon^k_i\)
中的选择变量，代表将操作
\(g_j\)
分配给proposal
\(x_i\)
的权重：

• 在训练期间，选择向量是包含三个变量one hot编码，将Gumble-Softmax函数作为MLP的激活函数，用于生成选择向量。
• 在推理中，选择向量包含三个连续值，选择值最大的变量对应的操作。

分配过程如图2所示，整体开销非常小（100个proposal仅需4e-3 GFLOPS），与detection head相比可以忽略不计。

从公式4可以看出，不同的proposal和阶段选择的算子都有变化，从而能够进行动态处理。
此外，虽然
\(\mathcal{G}\)
仅有三个候选项，但潜在的detection head网络结构有
\(3^{|K|}\)
种。最后，由于选择器是可训练的，所以整体结构可以端到端学习。

Loss Functions

为了确保在给定复杂度的情况下，DPP能为每个proposal选择最优的操作序列，作者增加了选择器损失，包含两个目标：

• 首先，应该将复杂的算子（
  \(g_0\)
  和
  \(g_1\)
  ）分配给高质量的proposal（高IoU）：
  
  其中
  \(u_k\)
  是第
  i
  个proposal在第
  k
  阶段的 IoU。当IoU小于0.5时，
  \(L_{iou}\)
  推动选择器将
  \(\epsilon^k_{i,0}\)
  和
  \(\epsilon^k_{i,1}\)
  变为0，反之则变为1，鼓励在阶段 k 中使用更复杂的算子来获得高质量的proposal。此外，损失的大小是由IoU值决定的，为高IoU proposal选择简单结构或为低IoU proposal选择复杂结构均会产生大梯度值。

• 其次，选择器应该知道每张图像中的实例总数，并根据总数调整整体复杂度，在实例密集时选择更复杂的算子：
  
  其中
  T
  是特定图像选择
  \(g_0\)
  算子目标次数，定义为
  \(T = \alpha M\)
  ，即图像中
  M
  个实例的倍数。此外，
  \(T\in [T_{min}, N ]\)
  需通过根据预先指定的下限
  \(T_{min}\)
  和由总体proposal数
  N
  给出的上限对
  \(\alpha M\)
  进行裁剪。下界防止对高复杂度算子进行过于稀疏的选择，然后
  \(\alpha\)
  则是根据实例数调整选择器。

最终的整体选择器损失为：

选择器损失是一种即插即用损失，可以应用于不同的对象检测器。在实现时，与应用DPP的原始检测器的所有损失相结合，包括交叉熵损失和边界框回归损失。

Experiments

DPP的主干网络使用MobileNet V2或ResNet-50，使用特征金字塔网络(FPN)生成多维特征，在其之上使用Sparse R-CNN的策略学习初始proposal。为简单起见，选择器仅应用于阶段
\(K = \{2, 4, 6\}\)
。

对于损失函数，设置
\(\lambda=1\)
，
\(T_{min}=1\)
，
\(\alpha=2\)
，
\(N=100\)
。

Proposal processing by DPP

• Contribution of Each Operator

不同候选算子对性能的贡献。

• Performance of Each Stage in DPP

阶段1∼6的AP分别为
\(\{15.6, 32.1, 39.3, 41.7, 42.0, 42.2\}\)
，精度在前 4 个阶段迅速增加，然后达到饱和。较后的阶段，复杂算子占比越少，这说明 DPP 如何在复杂性与精度之间取得相当成功。

• Visualization

阶段4和阶段6中，
\(g_0\)
的预测结果。

Main Results

• ResNet

基于ResNet50与SOTA算法对比。

• MobileNetV2

基于MobileNetV2与SOTA算法对比。

• Inference speed

推理速度对比。

Ablation Study

• Selection loss

选择器损失的作用。

• Target number of heavy operators

复杂算子预期数量的作用。

Conclusion

DPP能够对目标检测proposal进行非统一处理，根据proposal选择不同复杂度的算子，加速整体推理过程。从实验结果来看，效果非常不错。

如果本文对你有帮助，麻烦点个赞或在看呗～
更多内容请关注 微信公众号【晓飞的算法工程笔记】

前言

不知道你们有没有遇到过这么一种情况，直接用树莓派的引脚输出PWM控制舵机，舵机是会出现抖动的。就算代码进行一定的时延迟优化还是会有影响的。

现在我们可以使用
PCA9685
这个模块去驱动舵机。

PCA9685 是一种常用的 PWM（脉冲宽度调制）驱动器芯片，通常用于控制舵机、电机和其他需要精确控制的设备。该芯片可以通过 I2C 总线与微控制器或单片机通信，以实现对多路 PWM 信号的生成和控制。

16 路 PWM 输出：PCA9685 可以同时控制最多 16 路 PWM 输出，每路输出的占空比都可以独立设置，但是16路PWM频率一样。

12 位分辨率：PCA9685 提供了 12 位分辨率的 PWM 输出，可以实现精细的输出控制。

内部振荡器：芯片内部集成了振荡器，可以产生稳定25MHz的时钟信号，无需外部晶振。

可编程频率：可以通过配置寄存器来设置 PWM 输出的频率，范围从 24 Hz 到 1526 Hz。

I2C 接口：使用标准的 I2C 串行总线接口与主控设备通信，方便集成到各种微控制器系统中。

输出驱动能力：每路 PWM 输出都具有较强的驱动能力，可以直接驱动舵机或者其他负载。

接线

1. PCA9685绿端VCC和GND要和电池的正负极相连。
2. PCA9685控制端的GND和VCC和树莓派的3.3v（pin1）和GND（pin9）相连。
3. PCA9685的SCL和SDA和树莓派的SCL0（pin5）以及SDA0（pin3）相连。

安装PCA9685驱动

adafruit/Adafruit_CircuitPython_PCA9685: Adafruit CircuitPython driver for PCA9685 16-channel, 12-bit PWM LED & servo driver chip. (github.com)

在树莓派终端输入：

pip3 install adafruit-circuitpython-pca9685

或者输入：

sudo pip3 install adafruit-circuitpython-pca9685

如果只是想下载虚拟环境到你当前的项目里可以：

mkdir project-name && cd project-name
python3 -m venv .venv
source .venv/bin/activate
pip3 install adafruit-circuitpython-pca9685

安装Motor驱动

adafruit/Adafruit_CircuitPython_Motor: Helpers for controlling PWM based motors and servos (github.com)

在树莓派终端输入：

pip3 install adafruit-circuitpython-motor

或者输入：

sudo pip3 install adafruit-circuitpython-motor

如果只是想下载虚拟环境到你当前的项目里可以：

mkdir project-name && cd project-name
python3 -m venv .venv
source .venv/bin/activate
pip3 install adafruit-circuitpython-motor

测试程序

# SPDX-FileCopyrightText: 2021 ladyada for Adafruit Industries
# SPDX-License-Identifier: MIT

import time
import board
from adafruit_motor import servo
from adafruit_pca9685 import PCA9685

i2c = board.I2C()  # uses board.SCL and board.SDA
# i2c = busio.I2C(board.GP1, board.GP0)    # Pi Pico RP2040

# Create a simple PCA9685 class instance.
pca = PCA9685(i2c)
# You can optionally provide a finer tuned reference clock speed to improve the accuracy of the
# timing pulses. This calibration will be specific to each board and its environment. See the
# calibration.py example in the PCA9685 driver.
# pca = PCA9685(i2c, reference_clock_speed=25630710)
pca.frequency = 50

# To get the full range of the servo you will likely need to adjust the min_pulse and max_pulse to
# match the stall points of the servo.
# This is an example for the Sub-micro servo: https://www.adafruit.com/product/2201
# servo7 = servo.Servo(pca.channels[7], min_pulse=580, max_pulse=2350)
# This is an example for the Micro Servo - High Powered, High Torque Metal Gear:
#   https://www.adafruit.com/product/2307
# servo7 = servo.Servo(pca.channels[7], min_pulse=500, max_pulse=2600)
# This is an example for the Standard servo - TowerPro SG-5010 - 5010:
#   https://www.adafruit.com/product/155
# servo7 = servo.Servo(pca.channels[7], min_pulse=400, max_pulse=2400)
# This is an example for the Analog Feedback Servo: https://www.adafruit.com/product/1404
# servo7 = servo.Servo(pca.channels[7], min_pulse=600, max_pulse=2500)
# This is an example for the Micro servo - TowerPro SG-92R: https://www.adafruit.com/product/169
# servo7 = servo.Servo(pca.channels[7], min_pulse=500, max_pulse=2400)

# The pulse range is 750 - 2250 by default. This range typically gives 135 degrees of
# range, but the default is to use 180 degrees. You can specify the expected range if you wish:
# servo7 = servo.Servo(pca.channels[7], actuation_range=135)
servo7 = servo.Servo(pca.channels[0])

# We sleep in the loops to give the servo time to move into position.
for i in range(180):
    servo7.angle = i
    time.sleep(0.03)
for i in range(180):
    servo7.angle = 180 - i
    time.sleep(0.03)

# You can also specify the movement fractionally.
fraction = 0.0
while fraction < 1.0:
    servo7.fraction = fraction
    fraction += 0.01
    time.sleep(0.03)

pca.deinit()

参考资料

Introduction — Adafruit motor Library 1.0 documentation (circuitpython.org)

Introduction — Adafruit PCA9685 Library 1.0 documentation (circuitpython.org)