深度学习清单

more >>

更多内容 >>

欧拉公式及证明

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

证明

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

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

more >>

更多内容 >>

带有先验的SMPLX

随机姿态的SMPLX模型可能千奇百怪，想生成一个随机的真实人体需要包含一些人体先验知识。
human_body_prior(VPoser)是一个变分自编码器，用于将人体姿态嵌入到隐空间，也可以将隐空间里的随机向量，映射为一个真实存在的姿态。
项目地址：https://github.com/nghorbani/human_body_prior

使用pip从github中进行安装，pypi中的版本比较老，而且官方版本在window平台下有一些问题。

1
pip install git+https://github.com/killf/human_body_prior.git

要想直接使用VPoser，还需要从官网下载训练好的模型，代码如下：

1
2
3
4
5
from human_body_prior.tools.model_loader import load_model
from human_body_prior.models.vposer_model import VPoser

vp = load_model("/3D/vposer_v2_05", model_code=VPoser, remove_words_in_model_weights='vp_model.')[0]
pose = vp.sample_poses(1)

将pose参数转换为3D模型：

1
2
3
4
5
6
import smplx

model = smplx.create("/3D/models/smplx/SMPLX_FEMALE.npz", model_type="smplx")
output = model(body_pose=pose["pose_body"], return_verts=True)
vertices = output.vertices.detach().cpu().numpy().squeeze()
joints = output.joints.detach().cpu().numpy().squeeze()
more >>

更多内容 >>

基于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()

更多内容 >>

基于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()

更多内容 >>

基于MindSpore的Mnist手写数字分类

发现一个华为出的深度学习框架，同时支持静态图和动态图，尝试一下，将代码收藏起来方便以后使用。

需要先下载数据集:

1
2
3
4
5
mkdir -p ./data/train ./data/test
wget -NP ./data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-labels-idx1-ubyte --no-check-certificate
wget -NP ./data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-images-idx3-ubyte --no-check-certificate
wget -NP ./data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-labels-idx1-ubyte --no-check-certificate
wget -NP ./data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-images-idx3-ubyte --no-check-certificate

代码如下:

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
import mindspore
from mindspore import context, nn, dataset as ds
import mindspore.dataset.vision.c_transforms as CV
import mindspore.dataset.transforms.c_transforms as C
from mindspore.train.callback import ModelCheckpoint, CheckpointConfig, Callback

import numpy as np
import os

context.set_context(mode=context.GRAPH_MODE, device_target="GPU")


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

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

        self.act = nn.ReLU()
        self.flatten = nn.Flatten()

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

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

        x = self.flatten(x)

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


def create_dataset(data_path, mode="train", batch_size=256, repeat_size=1, num_workers=4):
    # define dataset
    mnist_ds = ds.MnistDataset(os.path.join(data_path, mode))

    # using map to apply operations to a dataset
    if mode == "train":
        mnist_ds = mnist_ds.map(operations=CV.RandomResizedCrop((28, 28), scale=(0.8, 1.2)), input_columns="image", num_parallel_workers=num_parallel_workers)

    mnist_ds = mnist_ds.map(operations=C.TypeCast(mindspore.dtype.int32), input_columns="label", num_parallel_workers=num_workers)
    mnist_ds = mnist_ds.map(operations=CV.Rescale(1.0 / 255.0, 0), input_columns="image", num_parallel_workers=num_workers)
    mnist_ds = mnist_ds.map(operations=CV.HWC2CHW(), input_columns="image", num_parallel_workers=num_workers)

    # process the generated dataset
    if mode == "train":
        mnist_ds = mnist_ds.shuffle(buffer_size=10000)
    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)
    mnist_ds = mnist_ds.repeat(repeat_size)

    return mnist_ds


class Solver(Callback):
    def __init__(self, epochs=100, batch_size=32, lr=0.01, data_dir="./data", num_workers=1):
        self.train_data = create_dataset(data_dir, "train", batch_size, 1, num_workers)
        self.val_data = create_dataset(data_dir, "test", batch_size, 1, num_workers)

        self.net = LeNet()
        self.loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
        self.optimizer = nn.Momentum(self.net.trainable_params(), lr, 0.9, weight_decay=1e-4)
        self.model = mindspore.Model(self.net, self.loss, self.optimizer, metrics={"Accuracy": nn.Accuracy()})

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

        self._loss_ls = []

    def train(self):
        config_ck = CheckpointConfig(save_checkpoint_steps=100, keep_checkpoint_max=16)
        ck_cb = ModelCheckpoint(prefix="lenet", directory=self.output_dir, config=config_ck)

        self.model.train(self.epochs, self.train_data, callbacks=[ck_cb, self], dataset_sink_mode=False)

    def epoch_begin(self, run_context):
        self._loss_ls.clear()

    def step_end(self, run_context):
        cb_params = run_context.original_args()
        loss = float(cb_params.net_outputs.asnumpy())

        self._loss_ls.append(loss)
        step = (cb_params.cur_step_num - 1) % cb_params.batch_num + 1
        print(f"[Epoch {cb_params.cur_epoch_num}/{cb_params.epoch_num}] "
              f"Step={step}/{cb_params.batch_num} "
              f"Loss={loss:.4f}/{np.mean(self._loss_ls):.4f}",
              end="\r", flush=True)

        if step == cb_params.batch_num:
            acc = self.model.eval(self.val_data, dataset_sink_mode=False)
            acc = float(acc["Accuracy"])
            print(f"\n[VAL] Accuracy={acc:.4f}\n")


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

