学习 Rust【2】减少代码嵌套

结论先行:减少代码嵌套就是降低复杂度。

资源管理一向是编程中的重要任务。当一个函数要管理多个资源时,很容易出现代码嵌套层级太深的问题,尤其是调用系统或第三方 API 时。

以 C 语言代码为例,这里简化为两个资源,请您自行脑补多个资源:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int error_code = 0;
resource1 *p1 = new_resource1();
// UMU: with C++ SHOULD be `p1 != nullptr`
if (p1) {
resource2 *p2 = new_resource2();
if (p2) {
if (!deal_resources(p1, p2)) {
error_code = 3;
}
free_new_resource2(p2);
} else {
error_code = 2;
}
free_new_resource1(p1);
} else {}
error_code = 1;
}

return error_code;

上面代码最深嵌套是三层,为了减少嵌套,可以把代码改为平坦结构,降低到一层:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
resource1 *p1 = new_resource1();
if (!p1) {
free_new_resource1(p1);
return 1;
}

resource2 *p2 = new_resource2();
if (!p2) {
free_new_resource1(p1);
free_new_resource2(p2);
return 2;
}

if (!deal_resources(p1, p2)) {
free_new_resource1(p1);
free_new_resource2(p2);
return 3;
}

free_new_resource1(p1);
free_new_resource2(p2);

但这么改在资源释放时,更容易遗漏。也有人为使代码层级平坦化,会使用 goto 到函数末尾统一释放,或者更优雅点的 C++ 方式:用 try...throw...catch...finally 将所有资源包含起来管理。

Node.js 的异步回调函数也存在嵌套层级过深的问题,可以用 Promise 来平坦化,参考:

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
setTimeout(() => {
console.log('step1')
setTimeout(() => {
console.log('step2')
setTimeout(function() {
console.log('step3')
console.log('done!')
}, 1000)
}, 1000)
}, 1000)

// flatten
let timer = (text) => {
let promise = new Promise((resolve, reject) => {
setTimeout(() => {
console.log(text)
resolve()
}, 1000)
})

return promise
}

timer("step1")
.then(() => {
return timer("step2")
})
.then(() => {
return timer("step3")
})
.then(() => {
console.log("done!")
})

C++ 建议使用 RAII 思想来管理资源,获得资源后立刻放到管理对象里。如果有些资源使用得不频繁,想偷懒不去封装,则可以使用 scope_exit。go 语言更是用内置关键字 defer 来提供 scope_exit 机制。

Rust 用 scopeguard 提供 scope_exit 机制,defer! 宏和 go 的 defer 功能类似。

另外,Rust 还有 ? 操作符,也有减少嵌套的作用。比如这个任务:打开文件,如果失败就返回错误。go 是这样写的:

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import (
"os"
)

func main() {
file, error := os.Open("file.txt")
if error != nil {
panic(error)
}
defer file.Close()
}

同样功能,Rust 代码少一层:

1
2
3
4
5
6
use std::fs::File;

fn main() -> std::io::Result<()> {
let _f = File::open("file.txt")?;
Ok(())
}

学习 Rust【1】简化掉什么?

结论先行:从语法上说,Rust 基本无敌。

1. ++ 和 --

语言 有无 ++、-- 语法
C/C++/C#/Java
Go 只支持放变量后,不支持放变量前
Python/Rust/Scala

++、-- 一般是 +=、-= 的特例(除了 C++ 的迭代器),没有必要单独支持,新语言倾向于语法的单一性。

Python 的情况比较有意思,放后面是语法错误,放前面其实就是正负号,+ 写两次还是原来的数,- 写两次是负负得正,也还是原来的数。

2. 三目运算符(?:)

语言 有无 ?: 语法
C/C++/C#/Java/Swift
Go/Python/Rust/Scala

Rust 的 let = if else 就有 C 语言 ?: 的功能,即判断语句的子语句块可以有返回值。

3. 条件无需括号

