C++可调用对象

C++中都有哪些可调用对象

  1. 函数/函数指针
  2. lambda表达式
  3. 重载了()运算符后的对象
  4. std::bind的返回值
  5. 所有可调用对象都可以被相应的std::function所引用
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
#include <iostream>
#include <functional>

using namespace std;

int add(int a, int b) { return a + b; }

class Sub {
public:
  int operator()(int a, int b) { return a - b; }
};

int main() {
  function<int(int, int)> func;

  func = add;
  cout << func(1, 2) << endl;

  Sub sub;
  func = sub;
  cout << func(1, 2) << endl;

  func = [](int a, int b) { return a * b; };
  cout << func(1, 2) << endl;

  func = bind([](int a, int b) { return a / b; }, 1, 2);
  cout << func(1, 2) << endl;

  return 0;
}

更多内容 >>

自己动手写移动端推理引擎

本文的主要目的是学习和研究如何制作一个面向移动端的、高效的深度学习推理引擎，面向有一定深度学习基础知识的用户。

一、ARM基础

1.开发工具与平台

本文主要针对ARMv7-A架构，编译工具链为NDK19，使用VSCode进行开发，主要语言为C和ARM，测试设备为小米10。

2.Hello,ARM!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
.text
.global _start
_start:
    @ print a string
    mov r0, #1
    ldr r1, =msg
    ldr r2, =len
    mov r7, #4
    swi 0

    @ exit
    mov r0, #0
    mov r7, #0
    swi 0

.data
msg:    .ascii "Hello,ARM!\n"
len=    . - msg
1
2
3
4
5
6
7
8
9
export AS=$NDK_ROOT/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-as
export LD=$NDK_ROOT/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/arm-linux-androideabi-ld

$AS -o main.o main.s
$LD -s -o test main.o

adb push build/test /data/local/tmp
echo ============================================================
adb shell /data/local/tmp/test

3.寄存器和指令集

4.常用系统调用

5.与C语言的交互

附件

1.ARM指令集

2.NEON指令集

更多内容 >>

CNTK学习笔记 - 经典的卷积神经网络

卷积神经网络是深度学习中一种高效的方法，已经成为众多科学领域的研究热点之一，特别是在模式识别领域，由于该网络可以直接输入原始图像，避免对图像进行复杂前期预处理，因而得到更为广泛的应用。本文以经典的卷积神经网络为例(使用MNIST数据集，手写数字识别)，来展示如何在CNTK中构建卷积网络，关于卷积神经网络的基础知识这里不再赘述。

more >>

更多内容 >>

CNTK学习笔记 - 入门

北京时间9月16号凌晨3点半，CNTK终于发布2.2版本了（话说，定的不是9月15号吗！！！），终于支持CSharp了！于是，赶紧down下来体验一把～

后来才发现，只需要装一个Nuget包就行了，Nuget里面已经集成了所需的各种依赖，傻瓜式安装（微软式风格）。不过，Gpu版的包有200多M，cpu版的也有50多M，网速慢的话可以手动拷离线包。

CNTK以计算网络为基础（与数据流图的概念很像，表达式树有助于理解这个概念），在计算之前需要先构建好计算网络，然后准备并传入数据，就可以完成计算了。乍一看，采用这种方式似乎有点麻烦，但是如果你习惯了这种方式，你就会喜欢上她。

CNTK有几个不可忽视的优点：

  • 分离计算逻辑和实现方式，使得我们无需关注具体的实现细节。
  • 统一Cpu和Gpu，不管你的电脑有没有支持CUDA的显卡都没关系。
  • 自动微分。
  • 支持C#，支持C#，支持C#！
more >>

更多内容 >>

香农插值公式

根据香农采样定理可知，采样频率不小于连续信号频谱中最高频率2倍的离散信号，可以使用香农插值公式不失真的还原成连续信号。
插值公式如下：
$
f(t)=\sum_{n=-\infty}^{+\infty}f[n]sinc(\dfrac{t-nM}{M})
$
其中，$f[n]$表示第$n$个采样点的值，M表示采样间隔。

代码如下：

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 numpy as np
import matplotlib.pyplot as plt


def signal(t):
    """
    连续信号，频谱中有两个正弦波，周期分别为pi和pi/2，最大频率为2/pi
    :param t: 时间
    :return: 信号值
    """
    return np.sin(t) + np.sin(2 * t)


def restored(t, f, N, M):
    """
    使用香农插值公式，将离散信号还原成连续信号
    :param t: 时间
    :param f: 采样后的离散信号
    :param N: 采样的离散信号点的数量
    :param M: 采样间隔
    :return: 信号
    """
    y = 0
    for n in range(N):
        y += f[n] * np.sinc(t / M - n)
    return y


def main():
    M = np.pi / 4  # 采样间隔，采样频率要大于2倍的2/pi，采样间隔要小于pi/4
    N = 20  # 样本数量
    f = [signal(n * M) for n in range(N)]  # 离散信号点

    x = np.linspace(0, (N - 1) * M, 100)

    ax = plt.subplot(121)
    ax.set_xlabel("t")
    plt.plot(x, signal(x), label="original signal")
    plt.scatter(np.arange(0, N * M, M), f, color="red", label="samples", zorder=3)
    plt.legend()

    ax = plt.subplot(122)
    ax.set_xlabel("t")
    plt.plot(x, restored(x, f, N, M), label="restored signal")
    plt.scatter(np.arange(0, N * M, M), f, color="red", label="samples", zorder=3)
    plt.legend()

    plt.show()


