香农插值公式

根据香农采样定理可知，采样频率不小于连续信号频谱中最高频率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 >>

更多内容 >>

深度学习清单

more >>

更多内容 >>

欧拉公式及证明

数学中的欧拉公式，$e^{ix}=cos(x)+i*sin(x)$，将指数、复数和三角函数几个看起来毫无关系的几个概念联系了起来，并导出了著名“上帝公式”：$e^{i\pi}+1=0$

证明

为了将指数和三角函数联系起来，需要分别将二者变换到相同的域中，首先想到的就是泰勒公式。泰勒公式可以将任意函数变换成多项式形式，公式如下：

取$x_0=0$，则公式可以简化为：

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 >>

更多内容 >>

基于PyTorch的Mnist手写数字分类

相比于静态图，动态图更灵活、易读，特别是在编写条件语句、循环语句时很方便，非常适合算法研究。
本文通过一个简单的Mnist手写数字识别案例，演示PyTorch中动态图的使用方法。

代码如下:

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
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from torchvision.datasets.mnist import MNIST
from torchvision.transforms import ToTensor
import torch_dataset_mirror


class LeNet(nn.Module):
    def __init__(self, classes_num):
        super(LeNet, self).__init__()

        self.conv1 = nn.Conv2d(1, 32, 5)
        self.pool1 = nn.MaxPool2d(2, stride=2)
        self.conv2 = nn.Conv2d(32, 64, 5)
        self.pool2 = nn.MaxPool2d(2, stride=2)

        self.act = nn.ReLU()

        self.fc1 = nn.Linear(1024, 512)
        self.dropout = nn.Dropout(0.5)
        self.out = nn.Linear(512, classes_num)

    def forward(self, x):
        x = self.pool1(self.act(self.conv1(x)))
        x = self.pool2(self.act(self.conv2(x)))

        x = torch.flatten(x, start_dim=1)

        x = self.fc1(x)
        x = self.dropout(x)
        x = self.out(x)

        x = torch.softmax(x, dim=-1)
        return x


def train():
    train_dataset = MNIST('./data/', train=True, transform=ToTensor(), download=True)
    test_dataset = MNIST('./data/', train=False, transform=ToTensor(), download=True)

    train_data = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
    test_data = DataLoader(test_dataset, batch_size=32)

    net = LeNet(10)
    if torch.cuda.is_available():
        net = net.cuda()

    if os.path.exists("LeNet.pkl"):
        net.load_state_dict(torch.load("LeNet.pkl"))

    optimizer = torch.optim.Adam(net.parameters(), 0.001)
    for epoch in range(10):
        for step, (x, y_true) in enumerate(train_data, 1):
            if torch.cuda.is_available():
                x = x.cuda()
                y_true = y_true.cuda()

            y_pred = net(x)
            loss = F.cross_entropy(y_pred, y_true)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            if step % 100 == 0:
                y_pred = torch.argmax(y_pred, dim=-1)
                acc = (y_pred == y_true).float().mean()
                print(f"Epoch:{epoch} Step:{step}, Loss:{loss:05f}, Acc:{acc:05f}")

        with torch.no_grad():
            acc, count = 0, 0
            for x, y_true in test_data:
                if torch.cuda.is_available():
                    x = x.cuda()
                    y_true = y_true.cuda()

                y_pred = net(x)
                y_pred = torch.argmax(y_pred, dim=-1)
                acc += (y_pred == y_true).float().sum()
                count += y_true.size(0)

            acc /= count
            print(f"[VAL]Epoch:{epoch}, Acc:{acc:05f}")
            print()

        torch.save(net.state_dict(), "LeNet.pkl")


if __name__ == '__main__':
    train()

更多内容 >>

基于PaddlePaddle的Mnist手写数字分类

使用PaddlePaddle写的Mnist手写数字识别，测试集准确率99.50%。

代码如下:

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
import paddle
from paddle import nn, io, vision, optimizer
import numpy as np

import os


class LeNet(nn.Layer):
    def __init__(self, num_classes=10):
        super(LeNet, self).__init__()

        self.conv1 = nn.Conv2D(1, 32, 5)
        self.pool1 = nn.MaxPool2D(2, stride=2)
        self.conv2 = nn.Conv2D(32, 64, 5)
        self.pool2 = nn.MaxPool2D(2, stride=2)

        self.act = nn.ReLU()

        self.fc1 = nn.Linear(1024, 512)
        self.dropout = nn.Dropout(0.5)
        self.out = nn.Linear(512, num_classes)

    def forward(self, x):
        x = self.pool1(self.act(self.conv1(x)))
        x = self.pool2(self.act(self.conv2(x)))

        x = paddle.flatten(x, 1)

        x = self.fc1(x)
        x = self.dropout(x)
        return self.out(x)


