使用Python编写RPCServer

周末抽空研究了一下vscode中的lsp，lsp是基于rpc协议的，于是就尝试做了一个简单的RPCServer。

RPCServer的使用与Flask类似，如下:

1
2
3
4
5
6
7
8
9
10
11
from rpc_server import RpcServer

app = RpcServer()


@app.method('initialize')
def initialize(params) -> str:
    return "Hello"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=7788)
more >>

更多内容 >>

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

更多内容 >>

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

更多内容 >>

nvcc使用指定版本的gcc

今天在编译custom_op时发现一个gcc的bug，我用的是Ubuntu 21.04系统，编译时报/usr/include/c++/10/chrono:428:27: internal compiler error: 段错误的错误，查了一通后解决问题。

nvcc默认使用的gcc 10.3.0，只需要在nvcc后面添加--compiler-bindir /usr/bin/gcc-x就可以了。

更多内容 >>

带有先验的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 >>

更多内容 >>

可视化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 >>

更多内容 >>

自己动手实现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 >>

更多内容 >>

使用C++编写Python扩展

C++的高效 + Python的简单 = 无与伦比的利器

总结一下使用C++编写Python扩展的方法和基本步骤，其中用到swig

通常需要4类文件，比如example.h、example.cpp、example.i、setup.py，可以任意选择你喜欢的IDE

一、example.h

头文件需要被C编译器识别，如下：

1
2
3
4
5
6
#ifndef PYTHON_EXAMPLE_H
#define PYTHON_EXAMPLE_H

int fact(int n);

#endif //PYTHON_EXAMPLE_H

二、example.cpp

1
2
3
4
5
6
7
#include "example.h"

int fact(int n) {
    if (n < 0) return 0;
    else if (n == 0) return 1;
    else return n * fact(n - 1);
}

三、example.i

swig脚本，用于生成胶水代码。注意，应当把头文件添加到生成的文件中，代码如下：

1
2
3
4
5
6
7
%module example

%{
#include "example.h"
%};

%include "example.h"

四、setup.py

用于生成python扩展的配置文件，代码如下：

1
2
3
4
5
from setuptools import setup, Extension

example_module = Extension('_example', sources=['example.cpp', 'example.i'], swig_opts=["-c++"])

setup(name="example", version="0.0.1", ext_modules=[example_module])

五、编译和测试

使用如下命令进行编译：

1
2
3
4
python setup.py build_ext --inplace     # 编译，构建扩展
python setup.py install                 # 安装到系统环境中
python setup.py devlop                  # 开发模式，不会安装到系统环境中
pip uninstall example                   # 卸载软件包

使用时，像使用普通模块一样即可:

1
2
import example
print(example.fact(10))     # 3628800

更多内容 >>

LRU算法

LRU全称Least Recently Used，即最近最久未使用算法，表示如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。时间复杂度$O(1)$，空间复杂度$O(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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
#include <iostream>

using namespace std;

template<class K, class V, class H = hash<K>, int SIZE = 1024>
class LRUCache {
private:
    struct Node {
        K key;
        V value;
        Node *hash_prev;
        Node *hash_next;
        Node *list_prev;
        Node *list_next;

        Node() = default;
    };

public:
    LRUCache() : count(0), hash_map(), head(nullptr), tail(nullptr) {}

    ~LRUCache() {
        for (Node *p = head, *n = nullptr; p; n = p->list_next, delete (p), p = n);
    }

private:
    Node *find(const K &key) {
        size_t hash_key = hash(key) % SIZE;
        for (Node *p = hash_map[hash_key].hash_next; p; p = p->hash_next) {
            if (p->key == key) {
                return p;
            }
        }
        return nullptr;
    }

public:
    bool get(const K &key, V &value) {
        Node *target = find(key);
        if (target) {
            value = target->value;
            return true;
        }

        return false;
    }

    void put(const K &key, const V &value) {
        Node *target = find(key);

        if (target) {
            target->value = value;
            if (target->list_prev)target->list_prev->list_next = target->list_next;
            if (target->list_next)target->list_next->list_prev = target->list_prev;
            target->list_prev = nullptr;
            target->list_next = head;
            head->list_prev = target;
            head = target;
            return;
        }

        target = new Node();
        target->key = key;
        target->value = value;
        target->list_next = head;
        if (head)head->list_prev = target;
        head = target;
        if (tail == nullptr)tail = target;

        size_t hash_key = hash(key) % SIZE;
        if (hash_map[hash_key].hash_prev == nullptr) {
            hash_map[hash_key].hash_prev = target;
            hash_map[hash_key].hash_next = target;
        } else {
            target->hash_prev = hash_map[hash_key].hash_prev;
            hash_map[hash_key].hash_prev->hash_next = target;
            hash_map[hash_key].hash_prev = target;
        }

        if (count<SIZE) {
            count++;
            return;
        }

        Node *new_tail = tail;
        if (tail->hash_prev)tail->hash_prev->hash_next = tail->hash_next;
        if (tail->hash_next)tail->hash_next->hash_prev = tail->hash_prev;
        delete (tail);

        tail = new_tail;
        tail->list_next = nullptr;
    }

private:
    size_t count;
    Node hash_map[SIZE];
    Node *head;
    Node *tail;
    H hash;
};
more >>

更多内容 >>

二叉树最小公共祖先

给定一个二叉树和二叉树中的两个不同节点，寻找这个两个节点的最小公共祖先。
思路是：先找到一条路径到这个两个节点中的其中一个，然后从下往上遍历这个节点的各级父节点，寻找这个节点是否包含另外一个节点。

一、算法

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
#include <iostream>
#include <vector>

struct Node {
  int value;
  Node *left;
  Node *right;

  Node(const int &value, Node *left = nullptr, Node *right = nullptr) : value(value), left(left), right(right) {}
};

Node *find_path(Node *node, Node *n1, Node *n2, std::vector<Node *> &path) {
  path.push_back(node);
  if (node == n1 || node == n2)return node;

  Node *result = nullptr;
  if (node->left && (result = find_path(node->left, n1, n2, path))) return result;
  if (node->right && (result = find_path(node->right, n1, n2, path))) return result;

  path.pop_back();
  return nullptr;
}

bool find_child(Node *node, Node *child) {
  return node == child || (node->left && find_child(node->left, child)) ||
         (node->right && find_child(node->right, child));
}

Node *find_parent(Node *node, Node *n1, Node *n2) {
  std::vector<Node *> path;
  auto n = find_path(node, n1, n2, path);
  if (!n)return n;

  Node *last = nullptr, *target = n == n1 ? n2 : n1;
  for (auto iter = path.rbegin(); iter != path.rend(); iter++) {
    Node *parent = *iter;
    if (last) {
      parent = last == parent->left ? parent->right : parent->left;
    }
    if (find_child(parent, target))return *iter;
    last = *iter;
  }

  return nullptr;
}
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

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