语言 条件需不需要括号
C/C++/Java/Scala 需要
Go/Python/Rust/Swift 不需要

字符是能少打一个是一个,有效预防鼠标手。另外,Go 和 Rust 的语句块必须包含于 {}。

4. 异常处理

语言 异常处理机制
C/C++ 编译器扩展 try…except…finally, leave
C++/C#/Java/Scala/Swift throw, try…catch…finally
Python raise, try…except…else, try…finally
Go/Rust

5. 换行符(;)

语言 换行符
C/C++/C#/Java 必须
JavaScript/Scala/Swift 可选,有少数必须的情况
Python/Go
Rust 有是有,无是无(return),两者含义不同

Rust 有分号的是语句(statement),返回值是 (),即没有返回值。而没分号的是表达式(expression),返回值就是自身的值。

其实想说的是:有的 return 被简化掉了。省略 ; 就是省略 return,真香。但是,由于隐含 return,所以只能用于语句块的最后一行。

6. case 隐含 break

语言 case 是否隐含 break
C/C++/C#/Java 必须显式 break
Go/Rust/Swift 隐含 break

Rust 优秀在用 match 代替 switch,明确告诉大家这是新语法,而 Go/Swift 用 switch,却改变 case 行为,还多出一个 fallthrough 关键字,容易引起鲸神魂裂

人工神经网络训练方法——后向传播

人工神经网络训练方法——随机查找》介绍的随机查找方法,有点盲人摸象,所以继续介绍主流的后向传播(BackPropagation)算法。

填坑

先给随机查找做个优化!上篇中的激活函数统一使用 ReLU,其实这是不好的,输出层可以改为 Sigmoid 或 Tanh:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
inline double ActivationFunction_ReLU(double x) {
return std::max(0.0, x);
}
inline double ActivationFunction_Sigmoid(double x) {
return 1.0 / (1 + exp(-x));
}
inline double ActivationFunction_Tanh(double x) {
return (tanh(x) + 1.0) / 2;
}

double AnnRun(const double x[2], double* w) {
double f = ActivationFunction_ReLU(x[0] * w[0] + x[1] * w[1] - w[2]);
double g = ActivationFunction_ReLU(x[0] * w[3] + x[1] * w[4] - w[5]);
return ActivationFunction_Sigmoid(f * w[6] + g * w[7] - w[8]);
}

原因很简单,我们已经知道 Xor 的结果不是 0 就是 1,用 ReLU 是可能大于 1 的,而 Sigmoid 和 Tanh 不会大于 1。

后向传播

理论学习:《如何直观地解释 back propagation 算法?》

原理:求导

训练时,x 和 y 都是固定的,要求的是 a 和 b,所以问题是:当 y 偏离了 delta_y,求 a 和 b 应该修正多少?

分别对 a 和 b 求偏导,则:

1
2
dy/da = x
dy/db = 1

所以

1
2
delta_a = delta_y / x
delta_b = delta_y

代码不会骗人,来一个简化的例子:

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
// BackPropagation.cpp
//

#include <iostream>

void Train(double& a,
double& b,
double input,
double expect_output,
double learning_rate)
{

double delta_y = expect_output - (input * a + b);
if (input != 0) {
a += (delta_y / input) * learning_rate;
}
b += delta_y * learning_rate;
}

int main() {
// 要求的函数是:y = 2 * x + 3
const double input[4] = {0, 1, 2, 3};
const double expect_output[4] = {3, 5, 7, 9};

// 初始化状态是:y = 1 * x + 4
double a = 1.0;
double b = 4.0;

std::cout << "Initial: y = " << a << " * x + " << b << "\n";

// 两轮就搞定了
for (int t = 0; t < 2; ++t) {
for (int i = 0; i < 4; ++i) {
Train(a, b, input[i], expect_output[i], 1);
}
}
std::cout << "Trained: y = " << a << " * x + " << b << "\n";

return 0;
}