class Solver:
    def __init__(self, epochs=100, batch_size=32, lr=0.01):
        self.train_loader = io.DataLoader(vision.MNIST(mode="train", transform=vision.Compose([
            vision.RandomResizedCrop(28, scale=(0.8, 1.2)),
            vision.ToTensor()
        ])), batch_size=batch_size, shuffle=True)
        self.val_loader = io.DataLoader(vision.MNIST(mode="test", transform=vision.ToTensor()), batch_size=batch_size)

        self.model = LeNet()
        self.loss = nn.CrossEntropyLoss()
        self.scheduler = optimizer.lr.StepDecay(learning_rate=lr, step_size=5, gamma=0.8)
        self.optimizer = optimizer.Momentum(parameters=self.model.parameters(), learning_rate=self.scheduler, momentum=0.9, weight_decay=1e-4)

        self.epochs = epochs
        self.output_dir = "output"
        os.makedirs(self.output_dir, exist_ok=True)

    def train(self):
        for epoch in range(1, self.epochs + 1):
            self.train_epoch(epoch)

            acc = self.val_epoch()
            self.save_checkpoint(epoch, acc)

            self.scheduler.step()
            print()

    def train_epoch(self, epoch):
        loss_ls, acc_ls = [], []
        for step, (img, label) in enumerate(self.train_loader):
            pred = self.model(img)

            loss = self.loss(pred, label)
            acc = paddle.metric.accuracy(pred, label)

            self.optimizer.clear_grad()
            loss.backward()
            self.optimizer.step()

            loss, acc = float(loss), float(acc)
            loss_ls.append(loss)
            acc_ls.append(acc)
            print(f"[epoch={epoch}/{self.epochs}] "
                  f"step={step + 1:04}/{len(self.train_loader)} "
                  f"loss={loss:.4f}/{np.mean(loss_ls):.4f} "
                  f"acc={acc:.4f}/{np.mean(acc_ls):.4f} "
                  , end="\r", flush=True)
        print()

    @paddle.no_grad()
    def val_epoch(self):
        acc_ls = []
        for step, (img, label) in enumerate(self.val_loader):
            pred = self.model(img)
            acc = paddle.metric.accuracy(pred, label)

            acc = float(acc)
            acc_ls.append(acc)
            print(f"[VAL] "
                  f"step={step + 1}/{len(self.val_loader)} "
                  f"acc={acc:.4f}/{np.mean(acc_ls):.4f} ", end="\r", flush=True)
        return np.mean(acc_ls)

    def save_checkpoint(self, epoch, acc):
        model_file = os.path.join(self.output_dir, f"lenet_{epoch:04f}_{acc:.4f}.pdparams")
        paddle.save(self.model.state_dict(), model_file)

    def load_checkpoint(self, model_file):
        self.model.set_state_dict(paddle.load(model_file))


if __name__ == '__main__':
    Solver().train()

更多内容 >>

基于TensorFlow2.0的Mnist手写数字分类

相比于静态图，动态图更灵活、易读，特别是在编写条件语句、循环语句时很方便，非常适合算法研究。
本文通过一个简单的Mnist手写数字识别案例，演示TensorFlow2.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
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
import tensorflow as tf
from tensorflow.keras.layers import Conv2D, MaxPool2D, Flatten, Dense, Dropout


class LeNet(tf.keras.Model):
    def __init__(self, classes_num):
        super(LeNet, self).__init__()

        self.conv1 = Conv2D(32, 5, activation=tf.nn.relu)
        self.pool1 = MaxPool2D(2, strides=2)
        self.conv2 = Conv2D(64, 5, activation=tf.nn.relu)
        self.pool2 = MaxPool2D(2, strides=2)

        self.flatten = Flatten()
        self.fc1 = Dense(1024, activation=tf.nn.relu)
        self.dropout = Dropout(0.5)
        self.out = Dense(classes_num)

    def call(self, x, training=False):
        x = self.pool1(self.conv1(x))
        x = self.pool2(self.conv2(x))

        x = self.flatten(x)

        x = self.fc1(x)
        x = self.dropout(x)
        x = self.out(x)

        if not training:
            x = tf.nn.softmax(x)

        return x


def cross_entropy_loss(y_pred, y_true):
    if y_true.ndim == 1:
        y_true = tf.cast(y_true, tf.int64)
        cost = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)
    else:
        cost = tf.nn.softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)
    return tf.reduce_mean(cost)


def accuracy(y_pred, y_true):
    y_pred = tf.cast(y_pred, tf.int64) if y_pred.ndim == 1 else tf.argmax(y_pred, 1)
    y_true = tf.cast(y_true, tf.int64) if y_true.ndim == 1 else tf.argmax(y_true, 1)

    correct_prediction = tf.equal(y_pred, y_true)
    return tf.reduce_mean(tf.cast(correct_prediction, tf.float32), axis=-1)


def train():
    (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
    x_train = x_train.reshape((-1, 28, 28, 1)) / 255.
    x_test = x_test.reshape((-1, 28, 28, 1)) / 255.

    train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
    train_data = train_data.repeat(10).shuffle(5000).batch(32).prefetch(1)

    net = LeNet(10)
    optimizer = tf.optimizers.Adam(0.001)

    for step, (x, y_true) in enumerate(train_data, 1):
        with tf.GradientTape() as tape:
            y_pred = net(x, training=True)
            loss = cross_entropy_loss(y_pred, y_true)

        gradients = tape.gradient(loss, net.trainable_variables)
        optimizer.apply_gradients(zip(gradients, net.trainable_variables))

        if step % 4 == 0:
            acc = accuracy(y_pred, y_true)
            print(f"step:{step},loss:{loss:05f},acc:{acc:05f}")


if __name__ == '__main__':
    for dev in tf.config.experimental.list_physical_devices('GPU'):
        tf.config.experimental.set_memory_growth(dev, True)
    train()

更多内容 >>

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

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