if __name__ == '__main__':
    main()

更多内容 >>

记一次nan的问题

yolact是一个实时的实例分割算法，是目前分割速度最快的算法，而且生成mask的质量也很高。论文上说该算法还可以做目标检查，而且速度和准确度都能够达到(接近)YOLOv3的水平，于是就尝试了一下。将算法该成Paddle上的代码后，训练到5000多个step的时候，conf_loss突然就变成了nan。

以前遇到nan的问题都是因为学习率过大，而且是在训练初期发生的。我这里的学习率用的是0.001，应该不是学习率的问题，排除。

由于采用的是动态图编写的代码，因此可以通过一步一步的跟踪代码，来诊断错误。从loss一步步向上查找问题，发现target_logits中存在非常小的数据（负数），如下面的图：

loss代码

target_logits

target_labels

conf_loss

这个问题是由于logits太负了，导致其指数接近与0引起的。因此，首先想到的就是对logits进行裁剪，裁剪到[-10,10]之间，解决了这个问题。

注:对于log函数，如何参数是一个负数，结果中就会出现nan，而如果参数是0，结果中就会出现inf。

不过后来训练时又出现了其他nan的问题，详细观察训练记录发现，损失会出现突然变大的情况，怀疑是异常样本引起的。于是，便记录最近100个损失，如果当前的损失大于这100个的平均值的10倍，则认为是异常数据，不训练该数据。

更多内容 >>

自己动手实现SMPL算法

最近在学习3D相关的算法，遇到SMPL算法，不甚理解，所以打算自己实现一遍，毕竟————学习新知识的最好方法就是自己实现一下。
项目地址：https://github.com/killf/smpl

一、代码

model.py是加载模型文件和算法的入口。

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
import numpy as np
import pickle

from .lbs import blend_skin
from .utils import rodrigues, batch_eye


class SMPL:
    def __init__(self, model_file):
        model = pickle.load(open(model_file, "rb"), encoding='iso-8859-1')
        self.v_template = model["v_template"]  # 平均body
        self.weights = model["weights"]  # joints对顶点的权重
        self.posedirs = model["posedirs"]  # pose对顶点的影响
        self.shapedirs = model["shapedirs"].x  # shape对顶点的影响
        self.J_regressor = model["J_regressor"]  # joints回归器，根据顶点坐标估算joints坐标
        self.faces = model["f"] + 1  # faces的索引，索引从1开始

        kintree_table = model["kintree_table"]  # 运动学树
        id_to_col = {kintree_table[1, i]: i for i in range(kintree_table.shape[1])}
        self.kintree_table = {i: id_to_col[kintree_table[0, i]] for i in range(1, kintree_table.shape[1])}  # 关节点之间的父子级关系，0->父，1->子

    def __call__(self, shape=None, pose=None, trans=None):
        """
        SMPL算法
        :param shape: 10
        :param pose: 24x3
        :param trans: 3
        """
        shape = np.zeros(10) if shape is None else shape
        pose = np.zeros(24, 3) if pose is None else pose
        trans = np.zeros(3) if trans is None else trans

        v_shaped = self.v_template + self.shapedirs.dot(shape)  # shape->顶点
        v_posed = v_shaped + self.posedirs.dot((rodrigues(pose[1:]) - batch_eye(3)).ravel())  # pose->顶点

        joints = self.J_regressor.dot(v_shaped)  # 根据顶点估算的joints坐标
        vertices = blend_skin(pose, v_posed, joints, self.weights, self.kintree_table)  # 姿态影响的顶点变化
        vertices = vertices + trans.reshape((1, 3))

        joints = self.J_regressor.dot(vertices)  # 计算 pose 下 joints 位置
        return vertices, joints
more >>

更多内容 >>

简单验证码识别

最近工作中经常遇到验证码识别的问题，大部分的验证码都比较简单，代码的结构也比较类似，于是抽空总结下，便于以后参考。

简单的验证码拥有几个明显的特征：

  1. 容易去除背景色
  2. 小字符集，比如:字母和数字
  3. 字符间隔比较大，没有字符粘连
  4. 字符比较规范，没有旋转、拉伸

注:本文只针对简单验证码

先来张图看看效果~

more >>

更多内容 >>

目标检测：提取候选框

传统的目标检测（R-CNN、Fast R-CNN、Faster R-CNN）都是从提取候选框开始的，本文介绍两种提取候选框的方法。

一、使用selectivesearch提取候选框

selectivesearch是一个用Python编写的提取候选框的方法，基于skimage，项目地址：https://github.com/AlpacaDB/selectivesearch。
首先，使用pip安装selectivesearch:

1
pip install selectivesearch

然后，使用如下代码提取并查看候选框：

1
2
3
4
5
6
7
8
9
10
11
12
import selectivesearch.selectivesearch as ss
import matplotlib.pyplot as plt

img = plt.imread('img.jpg')
img_lbl, regions = ss.selective_search(img, scale=1000, sigma=0.8, min_size=50)
plt.axis('off')
plt.imshow(img)
for r in regions:
    x, y, h, w = r['rect']
    rect = plt.Rectangle((x, y), w, h, fill=False, edgecolor='red', linewidth=1)
    plt.gca().add_patch(rect)
plt.show()
more >>

更多内容 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

真正使人进步的,是不断总结。