人工神经网络训练方法——随机查找

人工神经网络究竟是什么鬼?》中没有讲到如何训练神经网络,本篇延续用 XOR 运算为例,介绍一种随机查找的训练方式,主要原理是:随机初始化 w,计算错误率,在循环中,保存错误率小的 w,直到错误率小于等于 0.01 为止。

代码不会骗人,简单的实现如下:

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
// TrainXor_RandomSearch.cpp
// UMUTech @ 2018-07-05 23:45:52
// Be aware that I'm only a novice to ANN. My apologies for any wrong info.
//
#include <algorithm>
#include <iostream>
#include <random>

std::default_random_engine random_engine;

void RandomizeW(double* w, size_t size) {
std::uniform_real_distribution<double> r(0, 1);
for (size_t i = 0; i < size; ++i) {
w[i] = r(random_engine);
}
}

void PrintW(double* w, size_t size) {
for (size_t i = 0; i < size; ++i) {
std::cout << i << "\t" << w[i] << "\n";
}
}

double ActivationFunction(double x) {
// ReLU
return std::max(0.0, x);
}

double AnnRun(const double x[2], double* w) {
// bias 乘了 -1,让结果更好地收敛到 [0, 1]
double f = ActivationFunction(x[0] * w[0] + x[1] * w[1] - w[2]);
double g = ActivationFunction(x[0] * w[3] + x[1] * w[4] - w[5]);
return ActivationFunction(f * w[6] + g * w[7] - w[8]);
}

int main() {
const double input[4][2] = {{0, 0}, {0, 1}, {1, 0}, {1, 1}};
const double expect_output[4] = {0, 1, 1, 0};

double last_error = 1000;

double w[3 * 3];
double w_copy[3 * 3];

std::random_device rd;
random_engine.seed(rd());

int train_count = 0;
for (; last_error > 0.01; ++train_count) {
if (train_count % 10000 == 0) {
std::cout << "Randomize\n";
RandomizeW(w, _countof(w));
}

memcpy(w_copy, w, sizeof(w));

// 随机改变 w
std::uniform_real_distribution<double> r(-0.5, 0.5);
for (int i = 0; i < 3 * 3; ++i) {
w[i] += r(random_engine);
}

double error = pow(AnnRun(input[0], w) - expect_output[0], 2.0);
error += pow(AnnRun(input[1], w) - expect_output[1], 2.0);
error += pow(AnnRun(input[2], w) - expect_output[2], 2.0);
error += pow(AnnRun(input[3], w) - expect_output[3], 2.0);

if (error < last_error) {
// 错误率更小,保存
last_error = error;
} else {
// 恢复 w
memcpy(w, w_copy, sizeof(w));
}
}

printf("Finished in %d loops.\n", train_count);

PrintW(w, _countof(w));

/* Run the network and see what it predicts. */
printf("Output for [%1.f, %1.f] is %1.f.\n", input[0][0], input[0][1],
AnnRun(input[0], w));
printf("Output for [%1.f, %1.f] is %1.f.\n", input[1][0], input[1][1],
AnnRun(input[1], w));
printf("Output for [%1.f, %1.f] is %1.f.\n", input[2][0], input[2][1],
AnnRun(input[2], w));
printf("Output for [%1.f, %1.f] is %1.f.\n", input[3][0], input[3][1],
AnnRun(input[3], w));

return 0;
}

效果主要看人品,可能跑个不停,也可能几乎立刻完成。一次运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Randomize
Finished in 344 loops.
0 -1.18943
1 -1.60685
2 -0.848489
3 1.28751
4 1.21697
5 0.532657
6 -2.27322
7 -0.77646
8 -1.57966
Output for [0, 0] is 0.
Output for [0, 1] is 1.
Output for [1, 0] is 1.
Output for [1, 1] is 0.