更多内容 >>

可视化SMPLX

SMPLX是一个带手势和表情的线性人体模型，官方地址：smpl-x.is.tue.mpg.de，需要注册后才能下载模型。

官方提供的smplx算法是基于pytorch的，可以直接使用pip进行安装。

1
pip install smplx

现在还不能直接使用，需要到官网下载对应的模型。

这里使用随机参数来创建一个模型，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
import smplx
import torch

model = smplx.create("/data/3D/models/smplx/SMPLX_FEMALE.npz",model_type="smplx")

betas = torch.randn([1, model.num_betas], dtype=torch.float32)
expression = torch.randn([1, model.num_expression_coeffs], dtype=torch.float32)
body_pose = torch.randn([1, 21, 3], dtype=torch.float32)
output = model(betas=betas, expression=expression, body_pose=body_pose, return_verts=True)

vertices = output.vertices.detach().cpu().numpy().squeeze()
joints = output.joints.detach().cpu().numpy().squeeze()
more >>

更多内容 >>

三维坐标系及空间变换

给定一个原点、一个在坐标轴上的点和一个不在坐标轴上点，可以唯一的确定一个3维空间下的直角坐标系。
代码如下：

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

# 给定一个原点、一个在坐标轴上的点和一个不在坐标轴上点，可以唯一的确定一个3维空间下的直角坐标系
O = np.array([1., 1., 1.])
X = np.array([2., 3., 4.])
P = np.array([2., 3., 5.])

# 1.确定x方向
x = X - O
x = x / np.linalg.norm(x)

# 2.确定y方向
p = P - O
y = p - np.dot(p, x) * x
y = y / np.linalg.norm(y)

# 3.确定z方向
z = np.cross(x, y)

# 4.验证
print(np.dot(x, y), np.dot(y, z), np.dot(z, x))
print(np.linalg.norm(x), np.linalg.norm(y), np.linalg.norm(z))

使用原点和一组正交基来表示一个坐标系，将坐标由原空间变换到目标空间，就是求向量在每个基上的投影，将坐标由目标空间变换到原空间，就是求基的线性组合。
代码如下：

1
2
3
4
5
6
7
# 5.坐标变换：原空间->目标空间
S = np.array([4, 4, 4])
T = np.dot(np.stack([x, y, z]), S - O)

# 6.坐标变化：目标空间->原空间
N = np.dot(np.stack([x, y, z], axis=1), T) + O
print(np.allclose(S, N))

由正交基组成的矩阵，其逆与转置相同，代码如下：

1
2
3
# 7.由正交基组成的矩阵，其逆矩阵和转置矩阵相同
b = np.stack([x, y, z], axis=1)
print(np.allclose(b.T, np.linalg.inv(b)))

更多内容 >>

OpenCV

一、基础操作

1.安装OpenCV

使用如下命令安装OpenCV：

1
pip install opencv-python

要使用OpenCV，首先需要引入：

1
2
import cv2
print(cv2.__version__)

2.读入图像

OpenCV有多种方式读取图像，常用的有彩色模式和灰度模式。

1
2
im = cv2.imread("icon.jpg") # 读取彩色图像
im = cv2.imread("icon.jpg", cv2.IMREAD_GRAYSCALE) # 读取灰度图像

注意：读取的图像是bgr格式的numpy.ndarray对象。

3.显示图像

使用cv2.imshow(winname, mat)函数显示图像，注意：第一个参数是窗口名，第二个才是图像。
调用显示方法后，通常要调用cv2.waitKey()函数启动消息循环，之后调用cv2.cv2.destroyAllWindows()关闭窗口。
完整代码如下：

1
2
3
4
5
6
import cv2

im = cv2.imread("icon.jpg")
cv2.imshow("icon.jpg", im)
cv2.waitKey()
cv2.destroyAllWindows()

注意：默认创建的窗口是不可以调整大小，我们可以先创建一个可调大小的窗口，之后再显示图像，完整代码如下。

1
2
3
4
5
6
7
import cv2

im = cv2.imread("icon.jpg")
cv2.namedWindow("icon.jpg", cv2.WINDOW_NORMAL) # 在拖动窗口边缘来调整窗口大小
cv2.imshow("icon.jpg", im)
cv2.waitKey()
cv2.destroyAllWindows()

4.保存图像

如下代码展示如何以灰度模式读取图像，然后再保存到文件中。

1
2
3
4
import cv2

im = cv2.imread("icon.jpg", cv2.IMREAD_GRAYSCALE)
cv2.imwrite("icon_gray.jpg", im)

更多内容 >>

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

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