另一次:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Randomize
Finished in 444 loops.
0 1.6138
1 1.4345
2 1.33925
3 1.50895
4 1.09461
5 -0.283878
6 -2.37528
7 1.08117
8 0.239626
Output for [0, 0] is 0.
Output for [0, 1] is 1.
Output for [1, 0] is 1.
Output for [1, 1] is 0.

程序员心法三则

本文不是介绍奇技淫巧,甚至本质上并不是技术,而是态度,心法。

1.抓住问题的本质,在源头解决问题

简单地说,A 有八哥,B 依赖 A,所以导致依赖 B 的 C 出问题,您会通过修改 B 来解决问题吗?正常人都知道要先解决 A 的八哥,蛋似,稍微复杂、含蓄点的问题就有人迷糊了:

一个浮动小窗体,不希望在任务栏上出现标签。

UMU 见过有人使用了 ITaskbarList 对象的 DeleteTab 方法来删掉任务栏上的标签,很高端的做法。蛋似,不够本质,我们要的是不让它出现,而不是出现后擦掉……很早以前,explorer.exe 挂掉后,任务栏通知区域的 QQ 图标就消失了,因为当时 QQ 没有处理任务栏重建的通知消息 TaskbarCreated,重新添加图标。前面说的方法,有同样的问题,explorer.exe 重启后,标签又会出现,还要再删除一次。

正确的主流做法有两个,看情况采用:(1)、WS_EX_TOOLWINDOW;(2)、指定一个隐藏窗体为自己的拥有者。

另一个脱裤子放屁的例子:获得一个文本文件大小,然后 new 一个够大的 char 数组 p,把内容读到 p 上,最后 ::std::string str = p; delete[] p;,这个见太多次,都懒得喷了。::std::string 有 resize 方法,可以直接分配,不需要 new 一个临时数组,再 delete……

判断系统是不是 XP》,也包含了这一哲学,表面上看有好多函数可以获得系统信息,但要明白他们的本质其实有差别,不是都可以混用。

2.要有远见,没有?至少不要不见棺材不落泪!

Y2K 已经过去了,但还有一个 Y2K38,又称 Unix Millennium Bug,历史原因 Unix 时间戳是一个 32 位整数,记录从 1970 年 01 月 01 日开始的秒数,它所能保存的最大时间长度大概是 68.1 年,2038 年 1 月 19 日 03:14:07 之后。

以前硬盘容量小,也不看高清,很多代码都认为文件大小用 32 位表示就够了,结果后来出现很多 ISO、高清电影,都超过 4G……还见过有人采集流量用 32 位整形表示,时间跑久了就溢出了。

远见未必人人都有,退一步说,UMU 敢保证,有很多人即使知道 32 位不够用,还是继续用着,明知道 IPv6 已经出现了很久,还是各种硬编码,认为 IP 地址一定是 IPv4 的地址。态度问题!

3.不要姑息养奸

遇到不合理的情况,UMU 认为应该给力地告诉该知道的人。比如,函数不希望入参是某指,可是调用者偏偏就输入了那个值,怎么办?打印调试信息?不够给力,容易被忽视,应该中断一下,告诉开发者。

配置文件字段被改错,怎么办?如果这个文件是技术人员维护的,应该抛出异常,死给修改配置文件的人看;如果是一般的最终用户,那应该弹出界面,友好提示哪里、怎么错了。

早期,很多程序员为了避免头文件被重复包含,就用了以下代码:

1
2
3
4
#ifndef XXX
#define XXX
// 各种语句
#endif

后来,大家喜欢用 #pragma once,省事,又不容易漏掉最后的 #endif。但是这样做之后会……姑息养奸!除非十分通用的工具类,对严谨的人来说,重复包含是不应该的!所以应该这样:

1
2
3
4
5
#ifdef XXX
#error "您不严谨了!"
#endif
#define XXX
// 各种语句

有重复包含立刻告警,而且都是集中在开头,不存在漏掉 #endif 的问题。

态度问题!这里只是举几个简单的例子~