
> 装了这么久的 ML/AI 爱好者，我发现我对 PyTorch 中的自动微分还是一知半解，停留在知道计算图和反向传播的概念，以及能看懂和小改别人写好的代码的水平。所以自觉还得再补补课。
> 
> ~~真实动机是前女友找到了国内的研发工作，马上要回国赚大钱了，我破防了~~
> 
> 之所以存在这样的认知断层，是因为介绍自动微分的时候一般是手动计算张量，然后给读者画个计算图；而真正干活的时候一般是写一个神经网络的类，这个类继承自 `torch.nn.Module`。
> 
> 这样一包装，承载微分的张量很少被点名取用；而计算过程被一刀两段，绝大多数计算包装在了这个类的 `forward()` 方法中，但是最后一步计算模型预测和训练目标的差异 (loss)，往往留在了训练的控制流中，让人以为两者之间有什么本质区别。
> 
> 其实不然——自动微分只针对 PyTorch 张量，`torch.nn.Module` 的实例是一个包含若干参数的函数，其参数要么是 `torch.nn.Parameter`，要么是其他含参的 `torch.nn.Module` 实例的参数，（用 `.parameters()` 方法取得，常见于 optimizer 的首个参数）。每次把训练输入张量带入这个函数，中间的数学计算就会被自动微分机制记录。对于自动微分来说，这些计算和最后对 loss 的计算没什么不同。
> 
> 这个道理其实在做《[**一个 PyTorch 机器学习项目长什么样**](what-a-PyTorch-project-looks-like)》这篇笔记的时候就应该理解，而实际上没有理解，说明——
> 
> - 一来信息和知识不是同一层面的概念，相同的信息嵌入在不同元信息中，可以给出不同深度的知识；
> - 再者费曼学习法虽然像实验记录一样有让人快速恢复学习进度的好处，但也有让人沉溺于流量，忘记学习本心的危险，戒之在躁。

一个机器学习项目的过程包括：准备数据、定义模型、训练、评估效果。先来个简单例子：

```python
import torch
from torch import data,nn,optim
# Data Preparation
dataset = data.Dataset(...)
trainloader = data.DataLoader(dataset,...)
# Model Definition
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        # ...
    def forward(self, x):
        # forward calculation ...
        return x
net = Net()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
# Training
for epoch in range(2):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        # get the inputs
        inputs, labels = data
        # zero the parameter gradients
        optimizer.zero_grad()
        # forward + backward + optimize
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        # print statistics
        # ...
print('Finished Training')
# Validation
correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
```

## [张量——自动微分的对象](https://pytorch.org/tutorials/beginner/introyt/tensors_deeper_tutorial.html)

对于基本数据结构——张量，~~不应该~~ 也可以用大写的 `torch.Tensor(data)` 来创建；官方推荐的方法是小写的 `torch.tensor(data)`，产生的张量是 `data` 的拷贝，对一方的改动不反映到另一方。

如果数据已经是 `numpy.ndarray` 了，可以用 `x_tensor = torch.from_numpy(x_array)` 和 `x_array = x_tensor.numpy()` 互相转化，他们使用同一片内存，对一方的改动会反映到另一方。

更推荐的方法是用各种工厂函数，比如 

- `torch.empty()`
- `torch.zeros()`, `torch.zeros_like()`
- `torch.ones()`, `torch.ones_like()`
- `torch.eye()`
- `torch.rand()`, `torch.rand_like()`

其中在声明随机张量之前使用 `torch.manual_seed(seed)`，可以让距离该函数相同执行距离的随机数代码总是产生相同的数值：

> [https://pytorch.org/docs/stable/notes/randomness.html](https://pytorch.org/docs/stable/notes/randomness.html)
> 

### 尺寸相关

张量的尺寸是一个它本身的一个性质 `x.shape`, 属于 `torch.Size` 类。

张量之间的计算，在尺寸不同时，遵循类似 NumPy 的 broadcasting 规则。

`x.item()` 从一个单元素张量（不一定是标量）里取出它的值，返回值的数据类型不再是 PyTorch 自己的类型，而是 python 原生类型。

`x.unsqueeze(dim)` 在第 dim 个维度增加一个长度为 1 的维度。

更一般的改变形状需要 `x.reshape(*new_shape)` 和 `torch.reshape(x,new_shape)`

### 物理设备相关

一般数学函数也有 `out` 参数，可以原位写入已存在的张量，不改变原张量的 id。

原位计算是在一般数学函数名字后面加一下划线，如 `torch.sin_(x)`, `x1.add_(x2)`

张量的赋值是传递指针，而不是传递数值。数值拷贝需要 `x2 = x1.clone()`. 克隆产物会保持和之前一样的 `requires_grad` 参数值。如果原张量在计算图里，新张量不需要的话应该 `c = a.detach().clone()`

参与运算的两个张量需要在同一设备 (CPU/GPU). 创建张量的时候可以用 `device` 参数声明设备，已经创建的张量可以用 `x.to(device)` 改变设备。

### 自动微分和神经网络相关

PyTorch 中的张量都有 `requires_grad` 参数，默认为 False。

对于带有 `requires_grad=True` 参数的张量，都受到自动微分机制 autograd 的控制。

前面每个每个创建张量的函数都接受这个参数，也自动传染给对自动微分的张量进行数学计算的结果。

神经网络，也就是继承自 `torch.nn.Module` 的对象（假设实例化为 `net`），内部有两个方法`net.parameters()` 和 `net.buffers()`，它们取到的是张量的 iterator，其中前者里面的张量（绝大多数）受 autograd 控制，后者不然。

要想取得某个神经网络的单个参数，需要知道 `__init__()` 方法中的变量名，以及官网文档中的参数名（一般在 Variables 小节，比如[这个例子](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html)）

```python
class MyNetwork(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.param1 = torch.nn.Parameter(torch.zeros((5,)),requires_grad=True)
        self.linear = torch.nn.Linear(in_features=5,out_features=1,bias=True)
    def forward(self,x):
        return self.linear(x * self.param1)
net = MyNetwork()
with torch.no_grad():
    print(net.param1)
    print(net.linear.weight)
    print(net.linear.bias)
```

## [自动微分](https://pytorch.org/tutorials/beginner/introyt/autogradyt_tutorial.html)

autograd 自动根据代码动态构建计算图：

```python
a = torch.linspace(0., 2. * math.pi, steps=25, requires_grad=True)
b = torch.sin(a)
c = 2 * b
d = c + 1
out = d.sum()
```

![上述代码构成的计算图](/photos/2024-11-10-computation-graph.png)

对于数学函数 `b = f(a,*args)` 计算出来的张量 `b` ——

### `.grad_fn` 是一个函数

- 输入只有一个，尺寸需要和 `a` 的尺寸对齐 ~~（我感觉很奇怪）~~
- 输出的数量等于计算出这个张量的函数的输入的数量。
- ~~直接运行这个函数 ，基本就是把输入张量重复输出~~。从[这个问答](https://stackoverflow.com/questions/66402331/in-pytorch-what-exactly-does-the-grad-fn-attribute-store-and-how-is-it-used)来看，直接运行这个函数几乎没有意义，因为自动微分是用其他编程语言实现的，`SinBackward0` 并不是 Python 对象。
- `t.grad_fn.next_functions` 是一个 tuple，成员是 `x1` 等参数的 `.grad_fn`, 可以继续递推到工厂函数创建的张量，也就是这个计算图的叶节点。叶节点的 `.grad_fn` 为 `None`

```python
print(a.grad_fn)   # None
print(b.grad_fn)   # <SinBackward0 object at 0x000001C8E240F400>
print(c.grad_fn)   # <MulBackward0 object at 0x000001C8E240EB30>
print(d.grad_fn)   # <AddBackward0 object at 0x000001C8E240F400>
print(out.grad_fn) # <SumBackward0 object at 0x000001C8E240F190>
```

### `.backward()`

- 默认状态下，计算图的最终节点 `out` 是一个标量，也就是 0 阶张量。
    - 要想让计算图的最终节点是一个高阶张量，需要指定 `out.backward(gradient)` 参数。`gradient`和 `out` 尺寸相同，两者对应元素相乘后求和，从而成为一个标量。
    - 这种设定可以让一个张量的梯度 `.grad` 的尺寸只和自身的尺寸相等；如果允许计算从 `out` 到自身的 Jacobian 矩阵，会导致计算规模按多项式（一般是平方）增长。
- 默认状态下，一个计算图只能有一个`.backward()`，且只能执行一次。多次执行会报 `RuntimeError`: “Trying to backward through the graph a second time”。
    - 要想对完全相同的计算图做多次 `.backward()`, 需指定 `out.backward(retain_graph-True)` 参数。

### `t.grad`

- 偏导数张量 $$\partial\mathrm {out}/\partial \mathrm t$$，在最终节点运行 `.backward()` 之后，计算图中各节点的 `.grad` 会自动被 autograd 赋值
- 默认情况下，只有计算图的叶节点可以访问其 `.grad`
- 要取得中间节点的 `.grad`，需要在 `.backward()` 之前对相应张量执行 `.retain_grad()`

```python
b.retain_grad()
out.backward()

print(a.grad)   # tensor([...],...), 约等于 2 * torch.cos(a)
print(b.grad)   # tensor([2.,2.,2.,...2.],...)
print(c.grad)   # None，不是计算图的叶节点，也没有 .retain_grad()
print(d.grad)   # None，不是计算图的叶节点，也没有 .retain_grad()
print(out.grad) # None，不是计算图的叶节点，也没有 .retain_grad()
```

以上各个操作基本上符合数学的习惯。

## 张量及其微分的更新

以下设定更多的是为了工程上方便：

`.grad` 是一个张量的性质，不是最终节点和该张量两者之间的性质，也不是计算图整体的性质。

不论是 `.backward(retain_graph=True)`，还是另外构建了新的计算图并运行 `.backward()`（比如训练时加载了训练集的新一轮 batch），当一个已有 `.grad` 的张量被新的 `.backward()` 波及时，`.grad` 的新值会是旧值和本轮偏导数的相加。

如果不想要这种累加，需要主动提前将张量 `.grad` 改成 0 或者 None。

除了梯度张量的置 0，

### 手动

正常情况下，`requires_grad=True` 的张量，对其做的所有操作都会被 autograd 记录，包括赋值操作，这就导致正常情况下，不论是清空梯度，还是根据梯度更新模型的参数，会导致 auto grad 的混乱。

所以需要特殊操作，通知 autograd 某些对受控张量的改动，不需要成为计算图的一部分。

所谓的特殊操作就是 `torch.no_grad()`

```python
a = torch.arange(5.,requires_grad=True)
b = torch.sin(a)
b.backward(gradient=torch.ones_like(b))
with torch.no_grad():
    a[1] = 10
    a.grad.zero_()  # a.grad = 0
print(a)  # tensor([0,10,2,3,4], requires_grad=True)
```

在完全不涉及训练，只需要推理的环境，`with torch.inference():` 比 `with torch.no_grad():` 更节省计算资源。

### 自动

PyTorch 提供了上述操作的接口。

神经网络的参数的更新有一整个 `torch.optim` [模块](https://pytorch.org/docs/stable/optim.html#algorithms) 提供的更新参数的方式（`Optimizer` 的子类）。里面的优化器都实现了两个方法：`.step()` 和 `.zero_grad()`，前者修改参数本身的值，后者将各参数的梯度归零。

```python
class MyModel(torch.nn.Module):
    def __init__():
        # ...
    def forward(x):
        # ...
        return x
net = MyModel()
opt = torch.optim.SGD(net.parameters(),lr=0.01)
for e in range(epoch):
    # ...
    opt.step()
    opt.zero_grad()
```

如果只需要将梯度归零的话，nn.Module 也有一个 `.zero_grad()` 方法。

### `tensor` vs. `tensor.data`

看 SGD 优化器的源码的时候，看到更新权重的时候不是 `with torch.no_grad():`，而是用到了张量的 `a.data` 和 `a.grad.data`

`a` vs. `a.data`, `b.grad` vs. `b.grad.data` 的区别今天不需要知道，不应该知道。这是旧的 Variable 对象的残留，新的接口将 Variable 合并进了 Tensor，`.data` 只是为了兼容旧代码而存在的，不再推荐这种用法。


.ai | PyTorch 中的自动微分 autograd


## 一些名词

### 调试和测试

调试一般是由代码的作者进行，用于自行检查程序运行过程，是否存在思路和实现不匹配的错误，调试的代码一般和程序主体写在一起，主要包括错误处理和日志记录。简单的可以用 print 和 assert，复杂的程序可以用 logging。

测试一般由第三方进行，测试代码和程序代码分离，写测试的人甚至不需要理解程序的具体工作原理，只关注给定的输入能否得到程序宣称的输出。

### 单元测试

对一个模块、一个函数或者一个类来进行正确性检验的测试工作。

检验的方法是写一堆测试用例，把测试员拍脑袋想的输入交给相应的模块，看模块的输出是否正确；以及不合理的输入是否被程序识别，抛出异常。

单元测试全通过了不代表程序整体一定就没错误，但是单元测试通不过的程序一定有问题。

### 文档测试

文档是对代码的功能介绍，其中不免要举例子，给出实例代码和相应的输出，这个过程很像是单元测试，只不过是纯嘴炮。

文档测试就是自动寻找文档中的示例代码，运行之后，和文档中的结果进行比对。

### 集成测试

集成测试模拟用户的行为，测试各个模块之间的配合，测试结果应该保证程序可以在生产环境中工作。

## Python 中的测试

### 文件结构

上一篇文章里面提到了 src-layout，在 setuptools 的官方文档里提供了[一篇博客文章](https://blog.ionelmc.ro/2014/05/25/python-packaging/#the-structure)，里面提到，这种文件结构的一个优点就是，测试代码的文件夹一般和 `src/` 而不是 package 平级，这就导致运行测试的时候只能先（在虚拟环境里）安装待测试的包，而不会无意中出现测试的代码和用户下载到的内容不同的问题。

```
<project_name>
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── <package_name>/
│       ├── __init__.py
│       └── example.py
└── tests/
```

### 单元测试·`unittest`

`unittest` 是 Python 自带的单元测试库。

测试脚本的内容基本如下：

```
import unittest

class TestName1(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

class TestName2(unittest.TestCase):

    def test_sum(self):
        self.assertEqual(sum([1, 2, 3]), 6, "Should be 6")

    def test_sum_tuple(self):
        self.assertEqual(sum((1, 2, 2)), 6, "Should be 6")

if __name__ == '__main__':
    unittest.main()
```

- 测试用例包装在一个 class 里面，这个 class 继承自 `unittest.TestCase`
- 所有测试方法名字以 “test” 开头，能测试的性质有限，都是类自带的方法，以 `self.` 开头。支持的方法见下表，感觉 `[assertTrue(x)](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertTrue)` 和 `assertRaises(Exception)` 包打一切
- 作为 `'__main__'` 运行，运行的是自带的函数 `unittest.main()`。
- 运行时需要 python 指明脚本的文件名。安装了 nose2 这个库的话，可以直接运行 `python -m nose2`, 它会自动寻找所有的测试依次运行。（后面发现 `unittest` 好像也有自动发现功能）

| Method | Checks that | New in |
| --- | --- | --- |
|         [unittest.TestCase.assertEqual](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertEqual) | a == b |  |
|      [unittest.TestCase.assertNotEqual](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotEqual) | a != b |  |
|          [unittest.TestCase.assertTrue](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertTrue) | bool(x) is True |  |
|         [unittest.TestCase.assertFalse](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertFalse) | bool(x) is False |  |
|            [unittest.TestCase.assertIs](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIs) | a is b | 3.1 |
|         [unittest.TestCase.assertIsNot](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNot) | a is not b | 3.1 |
|        [unittest.TestCase.assertIsNone](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNone) | x is None | 3.1 |
|     [unittest.TestCase.assertIsNotNone](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsNotNone) | x is not None | 3.1 |
|            [unittest.TestCase.assertIn](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIn) | a in b | 3.1 |
|         [unittest.TestCase.assertNotIn](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotIn) | a not in b | 3.1 |
|    [unittest.TestCase.assertIsInstance](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertIsInstance) | isinstance(a, b) | 3.2 |
| [unittest.TestCase.assertNotIsInstance](https://docs.python.org/3/library/unittest.html#unittest.TestCase.assertNotIsInstance) | not isinstance(a, b) | 3.2 |

### 文档测试

[https://www.liaoxuefeng.com/wiki/1016959663602400/1017605739507840](https://www.liaoxuefeng.com/wiki/1016959663602400/1017605739507840)

Python 的文档测试用的是 `doctest` 库，写法如下：

```python
class Dict(dict):
    '''
    Simple dict but also support access as x.y style.

    >>> d1 = Dict()
    >>> d1['x'] = 100
    >>> d1.x
    100
    >>> d1.y = 200
    >>> d1['y']
    200
    >>> d2 = Dict(a=1, b=2, c='3')
    >>> d2.c
    '3'
    >>> d2['empty']
    Traceback (most recent call last):
        ...
    KeyError: 'empty'
    >>> d2.empty
    Traceback (most recent call last):
        ...
    AttributeError: 'Dict' object has no attribute 'empty'
    '''
    def __init__(self, **kw):
        super(Dict, self).__init__(**kw)

    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError(r"'Dict' object has no attribute '%s'" % key)

    def __setattr__(self, key, value):
        self[key] = value

if __name__=='__main__':
    import doctest
    doctest.testmod()
```

在保持 docstring 缩进的前提下，`>>>`  开头的注释会被当作测试运行，紧随其后的行将作为对比基准。只有当预期报错的时候，可以用 `...` 省略中间的报错信息。

### 集成测试

也可以用 `unittest` 完成。

和单元测试的区别在于，一般来说需要构建测试数据集等等。这需要重写 `unittest.TestCase.setup()`

```python
class TestComplexData(unittest.TestCase):
    def setUp(self):
        # load test data
        self.app = App(database='fixtures/test_complex.json')

    def test_customer_count(self):
        self.assertEqual(len(self.app.customers), 10000)

    def test_existence_of_customer(self):
        customer = self.app.get_customer(id=9999)
        self.assertEqual(customer.name, u"バナナ")
        self.assertEqual(customer.address, "10 Red Road, Akihabara, Tokyo")

if __name__ == '__main__':
    unittest.main()
```


.py | Python 测试笔记


> 这里所说的“别人”，也包括6个月之后，已经不记得当初如何写出这段代码的自己。
> 

很久以前写过一篇《**[import 引用现成的代码](https://mountaye.github.io/blog/articles/python-import-script-module-package)**》讲如何使用别人的代码，最后讲到一个模块的 `setup.py` 文件就没再往下写，这次继续。

- [https://packaging.python.org/en/latest/tutorials/packaging-projects/](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
- [https://setuptools.pypa.io/en/latest/userguide/quickstart.html](https://setuptools.pypa.io/en/latest/userguide/quickstart.html)

## 基本流程

- 写代码，且让代码项目文件的结构符合一定的要求（见下一节）
- 根据项目的文件结构，填写 `pyproject.toml`、`setup.cfg` **或** `setup.py` **文件**
- 安装 build 这个库，然后运行 `python -m build`，产生 `dist/` 文件夹及下面的文件。（可选）将项目上传到 PyPi 或者 Conda

## 项目文件结构

常用的文件结构有两种：src-layout 和 flat-layout，另外一些小项目只有一个 python 文件。

### src-layout

在 src-layout 里，写有 package 源代码的文件夹上层还套了一个文件夹，这个文件夹习惯上命名为 src，当然也可以是别的。`pyproject.toml` 和 `src/` 文件夹同级。

```
<project_name>
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── <package_name>/
│       ├── __init__.py
│       └── example.py
└── tests/
```

### flat-layout

flat-layout 指的是写有 package 源代码的文件夹直接作为开发项目的第一级子文件夹，和 `pyproject.toml` 处于同一级。

这种结构比较古老，不太推荐

```
<project_name>
├── pyproject.toml  # and/or setup.cfg/setup.py (depending on the configuration method)
├── <package_name>
|   ├── __init__.py
|   └── ... (other Python files)
├── test
|   └── ... (test files)
├── # README.rst or README.md (a nice description of your package)
└── # LICENCE (properly chosen license information, e.g. MIT, BSD-3, GPL-3, MPL-2, etc...)
```

### 单文件项目

可以看作是 flat-layout 的一种特殊情况

```
<project_name>
├── pyproject.toml  # and/or setup.cfg/setup.py (depending on the configuration method)
├── <my_module>.py
├── # README.rst or README.md (a nice description of your package)
└── # LICENCE (properly chosen license information, e.g. MIT, BSD-3, GPL-3, MPL-2, etc...)
```

## 填写 `pyproject.toml`、`setup.cfg` **或** `setup.py` **文件**

要想让构建程序把我们的代码打包成安装包，标题中的三个文件至少有一个要出现在 project 的根目录。

文件中要按照各自拓展名对应的语法，填写项目的有关信息，绝大多数可以顾名思义。

各参数的取值和代码文件结构相关，参数主要包括 `name`, `packages`, `package_dir`。如果文件结构完全满足上一节的结构，那么 `setuptools.find_packages()` 的[自动发现机制](https://setuptools.pypa.io/en/latest/userguide/package_discovery.html#automatic-discovery)就够用了。

### `name`

这是一个必填项。

注意：上一节的文件结构中，有两个名字 `<project_name>` 和 `<package_name>` ——

`<project_name>` 是整个开发项目的名字，如果用了类似 git 的版本控制的话，这个名字就是你的 repository 的名字。

`<package_name>` 比较复杂，它可以是，但不一定是你在其他代码中 `import __` 的名字，import 的名字由 `pyproject.toml` / `setup.cfg` **/** `setup.py` 里面的 `name` 参数指定。不能有连字符，只能用下划线。

如果你的 `name` 参数和 `<package_name>` 不同，还需要填写 `package_dir` 参数，

此外还有第三个名字，就是 `pip install __` 时候的名字，上传到 PyPI 的时候填写，可以带有连字符，比如 scikit-image。

### `packages`

参数是一个 list，但是一般都使用 `setuptools.find_packages()` 的结果。

该函数常用三个参数，都是可选的：

- `where`: 一个路径，相对于 `setup.py`
- `include`: 一个 list，元素是 glob patterns
- `exclude`: 一个 list，元素是 glob patterns

不指明任何参数 = 使用自动发现机制

### `package_dir`

参数是一个 dict，两种用法：

- 标准的 src-layout，直接写 `{"": "src/"}`, 表示所有的代码都在这个文件夹里。
- 当 python 模块的结构和代码的文件结构不同的时候，用这个 dict 指明 模块-文件夹 之间的关系。

文件的路径相对于 `setup.py` 而言

### `py_modules`

参数是一个文件路径的列表，几乎专为单文件结构而存在。

## 打包和上传

安装 build 工具：`python3 -m pip install --upgrade build`

运行 build：`python3 -m build`

如此会生成一个 `dist/` 文件夹，里面包含打包的结果。

要想让自己的程序可以被别人用 `pip install` 的方式安装，需要将打包成果上传到 PyPI，方法在[这里](https://packaging.python.org/en/latest/tutorials/packaging-projects/#uploading-the-distribution-archives)。

## 安装

### 静态安装

已经上传到 PyPI 的包，可以直接用 `pip install <package>` 安装，这种方法叫做静态安装

### 动态安装

还在开发过程中的包，可以在 `setup.py` 所在的位置，运行 `pip install -e .` 这种安装方法叫做动态安装，因为代码的修改可以实时反映在引用的项目中。

## 思考题

上篇文章提到的一个[数据分析项目](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510)，其文件结构是这样的（我稍微改动了一下）：

```
/path/to/project/directory/
|-- notebooks/
    |-- 01-first-logical-notebook.ipynb
    |-- 02-second-logical-notebook.ipynb
    |-- prototype-notebook.ipynb
    |-- archive/
	      |-- no-longer-useful.ipynb
|-- src/
    |-- projectname/
	      |-- __init__.py
	      |-- config.py
	      |-- data.py
	      |-- utils.py
    |-- setup.py
|-- README.md
|-- data/
    |-- raw/
    |-- processed/
    |-- cleaned/
|-- scripts/
    |-- script1.py
    |-- script2.py
    |-- archive/
        |-- no-longer-useful.py
|-- environment.yml
```

问：

1. 这是一个 flat-layout 还是 src-layout？
2. setup.py 应该怎么写？执行动态安装时的 `pwd` 结果是什么？


.py | 让自己的代码可以被别人使用


在读 PyTorch 的文档和源码的时候，发现写文档的人也不怎么解释啥是卷积，卷积的各个参数是什么意思，只在文档里扔了个链接就完事了，链接那头是一个 GitHub 上的动图演示仓库，是一篇论文《A guide to convolution arithmetic for deep learning》（链接在文末）的附件。于是这篇文章，基本上就是论文的读书笔记了。

## 数学的卷积：连续 vs. 离散

### 定义

连续的情况，两个单变量函数 $$f(\cdot)$$ 和 $$g(\cdot)$$ 的卷积，定义为：

$$
\left(f*g\right)(x):=\int_{-\infty}^{\infty}f(\tau)g(x-\tau)d\tau
$$

离散的情况，两个向量（也就是一阶张量） $$\vec f$$ 和 $$\vec g$$ 的卷积，定义为：

$$
\left(\vec f * \vec g\right)_i := \sum_{j=-\infty}^{\infty} f_j g_{i-j}
$$

多变量函数/高阶张量的情况，只需要多加几重积分/求和号就可以类推了。

看这两个定义——

只看等号左边的话，可以把卷积看作是一种特殊的乘法，也就是一种**运算。**f 和 g 的地位是平等的，卷积甚至还满足交换律，你甚至可以把两者的顺序变一变；

但是看等号右边的话，卷积就应该被看作是一种**变换**。f 和 g 的地位不再平等，f 是被变换的函数/向量，g 是变换的核 (kernel)。函数的情况里，g 把定义在 $$\tau$$ 空间里的函数 f 变换成了 x 空间里的另一个函数；向量的情况里，g 把一个 J (j 所有可能取值的数量) 维向量 f 变换成了一个 I (i 所有可能取值的数量) 维向量。

神经网络中的卷积，**借用**的主要是第二种**理解**。

### 手算一个例子

例如 $$\vec f = (1,2,3,4)$$, $$\vec g = (1,2,3)$$，而且约定下标从 0 开始的话——

&nbsp; $$(\vec f*\vec g)_0 = f_0g_0 = 1$$

&nbsp; $$(\vec f*\vec g)_1 = f_0g_1 + f_1g_0  = 4$$

&nbsp; $$(\vec f*\vec g)_2 = f_0g_2 + f_1g_1 + f_2g_0 = 10$$

&nbsp; $$(\vec f*\vec g)_3 = f_1g_2 + f_2g_1 + f_3g_0 = 16$$

&nbsp; $$(\vec f*\vec g)_4 = f_2g_2 + f_3g_1 = 17$$

&nbsp; $$(\vec f*\vec g)_5 = f_3g_2 = 12$$

不想手算？

```python
import numpy as np
from scipy import signal
signal.convolve(np.array([1,2,3,4]),np.array([1,2,3]))
```

### 形象化表示

上面的计算过程，可以看作是——

1. 把 g 向量的**顺序反过来；**
2. 把 g 的最右一个元素和 f 的最左元素对齐，
3. 上下两行都有数字的列相乘（也就是把没有数字的地方看作 0），然后把所有乘积相加，得到 f*g 的第一项；
4. 把 g 向右移动一格
5. 重复第3、4步
6. 直到 g 的最左项移动到 f 的最右一个元素。

形如下列各表：

| --- | --- | --- | --- | --- | --- | --- |
| f |  |  | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 |  |  |  |
| (f*g)(0) = 1 |  |  | 1 |  |  |  |

<hr class="slender">

| --- | --- | --- | --- | --- | --- |
| f |  | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 |  |  |
| (f*g)(1) = 4 |  | 2 | 2 |  |  |

<hr class="slender">

| --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |
| g | 3 | 2 | 1 |  |
| (f*g)(2) = 10 | 3 | 4 | 3 |  |

<hr class="slender">

| --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |
| g |  | 3 | 2 | 1 |
| (f*g)(3) = 16 |  | 6 | 6 | 4 |

<hr class="slender">

| --- | --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |  |
| g |  |  | 3 | 2 | 1 |
| (f*g)(4) = 17 |  |  | 9 | 8 |  |

<hr class="slender">

| --- | --- | --- | --- | --- | --- | --- |
| f | 1 | 2 | 3 | 4 |  |  |
| g |  |  |  | 3 | 2 | 1 |
| (f*g)(5) = 12 |  |  |  | 12 |  |  |

## 机器学习的卷积，是卷积吗？

看论文给出的图 Figure 1.1，在卷积核是灰色 3\*3 矩阵的情况下，对蓝色 5\*5 矩阵的卷积就是直接把核对齐到蓝色矩阵上，**并没有把核的元素顺序颠倒过来**。

这玩意能叫卷积吗？

![convolution](/photos/2022-12-29-convolution.png)

有人强行挽尊，说我们画图示的时候已经把核给颠倒过来了，想知道卷积核就把灰色小矩阵再颠倒回去——

但是，不颠倒就对齐相乘的运算也是有名字的，叫 cross correlation。核有没有颠倒，convolution 还是 cross correlation 一组合，可以带来升维打击般的混乱，堪比高中化学的“还原剂被氧化，氧化剂被还原”……所以，对于计算机专业的数学水平，不予置评～


## 卷积`torch.nn.Conv` 及其各个参数

### `in_channels` & `out_channels`

“卷积”的意义在于用一种比较省内存的方式，考虑输入张量中各个元素，和空间上相近的邻居元素之间的关系。所以只需要在真的存在空间关系的维度做卷积，其他维度可以留着不动。

比如一张彩色图片，是一个 (颜色*高度*宽度) 的 3 阶张量，我们只需要对高度和宽度两个维度做卷积，颜色就是不参与“卷积”的 channel。

`in_channel` 就是被“卷积”的张量的 channel 数，`out_channel` 是“卷积”结果的 channel 数。比如我们想从一张 RGB 三色图片中分辨出前景和背景两种不同区域，`in_channel=3`, `out_channel=2`。

而 `in_channel` 如何能够与 `out_channel` 取值不同，原理见 Figure 1.3。我们使用 `out_channel` 个不含 channel 维度的“卷积”核，每一个核都与每一个 in channel 做卷积，得到图中的蓝、紫色小矩阵，然后直接把不同的 in channel 暴力求和，得到的结果分别作为卷积结果的 out channel。（这个暴力求和与我以前想得不一样，我以为是什么每一元素都做了一个`in_channel`*`out_channel` 的全联通层）

![channels](/photos/2022-12-29-channels.png)

 PyTorch 的习惯，对于一个 N 阶“卷积”，参与卷积的是张量的最后 N 阶，`in_channel` 和 `out_channel` 也就是被卷张量和卷积结果的 `Tensor.shape[-(N+1)]`

后面图示的例子都没有考虑 `in_channel` 和 `out_channel` 的数量，也就是都当作 1 了。

### `kernel_size`

就是灰色矩阵“卷积”核，每边有几个数字。如果不同方向的边长不一，该参数就需要用一个 tuple 来表示。Figure 1.1 的灰色卷积核，`kernel_size=(3,3)`

![kernel](/photos/2022-12-29-kernel.png)

### `padding` & `padding_mode`

前面手算例子的时候很鸡贼地把 0 作为向量下标的起点。如果采用日常 1 开头的下标来算，第 1 项结果为零，整个卷积结果的长度会长很多，而且多出来的后面几项也都是零。

而且在这个过程中，我们实际上是把一个有限长度的向量，看作了一个以所有整数 $$\Z$$ 为定义域的函数，除了那有限的几项之外，其余地方都定义函数值为 0。

用计算机计算的话显然没法如此奢侈地谈“无限多个”，例子中实际用到的，在 $$\vec f$$ 左右两边各需要 2 个 0，也就是说 `padding=2`, `padding_mode='zeros'`

Figure 1.2 表示的就是 `padding=(1,1)` 的情况（蓝色是被卷张量，白色是 padding，灰色是卷积核，绿色是卷积结果）：

![padding](/photos/2022-12-29-padding.png)

既然神经网络中的卷积并不是真正的卷积，所以他们索性不装了——

正常卷积的结果往往比被卷张量大一圈（具体大多少取决于  `kernel_size`, `padding`, `stride` 多个参数），但是图像处理的时候经常希望输出图片和输入图片一样大，此时可以用字符串 `“same”` 作为 `padding` 的参数，自动计算 padding 的大小。`“strict”` 则表示 `padding=0`, 这样输出图片尺寸会变小，但是没有 padding，也就没有往图片里掺杂研究者对图片边缘以外信息的臆测。

同时 `padding_mode` 参数表示往被卷张量四周填充的数字也不一定是 0。比如对于图片，0 往往表示纯黑，而绝大多数图片的视野之外，往往是和图片边缘像素值相差不大的值。所以 `padding_mode` 除了 `zeros` 之外，还接受以下取值：

- `reflect`: 以图片边缘为镜面，把边缘附近的像素值对陈反射出去；
- `replicate`: 只取边缘的像素值作为常数，直接向外延拓；
- `circular`: 类似于物理中的周期性边界条件，取对边附近的像素值作为 padding 内容。

### `stride`

前面手算卷积的第4步，把卷积核向右移动了1格，如果每次移动超过1格，就需要这个参数指定移动步长。如果不同方向的步长不同，也是用 tuple 来表示。

Figure 1.4 表示的就是 `stride=(2,2)` 的情况（蓝色是被卷张量，蓝色中的深色块是卷积核，绿色是卷积结果）：

![stride](/photos/2022-12-29-stride.png)

### `dilation`

这个参数把“卷积”核撑开，也就相当于在“卷积”核的相邻元素之间加 0。Figure 1.5 表示的就是 `dilation=(1,1)` 的情况（蓝色是被卷张量，蓝色中的深色块是卷积核，绿色是卷积结果）：

![dilation](/photos/2022-12-29-dilation.png)

比如 `dilation=1` 时，(1,2,3) 的卷积核就相当于 (1,0,2,0,3)

比如 `dilation=2` 时，(1,2,3) 的卷积核就相当于 (1,0,0,2,0,0,3)

这样可以让卷积核在尺寸比较小的情况下，覆盖到更大面积的被卷张量。当然具体实现时，不可能直接补 0 这么浪费内存。

### `groups`

该参数必须是 `in_channel` 和 `out_channel` 的公约数，当其不为 1 时，就相当于同时做 `groups` 个卷积，其中每个卷积的 `in_channel=in_channel/groups`, `out_channel=out_channel/groups`

### `bias`

该参数是一个布尔值，卷积类似于一种高维空间里的乘法，这个参数就决定是否要拟合 `y=kx+b` 中的 `b`

## “卷积”的“逆运算”： `TransposeConv`

卷积的结果比 padding 之后的被卷张量要小。尤其当“卷积”的 `stride` 约等于 `kernel_size` 时，卷积的就变成了某些池化 (pooling)（求最大值不是一种线性算子，所以最大值池化不能用卷积表示，但是平均值池化可以）。

那么在类似 U-net 这样的模型里，右半边的数据升维（下图中的绿箭头），就需要一种“卷积”的“逆运算”。有人把这种运算叫做 deconvolution，有人叫做 transposed convolution，还有人叫做 convolution with fractional strides。

![Unet](/photos/2022-12-29-unet.png)

PyTorch 取的是第二种名字。论文解释了为什么这么取名字，笔记以后有时间再补上把……

因为这个与运算本身就是作为“卷积”的逆运算出现的，所以 PyTorch 的文档里这么说：

> This is set so that when a `Conv2d` and a `ConvTranspose2d` are initialized with same parameters, they are inverses of each other in regard to the input and output shapes.
> 

也就是说，把 `ConvTranspose` 的输入和输出反过来，然后按照 `Conv` 的规则确定各个参数，填入 `ConvTranspose` 的括号里就可以了，除了 `output_padding`

### `output_padding`

`ConvTranspose` 的输出就是对应 `Conv` 的输入。看 Figure 2.7：

![padding_output](/photos/2022-12-29-output-padding.png)

当 $$(input+2*padding)/stride$$ 不能整除的时候，最右的几列最下的几行就被卷积核忽略掉了。那么在逆运算 `TransposeConv` 中，这就意味着同一个输入可能对应着 $$stride-1$$ 种可能的输出。`output_padding`参数就可以消除这种歧义，调整 `TransposeConv` 输出张量的尺寸。

## 参考链接

- 给卷积正名: [https://www.kaggle.com/general/225375](https://www.kaggle.com/general/225375)
- PyTorch Conv2d 源码: [https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#_ConvNd](https://pytorch.org/docs/stable/_modules/torch/nn/modules/conv.html#_ConvNd)
- 论文: [https://arxiv.org/abs/1603.07285](https://arxiv.org/abs/1603.07285)
- 动图演示: [https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md](https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md)
- U-net: [https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/](https://lmb.informatik.uni-freiburg.de/people/ronneber/u-net/)
- PyTorch TransposeConv 文档: [https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html](https://pytorch.org/docs/stable/generated/torch.nn.ConvTranspose2d.html)


.ai | 神经网络中的卷积及其参数


最近参加了一个关于如何在 Python 项目中利用 GPU 提高运算效率的培训，里面提到了 `numba` 这个加速科学计算的库，而 `numba` 发挥作用的主要工具就是各种装饰器。

所谓装饰器，就是读一些网上现成的 python 代码的时候会看到的，函数前一行 `@` 打头的一串字符，一般是一个名字，偶尔会附带有参数：

```python
@decorator
def myfunction():
    # do something...
    return results
```

它的实际作用相当于：

```python
def myfunction():
    # do something...
    return None

myfunction = decorator(myfunction)
```

Python 是一种[函数式编程语言](https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html)，函数和各种类型的变量一样，在 Python 都是一种对象，所以可以把函数赋值给一个变量，可以在函数里定义另一个函数，可以把函数作为参数传递给另一个函数，可以把函数名作为另一个函数的返回值。

`myfunction = decorator(myfunction)` 就是装饰器的定义，是 Python 的一个[语法糖](https://zh.m.wikipedia.org/zh-hans/%E8%AF%AD%E6%B3%95%E7%B3%96)。也就是说装饰器本身也是一个函数，我们的函数被装饰器装饰之后，函数名称不变，在完整实现函数原有功能的同时，额外执行装饰器中的命令。

### 装饰器是如何做到的

要想自己写一个装饰器的话，需要了解一下装饰器的实现原理。一个最简单的装饰器可以这么写：

```python
def decorator(func):
    def inner():
        # do something
        func()
        # do some more
        return None
    return inner
```

也就是在装饰器内部再定义一个函数，这个内部函数的函数体执行被装饰的函数，然后外层装饰器把内层函数名当作返回值。

### 如果一个函数需要多个装饰器

把前面装饰器的定义套在多个装饰器的情况里：

```python
@decorator1
@decorator2
def myfunction():
    return None

myfunction = decorator1(decorator2(myfunction))
```

### 如果被装饰的函数有传入参数

装饰器不知道自己要装饰的函数长什么样，也就不知道函数接受多少个参数，其中有几个是位置参数，几个是关键词参数。所以需要用单星号打包/解包位置参数，双星号打包/解包关键词参数。`args` 和 `kwargs` 是变量名的代词，可以换成其他自己喜欢的名字。

```python
def decorator(func):
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return None
    return inner

@decorator
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return None
```

### 如果被装饰的函数有返回值

则装饰器的内层函数需要把被装饰的函数的返回值返回出来：

```python
def decorator(func):
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return func(*args,**kwargs)
    return inner

@decorator
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return results
```

### 如果想让装饰器本身接受参数

也就是想达到下面的效果：

```python
@param_decorator(param="neat")
def myfunction(x,y,mode="normal",strict=True):
    # do something...
    return results
```

也就是让 `param_decorator(param="neat")` 返回一个装饰器函数，也就是在之前的装饰器外面再加一层：

```python
def param_decorator(param):
    def decorator(func):
        def inner(*args,**kwargs):
            if param=="neat":
                print("neat")
                # ...
            else:
                print("not neat")
                # ...
            func(*args,**kwargs)
            return func(*args,**kwargs)
        return inner
    return previous_decorator
```

### 如果想让装饰器既可以接受参数，也可以不接受参数～

实在是有点过于高级了，直接说答案：

```python
def flex_decorator(_func=None,*,kw1="val1",kw2="val2"):
    def decorator(func):
        def inner(*args,**kwargs):
            print(kw1,kw2)
            # do something
            func(*args,**kwargs)
            # something else
            return func(*args,**kwargs)
        return inner
    if _func is None:
        return decorator
    else:
        return decorator(_func)
```

根据 [https://peps.python.org/pep-3102/](https://peps.python.org/pep-3102/)，`*`作为一个单独的函数参数，表示后面所有的参数都是关键词参数，用来限定星号前面位置参数的数量。

- 当 `@flex_decorator` 不加参数使用的时候:
    - 根据定义 `myfunction = flex_decorator(myfunction)`
    - `_func=myfunction`
    - 此时 `else` 生效，`myfunction = decorator(myfunction)`
- 当 `@flex_decorator(kw1="val1",kw2="val2")` 加上参数使用的时候:
    - 根据定义 `myfunction = flex_decorator(kw1="val1",kw2="val2")(myfunction)`
    - `_func=None`
    - 此时 `if` 生效，`myfunction = decorator(myfunction)`

——**接受的参数必须是关键词参数**，否则和被装饰的函数名无法区分。

### `@functools.wraps`：刻章、办证

以上各节基本完成了常用场景下装饰器的功能。

但是，Python 作为一种动态语言，一大特征就是可以在运行时进行[类型内省](https://en.wikipedia.org/wiki/Type_introspection)。而按照我们上面的写法，被装饰之后的函数，Python 认为它不再是原来的函数，而是装饰器里面定义的那个内部函数，这样可能会出现意想不到的问题。

解决方法是使用一个专门的装饰器根装饰器定义的内部函数办个假身份：

```python
import functools

def decorator(func):
    @functools.wraps(func)
    def inner(*args,**kwargs):
        # do something
        func(*args,**kwargs)
        # something else
        return func(*args,**kwargs)
    return inner
```


.py | Python decorator 装饰器


## 一般监督学习的数据结构和处理过程

### 训练集、验证集、测试集

所有数据整体构成一个大集合，这个集合的每一个元素都包含一个输入和一个目标，分别记作 x 和 y。

把这个大集合分成互相没有交集的三个子集，分别是训练集 (training set)、验证集 (validation set)、测试集 (test set)。

- 训练集和验证集在训练过程中使用。
    - 训练集的数据带入模型时，模型处于训练模式，模型输出对参数的导数被记录。通过比较把“模型输出”和“训练目标 y”代入**损失函数**的损失，更新模型的参数。同时记录“模型输出”和“训练目标 y”带入验证函数的结果，和验证集比较。
    - 验证集的数据代入模型时，模型处于求值模式，模型只根据输入计算输出，对参数的导数不记录。通过观察“模型输出”和“训练目标 y”带入**验证函数**的结果，观察训练是否陷入“过拟合”。当训练集的验证函数结果不断下降，但是验证集的验证函数结果几乎不变时，可以认为模型过拟合。
- 测试集在训练完成之后使用，代入模型时，模型处于求值模式。用于评价训练结果的好坏。

### epoch vs. batch

如果把所有数据同时进行训练，所需要的空间一般都大于电脑内存。所以一般会将训练集随机分成若干批次 (batch)，一个批次的数据同时塞入模型进行训练，在一个 batch 里每一个模型输出对参数的导数累加在一起，整个 batch 结束后更新模型参数，同时导数清零。因为 batch 这个概念和内存有关，所以数值一般选择为 2 的指数。

将训练集所有的 batches 跑完一次称为而一个 epoch。一次训练一般需要很多 epochs，直到损失函数结果足够低，或验证集显示出现过拟合。

## PyTorch 对上述结构和处理过程的封装

### `Dataset`

前面已经说了，数据集包括输入和目标两部分，`Dateset` 及其子类的作用就是

如果在把数据装入 `Dataset` 之前就已经是规整的两个张量了的话——

```python
import torch
from torch.utils import data

# ...

for x,y in zip(train_x,train_y):
    # do something with x and y

trainset = TensorDataset(train_x,train_y)
for x,y in trainset:
    # do something with x and y
```

——这一步确实没什么意思。

有意思的地方在于可以自己写一个数据集类，继承 `Dataset`，然后重载 `__getitem__()` 和 `__len__()` 方法，这样可以把一些不适合用张量表示的数据塞进 `Dataset` 里面，对图像进行学习的话可以在此处加入图像增强的步骤，并进一步用于 `DataLoader`

### `DataLoader`

`DataLoader` = `Dataset` + `Sampler`，因为一般的教程里只需要讲数据集进行简单随机划分，也就只用到了 `batch_size` 等等参数，用到 Sampler 的地方很少。

最常见的用例就是 `WeightedRandomSampler` 。训练分类器的时候，有时其中一个类别的数据远少于其他，那么训练器就更难判断出这一分类（因为只要无脑排除这个类别就能获得不错的正确率），所以需要平衡不同组别之间的权重。

```python
list(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True))
# [4, 4, 1, 4, 5]
list(WeightedRandomSampler(weights=[0.9, 0.4, 0.5, 0.2, 0.3, 0.1], num_samples=5, replacement=False))
# [0, 1, 4, 3, 2]
```

平衡完之后转化为 batch，搭配 `BatchSampler`：

```python
list(BatchSampler(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True), batch_size=2, drop_last=False))
# [[4, 4], [1, 4], 5]
list(BatchSampler(WeightedRandomSampler(weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], num_samples=5, replacement=True), batch_size=2, drop_last=True))
# [[0, 1], [4, 3]]
```

### 汇总一下

```python
import torch
from torch.utils import data

train_x = torch.rand((100,5))
train_y = torch.rand((100,2))
trainset = data.TensorDataset(train_x,train_y)

# either:
trainloader = data.DataLoader(
    trainset,
    batch_size=2,
    drop_last=True,
    sampler=data.WeightedRandomSampler(
        weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], 
        num_samples=5, 
        replacement=True))
# or:
trainloader = data.DataLoader(
    trainset,
    batch_sampler=data.BatchSampler(
        data.WeightedRandomSampler(
            weights=[0.1, 0.9, 0.4, 0.7, 3.0, 0.6], 
            num_samples=5, 
            replacement=True), 
        batch_size=2, 
        drop_last=True))

for epoch in range(100):
    for x,y in trainloader:
        train(model,x,y,loss_function)
```

需要注意的是，`for x,y in trainset` 的 x 和 y 的维度是单个数据的维度，最简单的情况就是是 P 和 Q 维向量，而此时如果把 batch_size 记作 B，`for x,y in trainloader` 中的 x 和 y 是维度分别为 (B,P) 和 (B,Q) 的矩阵。`train()` 函数里面的计算要考虑到多出的这一个维度。

## 参考链接：

- [https://pytorch.org/tutorials/beginner/basics/data_tutorial.html](https://pytorch.org/tutorials/beginner/basics/data_tutorial.html)
- [https://pytorch.org/tutorials/beginner/nn_tutorial.html](https://pytorch.org/tutorials/beginner/nn_tutorial.html)
- [https://pytorch.org/tutorials/beginner/ptcheat.html](https://pytorch.org/tutorials/beginner/ptcheat.html)
- [https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset](https://pytorch.org/docs/stable/data.html?highlight=dataset#torch.utils.data.Dataset)
- [https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.DataLoader)
- [https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.Sampler](https://pytorch.org/docs/stable/data.html?highlight=dataloader#torch.utils.data.Sampler)
- [https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#Dataset](https://pytorch.org/docs/stable/_modules/torch/utils/data/dataset.html#Dataset)


.py | PyTorch 数据处理方面的封装


- 电脑设置、python 入门
    - NoMachine, ssh, python, conda, jupyter
    - 文件夹操作 `pathlib`, 图片操作 `skimage`
    - 数据增强 (data augmentation): `imgaug`
    - TensorBoard
- 机器学习简介
    - Linear Classifier
    - `sklearn**.**model_selection**.**train_test_split()`
    - Stochastic gradient descent
    - TensorFlow:
        - `tensorflow_addons as tfa`
        - `tfa.image.rotate()`, `tf.image.random_flip_left_right()`
        - **`from** tensorflow.keras **import** Model`, **`from** tensorflow.keras.models **import** Sequential`, **`from** tensorflow.keras.layers **import** Input, Flatten, Dense, Activation, BatchNormalization, Conv2D, MaxPool2D, Softmax`
        - `tf**.**keras**.**losses**.**CategoricalCrossentropy()`, `tf**.**keras**.**optimizers**.**Adam(lr**=**1e-3, clipnorm**=**0.001)`
        - `linear_classifier **=**``Model(...)`, `linear_classifier.compile()`, `linear_classifier.fit()`, `linear_classifier.predict()`
- 深度学习简介
    - Perceptron
    - Perceptron-based XOR gate
    - **decision boundary** of your model: `np.meshgrid`
- 图像恢复 (image restoration)
    - CARE network
    - Noise2Nosie, Noise2Void
- 图像翻译 (image translation)
    - micro-DL: a tool to generate and train U-net from config files.
- 图像语义分割 (image semantic segmentation): 比较详细，前两节有点水了。
    - **`from** PIL **import** Image`, **`import** imageio`, **`from** torchvision **import** transforms`
    - **`from** torch.utils.data **import** Dataset, DataLoader`, **`import** torch.nn **as** nn`, **`from** torch.nn **import** functional **as** F`,  **`from** torch.utils.tensorboard **import** SummaryWriter`,
    - U-net on PyTorch
- 图像实例分割 (instance segmentation)
    1. Foreground segmentation: 
        - **Receptive Field of View**: The term is borrowed from biology where it describes the "portion of sensory space that can elicit neuronal responses when stimulated" (wikipedia). Each output pixel can look at/depends on an input patch with that diameter centered at its position. Based on this patch, the network has to be able to make a decision about the prediction for the respective pixel.
        - **Early Stopping** to avoid overfitting: define an `EarlyStopping` class
    2. Instance Segmentation:
        - Ideas:
            - Three-class model (foreground, background, boundary),
            - Distance transform (label for each pixel is the distance to the closest boundary),
            - Edge affinity (consider not just the pixel but also its direct neighbors, predicts the probability that there is an edge, this is called affinity.) 听的时候懂了，回来看的时候没太看懂
            - Metric learning (learns to predict an embedding vector for each pixel.)
    3. **Tile and Stitch：**
        - 当需要处理的图片过大时，将图片切分成多个小图，分别预测之后拼接在一起。
        - 文中说图片尺寸不是 某个参数的整数倍的时候拼贴结果会不连续，但是代码注释中说等于这个整数倍的时候会不连续，晕。
        - [https://arxiv.org/pdf/2101.05846.pdf](https://arxiv.org/pdf/2101.05846.pdf)
    4. 一个实例，epithelia cells
- 失败模式：极其之水，就是科普了一下训练参数错误的后果，以及一点对抗学习的内容
- 追踪：比较水，因为机器学习追踪的运算量极大，且主讲人感觉就是来做广告的，所以就直接用 CoLab 体验了一下就完事了。（就这还加州理工呢~）
- 知识提取：
    - 前面的基本上是从像素到像素的映射，这里的知识提取是从图片到标签的映射。
    - CycleGAN
    - **Create a balanced Dataloader**
    

.py | 深度学习暑期学校知识点


自学，或者说一切学习和教学，本质就是在已经掌握的知识和未知的目标知识之间修路。路有两种修法，一是理论或者说是第一性原理路线，从不证自明的公理或者已经掌握的知识出发，通过逻辑推理一步步得到新的知识；另一种是实践或者说工程师路线，拿到一个已经可以工作的产品，划分成各个子系统，通过输入的改变来观察输出的不同，直到子系统简化到自己可以理解的地步，不再是黑箱，借此了解整个系统的功能。

但是当学习的对象复杂到一定程度之后，凭借一个人的自学能力，只用其中一种方法往往难以钻透。又或者两种方法学到的路线并非同一条路。对于机器学习，理论路线就是“让输入数据通过一个带有超多参数的函数，根据函数返回值和输出数据之间的差别修正参数，直到函数能够近似输入数据和输出数据之间的关系”；实践中代码往往会使用很多库作者封装好的函数，只读源码往往一头雾水。

所以，看到 PyTorch 官网的这篇教程 **WHAT IS TORCH.NN *REALLY*?:** [https://pytorch.org/tutorials/beginner/nn_tutorial.html](https://pytorch.org/tutorials/beginner/nn_tutorial.html) 可以说是喜出望外，把两种路线写出的代码都给了出来，对于自学者来说，就像罗塞塔石碑一样可以互相对照。这里我把 CNN 相关的部分抽掉了，毕竟 CNN 只是深度学习的一个子集，深度学习只是机器学习的一个子集，和这篇文章的主题关系不大。

原文先按照第一性原理，尽量用原生 python 写了一遍，然后一步一步重构成接近生产环境的代码。这里我把顺序反过来，先放出重构之后的最终结果：

```python
from pathlib import Path
import requests
import pickle
import gzip
import numpy as np
import torch
import torch.nn.functional as F
from torch import nn
from torch import optim
from torch.utils.data import TensorDataset,DataLoader

# Using GPU

print(torch.cuda.is_available())
dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")

# Wrapping DataLoader
# https://pytorch.org/tutorials/beginner/basics/data_tutorial.html?highlight=dataloader
# https://pytorch.org/tutorials/beginner/data_loading_tutorial.html?highlight=dataloader

def preprocess(x, y):
    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )

class WrappedDataLoader:
    def __init__(self, dl, func):
        self.dl = dl
        self.func = func

    def __len__(self):
        return len(self.dl)

    def __iter__(self):
        batches = iter(self.dl)
        for b in batches:
            yield (self.func(*b))

# Define the neural network model to be trained

# # If the model is simple:
# model = nn.Sequential(nn.Linear(784, 10))

# generally the model is a class that inherites nn.Module and implements forward()
class Mnist_Logistic(nn.Module):
    def __init__(self):
        super().__init__()
        # self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))
        # self.bias = nn.Parameter(torch.zeros(10))
        self.lin = nn.Linear(784, 10)

    def forward(self, xb):
        # return xb @ self.weights + self.bias
        return self.lin(xb)

# Define the training pipeline in fit()

def loss_batch(model, loss_func, xb, yb, opt=None):
    loss = loss_func(model(xb), yb)

    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()

    return loss.item(), len(xb)

def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)

        model.eval()
        with torch.no_grad():
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)

        print(epoch, val_loss)
    return None

# __main()__:

# data
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)

train_dataset = TensorDataset(x_train, y_train)
valid_dataset = TensorDataset(x_valid, y_valid)
train_dataloader, valid_dataloader = get_data(train_ds, valid_ds, bs)
train_dataloader = WrappedDataLoader(train_dataloader, preprocess)
valid_dataloader = WrappedDataLoader(valid_dataloader, preprocess)

# hyperparameters/model
learning_rate = 0.1
epochs = 2
loss_function = F.cross_entropy # loss function
model = Mnist_CNN()
model.to(dev)
optimizer = optim.SGD(model.parameters(), lr=learning_rate , momentum=0.9)

# training
fit(epochs, model, loss_function, optimizer, train_dataloader, valid_dataloader)
```

可以看到，一个项目主干可以分成4部分：

1. 准备数据
2. 定义模型
3. 描述流程
4. 实际运行

下面把各部分拆分开来，把两种思路的代码进行对比。

## 1. 准备数据

### 重构之前

```python
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)
n, c = x_train.shape
```

### 重构以后：

```python
# Wrapping DataLoader
# https://pytorch.org/tutorials/beginner/basics/data_tutorial.html?highlight=dataloader
# https://pytorch.org/tutorials/beginner/data_loading_tutorial.html?highlight=dataloader

def preprocess(x, y):
    return x.view(-1, 1, 28, 28).to(dev), y.to(dev)

def get_data(train_ds, valid_ds, bs):
    return (
        DataLoader(train_ds, batch_size=bs, shuffle=True),
        DataLoader(valid_ds, batch_size=bs * 2),
    )

class WrappedDataLoader:
    def __init__(self, dl, func):
        self.dl = dl
        self.func = func

    def __len__(self):
        return len(self.dl)

    def __iter__(self):
        batches = iter(self.dl)
        for b in batches:
            yield (self.func(*b))
```

## 2. 定义模型

### 重构之前

```python
weights = torch.randn(784, 10) / math.sqrt(784)
weights.requires_grad_()
bias = torch.zeros(10, requires_grad=True)

def log_softmax(x):
    return x - x.exp().sum(-1).log().unsqueeze(-1)

def model(xb):
    return log_softmax(xb @ weights + bias)

def nll(input, target):
    return -input[range(target.shape[0]), target].mean()
loss_func = nll

def accuracy(out, yb):
    preds = torch.argmax(out, dim=1)
    return (preds == yb).float().mean()
```

### 重构以后

```python
# If the model is simple:
model = nn.Sequential(nn.Linear(784, 10))

# generally the model is a class that inherites nn.Module and implements forward()
class Mnist_Logistic(nn.Module):
    def __init__(self):
        super().__init__()
        # self.weights = nn.Parameter(torch.randn(784, 10) / math.sqrt(784))
        # self.bias = nn.Parameter(torch.zeros(10))
        self.lin = nn.Linear(784, 10)

    def forward(self, xb):
        # return xb @ self.weights + self.bias
        return self.lin(xb)

```

## 3. 描述流程

### 重构之前

```python
lr = 0.5  # learning rate
epochs = 2  # how many epochs to train for

for epoch in range(epochs):
    for i in range((n - 1) // bs + 1):
        #         set_trace()
        start_i = i * bs
        end_i = start_i + bs
        xb = x_train[start_i:end_i]
        yb = y_train[start_i:end_i]
        pred = model(xb)
        loss = loss_func(pred, yb)

        loss.backward()
        with torch.no_grad():
            weights -= weights.grad * lr
            bias -= bias.grad * lr
            weights.grad.zero_()
            bias.grad.zero_()
```

### 重构以后

```python

def loss_batch(model, loss_func, xb, yb, opt=None):
    loss = loss_func(model(xb), yb)

    if opt is not None:
        loss.backward()
        opt.step()
        opt.zero_grad()

    return loss.item(), len(xb)

def fit(epochs, model, loss_func, opt, train_dl, valid_dl):
    for epoch in range(epochs):
        model.train()
        for xb, yb in train_dl:
            loss_batch(model, loss_func, xb, yb, opt)

        model.eval()
        with torch.no_grad():
            losses, nums = zip(
                *[loss_batch(model, loss_func, xb, yb) for xb, yb in valid_dl]
            )
        val_loss = np.sum(np.multiply(losses, nums)) / np.sum(nums)

        print(epoch, val_loss)
    return None
```

## 4. 实际运行

### 重构之前

```python
# __main()__:
print(loss_func(model(xb), yb), accuracy(model(xb), yb))
```

### 重构以后

```python
# __main()__:

# data
DATA_PATH = Path("data")
PATH = DATA_PATH / "mnist"

PATH.mkdir(parents=True, exist_ok=True)

URL = "https://github.com/pytorch/tutorials/raw/master/_static/"
FILENAME = "mnist.pkl.gz"

if not (PATH / FILENAME).exists():
        content = requests.get(URL + FILENAME).content
        (PATH / FILENAME).open("wb").write(content)
with gzip.open((PATH / FILENAME).as_posix(), "rb") as f:
        ((x_train, y_train), (x_valid, y_valid), _) = pickle.load(f, encoding="latin-1")

x_train, y_train, x_valid, y_valid = map(
    torch.tensor, (x_train, y_train, x_valid, y_valid)
)

train_dataset = TensorDataset(x_train, y_train)
valid_dataset = TensorDataset(x_valid, y_valid)
train_dataloader, valid_dataloader = get_data(train_ds, valid_ds, bs)
train_dataloader = WrappedDataLoader(train_dataloader, preprocess)
valid_dataloader = WrappedDataLoader(valid_dataloader, preprocess)

# hyperparameters/model
learning_rate = 0.1
epochs = 2
loss_function = F.cross_entropy # loss function
model = Mnist_CNN()
model.to(dev)
optimizer = optim.SGD(model.parameters(), lr=learning_rate , momentum=0.9)

# training
fit(epochs, model, loss_function, optimizer, train_dataloader, valid_dataloader)
```

.py | 一个 PyTorch 机器学习项目长什么样


笔记本的触摸屏被我摔了道裂纹，一开始还不影响使用，但是最近几周情况恶化，有时鼠标光标会突然暴走，不听指挥。所以需要禁用触摸屏作为输入设备。

在 xorg 的桌面环境之下，可以用 `xinput list` 显示出所有输入设备，以及对应的 id 号码。然后把找到的 id 填入 `xinput disable ##` 就可以了。一般来说这个 id 的数值是稳定的，所以我就直接把禁用命令写到 `~/.bashrc` 里面去了。

然而，最近把吃灰很久的树莓派拿出来玩了，所以败家买了个60%布局的小机械键盘，小键盘往笔记本一插，诶，您猜怎么着，新买的键盘输完密码登陆之后就不能用了，着实吓了一跳。

所以需要每次检查一遍输入设备的 id，然后把和触摸屏有关的 id（不止一个）从 `xinput list` 的输出里摘出来赋值给一个变量，然后把变量带入 `xinput disable #` 里面。这一套操作已经超出我的 bash 能力了，所以考虑用 python 完成中间步骤，也就是需要让 python 读 bash 的命令结果，写 bash 的命令语句。

Googles搜索给到了这个结果：[https://stackoverflow.com/questions/4256107/running-bash-commands-in-python](https://stackoverflow.com/questions/4256107/running-bash-commands-in-python)，稍微看了一下 subprocess 的官方文档，写了下面的一段，存到 `~/disable_touchscreen.py`, 然后在 `~/.bashrc` 里加一句 `python ~/disable_touchscreen.py`

```python
import subprocess
check = subprcess.run(["xinput","list"],capture_output=True)
for line in check.stdout.decode("utf-8").split("\n"):
    if "touchscreen" in line:
        device = line.partition("id=")[2].partition("\t")[0]
        disable = subprocess.run(["xinput","disable",str(device)])
        if disable.returncode==0:
            print(f"Successfully disabled touchscreen device {device}")
        else:
            print(f"Failed to disable touchscreen device {device}")
```

- 这段代码的核心是 `subprocess.run()` ，第一个参数就是传给 bash 的命令，这是一个list，其中每个元素就是 bash 语句用空格分割开的每一部分。要想得到命令的执行结果，需要添加参数 `capture_output=True`
- 上面函数的返回值是一个特殊的数据结构，命令顺利执行的话，结果会写在 `.stdout` 里，这是一个二进制串 `b'xxx...'`，所以需要 `.decode("utf-8")` 转化成字符串。

如果只用bash的话，

- 我的 bash 水平可以做到 `xinput list | grep "touchscreen"`, 这里的 `|` 是一个管道，也就是将前一条命令的输出传递给后一条作为输入。要想在 python 里使用管道，可以看这个问答：[https://stackoverflow.com/questions/13332268/how-to-use-subprocess-command-with-pipes](https://stackoverflow.com/questions/13332268/how-to-use-subprocess-command-with-pipes)
- 上面管道的结果还需要裁剪出 id 号，也就是 `line.partition("id=")[2].partition("\t")[0]`，估计需要用到 awk, 虽然难，但可以学，至少知道该学什么；
- 但是把 id 号传递给一个变量，然后把这个变量填进 `xinput disable`, 这一步就连该学什么也不知道了。


.py | python.subprocess执行bash命令


- 官网教程：[https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html](https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html)
- 官方文档：[https://pytorch.org/docs/stable/tensorboard.html](https://pytorch.org/docs/stable/tensorboard.html)

TensorBoard 是 TensorFlow 团队开发的一款可视化工具，方便观察和调整机器学习的数据集、模型、超参数和训练结果等等。但是不知道为什么，PyTorch 调用 TensorBoard，要比 TensorFlow 方便简单得多，~~这何尝不是一种 NTR~~……

---

## 用法和效果

一个使用了 TensorBoard 的 torch 项目的主文件一般是这样的（把和 TensorBoard 无关的部分都注释掉了）：

```python
# imports
# import matplotlib.pyplot as plt
# import numpy as np

# import torch
# import torchvision
# import torchvision.transforms as transforms

# import torch.nn as nn
# import torch.nn.functional as F
# import torch.optim as optim

from torch.utils.tensorboard import SummaryWriter

# # transforms
# transform = transforms.Compose(
#     [transforms.ToTensor(),
#     transforms.Normalize((0.5,), (0.5,))])

# # datasets
# trainset = torchvision.datasets.FashionMNIST('./data',
#     download=True,
#     train=True,
#     transform=transform)
# testset = torchvision.datasets.FashionMNIST('./data',
#     download=True,
#     train=False,
#     transform=transform)

# # dataloaders
# trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
#                                         shuffle=True, num_workers=2)
# testloader = torch.utils.data.DataLoader(testset, batch_size=4,
#                                         shuffle=False, num_workers=2)

# # constant for classes
# classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
#         'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')

# class Net(nn.Module):
#     def __init__(self):
#         super(Net, self).__init__()
#         self.conv1 = nn.Conv2d(1, 6, 5)
#         self.pool = nn.MaxPool2d(2, 2)
#         self.conv2 = nn.Conv2d(6, 16, 5)
#         self.fc1 = nn.Linear(16 * 4 * 4, 120)
#         self.fc2 = nn.Linear(120, 84)
#         self.fc3 = nn.Linear(84, 10)
#     def forward(self, x):
#         x = self.pool(F.relu(self.conv1(x)))
#         x = self.pool(F.relu(self.conv2(x)))
#         x = x.view(-1, 16 * 4 * 4)
#         x = F.relu(self.fc1(x))
#         x = F.relu(self.fc2(x))
#         x = self.fc3(x)
#         return x
# net = Net()

# criterion = nn.CrossEntropyLoss()
# optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# default `log_dir` is "runs" - we'll be more specific here
writer = SummaryWriter('runs/fashion_mnist_experiment_1')

running_loss = 0.0
for epoch in range(1):  # loop over the dataset multiple times
    for i, data in enumerate(trainloader, 0):
        # # get the inputs; data is a list of [inputs, labels]
        # inputs, labels = data

        # # zero the parameter gradients
        # optimizer.zero_grad()

        # # forward + backward + optimize
        # outputs = net(inputs)
        # loss = criterion(outputs, labels)
        # loss.backward()
        # optimizer.step()

        # running_loss += loss.item()
        if i % 1000 == 999:    # every 1000 mini-batches...
            # ...log the running loss
            writer.add_scalar('training loss',
                            running_loss / 1000,
                            epoch * len(trainloader) + i) # 注意这一行！
# print('Finished Training')
```

正常情况下，使用了tensorboard 的项目在训练的过程中，可以用网页浏览器打开网址 `localhost:6006`，应该可以看到和下图类似但不同的画面：

![tensorboard](/photos/2022-04-08-tensorboard.png)

下面来仔细分解。

## 代码分解

[引入](python-import-script-module-package) TensorBoard 需要下面一行代码：

```python
from torch.utils.tensorboard import SummaryWriter
```

从名字就能看出来，`SummaryWriter` 是一个 class。粗略用了一下文档页面的业内搜索，好像整个 `torch.utils.tensorboard` 就只有这一个 class。

新建一个这个类的实例：

```python
writer = SummaryWriter('runs/fashion_mnist_experiment_1')
```

这一步会在当前工作环境下新建一个 `/runs` 文件夹，

要想显示导航栏上的“SCALARS”、“IMAGES”等等选项卡，并且让自己想观察的数据显示在各自类别的选项卡里，需要调用 `SummaryWriter` 下面的各种方法，比如 `add_scalar()`, `add_image()`.

### 各种方法

用法和效果举例如下：

- `add_scalar()`: 在一张图中画出**一个标量**指标随学习迭代的**变化曲线**。
    - `tag`: 图片的标题。
    - `scalar_value`: 指标的值，也就是纵坐标。
    - `global_step`: 全局迭代次数，也就是横坐标。
- `add_scalars()`: 在一张图中同时画出**多个指标**随学习迭代的**变化曲线**。
    - `main_tag`: 图片的标题
    - `tag_scalar_dict`: 一个字典，字典的键是变量的名字，值是各个变量的纵坐标。
    - `global_step`: 全局迭代次数，也就是横坐标。
- `add_custome_scalars()`: 没有用过，也没见到例子，不太明白。根据描述像是把之前 `add_scalar()` 和 `add_scalars()` 的结果重新组合，对 SCALARS 选项卡重新排版。每个 `SummaryWriter` 只能运行一次，可以在训练开始前运行，也可以在之后。
    - `layout`: 只有一个这参数，是一个字典，字典的键像是新图片/章节的名字，值是下一级字典或者是 `add_scalar()` 出现过/将要出现的 `tag` 参数。
- `add_figure()`: 显示 `matplotlib` 画出的**图表**。
    - `tag`: 标题
    - `figure`: 图表，要求类型为 `matplotlib.pyplot.figure`
    - `global_step`:迭代次数，效果如何 没试过。
- `add_histogram()`: 在一张图中画出一个样本的**直方图**，以及这个直方图随迭代变化的规律。这是个三维图片，x 轴是直方图的取值范围，y 轴是迭代次数，z 轴是直方图的频率值。
    - `tag`: 图片标题。
    - `values`: 一个 `torch.Tensor` 或者 `numpy.array` ，用于绘制直方图的样本.
    - `global_step`: 迭代次数，y 轴分量。
    - `bins`: 取样间隔参数，`numpy.histogram()` 中用到的。 ****
- `add_graph()`: 一般用于在训练前画出神经网络的**图状结构**。
    - `model`: 要画的模型，类型是 `torch.nn.Module`
    - `input_to_model=None`: （可选）输入模型的变量。
- `add_mesh()`: **三维点云**。
    - `tag`: 表格标题。
    - `vertices`: 顶点三维坐标的列表。
    - `colors`: 顶点的颜色。
    - `faces`: （可选）没看懂 (Indices of vertices within each triangle.)
    - `config_dict`: 用于画图的 ThreeJS 的参数。
    - `global_step`: 迭代次数。
- `add_embeddding()`: 神经网络的输入一般是高维向量，此工具将高维数据**投影到三维**空间，然后画出图像，方便我们感知训练集内样本之间的关系。
    - `mat`: 一个矩阵，每一行都是一个要处理的向量。
    - `metadata`: 标记文字，一般是列表。
    - `label_img`: 标记图片，显示在每个数据点旁边的
    - `global_step`: 迭代次数，一般没人用。
    - `tag`: 图片标题。
- `add_pr_curve()`: 准确率 (precision) -召回率 (call back) 曲线。准确率=真阳性/(真阳性+假阳性)，召回率=真阳性/(真阳性+假阴性)
    - `tag`: 图片标题。
    - `labels`: Ground truth 数据，每个数据点对应一个布尔值。
    - `predictions`: 模型的输出，每个数据点对应一个 [0,1] 之间的实数。
    - `global_step`: 迭代次数。
    - `num_thresholds`:用于画出 PR 曲线的阈值的数目。
- `add_hparams()`: 比较不同次运行之间的超参数。没太看懂。
    - `hparam_dict`: 超参数的名称和取值
    - `metric_dict`: metric （不知道怎么翻译）的名称和取值
    - `hparam_domain_discrete`: （可选）字典，超参数的名称和有限个可能的取值。
    - `run_name`: 运行的名称，将会成为 `logdir` 的一部分。
- `add_image()`: 在 IMAGES 选项卡中显示**一张图片**。
    - `tag`: 图片名称。
    - `img_tensor`: 一个 `torch.Tensor` 或者 `numpy.array`，被显示的图片。对应于下面的 `dataformats` 参数。
    - `global_step`: 迭代次数，没见有人在显示图片的时候用过。
    - `dataformats=’CHW’`: 图片各维度的顺序。默认是“颜色-高度-宽度”。
- `add_images()`: 并列显示**多张图片**。
    - `tag`: 图片组的标题。
    - `img_tensor`: 一个 `torch.Tensor` 或者 `numpy.array`，被显示的图片。图片个维度的含义由 `datadormats` 给出。
    - `global_step`: 迭代次数，没见有人在显示图片的时候用过。
    - `datadormats=’NCHW’`: 图片各维度的顺序。默认为“图片序号-颜色-高度-宽度”。
- `add_video()`: 略
- `add_audio()`: 略
- `add_text()`: 略

.py | TensorBoard 笔记（PyTorch 版）


以官网给出的文件结构为例来说明：

```

sound/                          Top-level package
      __init__.py               Initialize the sound package
      formats/                  Subpackage for file format conversions
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      effects/                  Subpackage for sound effects
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      filters/                  Subpackage for filters
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...
```

## 使用现成的 python 代码

正常的编程语言教程，教人配置完开发环境之后就应该进入正题，开始讲语法了。但是咱不正常，所以先来谈谈怎么用别人已经写好的代码。其中最简单的，就是可以直接通过包管理程序安装的：

```bash

pip install sound
```

然后想要使用某个文件中的函数，比如假装 `wavwrite.py` 中有个函数叫 `write()`，以下写法都是可以的，注意不同 import 方法对应不同的函数调用写法：

```python

import sound
sound.formats.wavwrite.write()

from sound import formats
formats.wavwrite.write() 

from sound.formats import wavwrite
wavwrite.write()

from sound.formats.wavwrite import write
write()
```

但是，不是所有的 python 代码都可以直接安装，比如一篇论文的研究成果发表之后，处理数据的代码也往往开源，但是这些作者基本上就只是把自己写代码的文件夹公开出来而已，我们把文件夹下载下来，然后直接 `import sound`, 会报错，提示找不到名为 sound 的库。

## python 如何读取代码文件

仔细想想，找不到才是正常的，之前轻轻松松的一句 `import sound`就解决问题，这才不简单——不同的库往往位于文件系统的不同位置，但我们只要写出他们的名字就行了，不需要指定文件路径。电脑硬盘那么大，找到库却几乎是瞬间完成的。

这是因为 python 并没有搜索整个硬盘。有一个变量，一般名为 `PYTHONPATH`，其变量值是一个列表，表中成员是含有 python 库文件夹的路径。当我们在命令行输入命令的时候，电脑会：

- 搜索当前所在的文件夹，也就是在命令行输入 `python` 时终端所在的文件夹。
- 遍历 `PYTHONPATH` 中的文件夹。
- python 包管理程序默认的位置，一般是 `<path to python>/site-package`。

看看有没有我们要引用的库，找到了就引入，找不到就报错。

上一节的错误中，如果我们恰好位于 sound 所在的文件夹，然后运行 python，此时第一条生效， `import sound` 不会报错，但在其他位置就不行了。

## 名词解释：interactive, script, module, package

可执行的 python 命令可以出现在以下四个地方，第一种是接受键盘输入的程序，后三种都是文件：

1. interactive: python **交互式界面**，也叫做 calculator mode，也就是在命令行输入 `python`之后出现的界面。每次输入一句，结果在命令行上显示出来。当 python 退出之后，输入过的命令就消失了。
2. script: python **脚本**文件，也就是在命令行输入 `python somefile.py`里面的那个`somefile.py`。
    1. 毕竟 python 是一种很轻量化的语言，在一定程度上可以起到 shell 的作用，有些命令我们并不想要用完就扔，而是保存起来以便以后重复执行，另外很多命令的组合组合成函数也可以极大地简化工作。在这种语境之下, interactive 和 script 的关系，就好像 Linux 命令行和 bash script 的关系一样。
    2. 但同时 python 又是一种功能很全面的语言，完全可以胜任复杂的面向对象编程。在这种语境之下，script 也可以用来指代 main module，也就是程序执行的主文件和入口，和下面的一般的 module 相区分。
3. module: python **模块**文件，也就是在命令行输入 `python -m another` 里面的那个 `another`（注意这里不写拓展名 `.py`）。按照官方文档的说法，所有 `.py` 文件都是 module。但是实际上这句话很有误导性，上一节的 main module 和一般的 module 非常不同，下一节会详细展开讲。一般提到 module，都是在强调这个文件定义的变量和函数可以被其他的 python 文件引用。
4. package: python **包**，互相关联的 modules 构成的更高一级的可供引用的结构，简单理解就是含有 `__init__.py` 的文件夹，但是 python 并不是根据文件夹和文件之间的从属关系来确定 package 和 module 之间的关系的，下一节会详细展开讲。

## script vs. module

python 同时兼具脚本语言的灵活性，和各种重型语言的功能全面性。因为前者，所以它并不要求程序作者一定要在一个叫做 `main.py` 的文件里写一个名叫 `Main` 的类, 然后在里面实现一个 `main()` 方法。但是因为后者，没写不代表 python 不需要知道一个复杂程序执行的起点。

这个起点就是不带有 `-m` 参数的 `python` 命令后面跟着的 `.py` 文件，这就使得这个文件变得比其他 `.py` 文件特殊。底层表现就是 python 会不管这个文件的名字叫什么，都将它的 `__name__` 属性赋值为 `"__main__"`。这样，即便这个文件可能是一个大型库中间的一个模块，运行的时候 python 连它的真名都不知道，就更找不到它同级和上下级的其他模块了。

各种普通模块被 python 用到的方法就是通过在主模块 main module（或者说 script）中 import。经过“python 如何读取代码文件”一节中的搜索过程之后找到了所需模块或包，模块的名字、模块之间的关系、模块里定义了哪些属性和函数，就被 python 了解了，从而当主模块召唤他们的时候就知道去哪里找相应的代码。除了在被 import 的时候，`python -m` 命令的宾语也可以告诉 python 被运行的模块和包的相对关系：`python -m sound.formats.wavwrite` ，此时 python 执行了 `wavwrite.py` 中的所有可执行的命令，同时知道从 `sound/` 到 `wavwrite.py` 的各个包之间的关系。

## absolute import vs. relative import

开头使用已经安装过的包使用的语法全都是绝对引用 (absolute import)，表现就是 import 语句里面没有以 `.` 作为开头的。

另外一种 import 方法叫相对引用 (relative import)，`.` 表示模块所在的文件夹，`..` 表示模块的上一级文件夹。主要用在各种明确知道自己是工具代码，而且是一个更高层次结构的组成部分，几乎永远不需要被作为主模块运行的代码。

回到开头例子里的文件结构，假如 sound/effects/surround.py 中想要使用 sound/formats/wavwrite.py 和 sound/effects/echo.py 中的函数，可以写成：

```python

# in sound/effects/surround.py
from ..formats import wavwrite
from . import echo
```

## 如何组织代码，以便自己重用

研究终于推进到了准备写论文的阶段了（学渣本质暴露了），写草稿之余，之前几年时间里做过的处理和分析，接下来的一两个月里需要把工作流程规范化之后迅速重做一遍确认。

随手写散落各处的分析代码需要整理到一起，之前试图统一到一个项目之下，结果总是在某个模块引用其他模块的时候遇到报错。于是才有了这篇文章。

以下是 [这篇文章](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510) 给出的一个推荐的项目文件结构：

```

|- notebooks/
   |- 01-first-logical-notebook.ipynb
   |- 02-second-logical-notebook.ipynb
   |- prototype-notebook.ipynb
   |- archive/
	  |- no-longer-useful.ipynb
|- projectname/
   |- projectname/
	  |- __init__.py
	  |- config.py
	  |- data.py
	  |- utils.py
   |- setup.py
|- README.md
|- data/
   |- raw/
   |- processed/
   |- cleaned/
|- scripts/
   |- script1.py
   |- script2.py
   |- archive/
      |- no-longer-useful.py
|- environment.yml
```

学过这篇笔记包含的内容，我才理解作者这样的安排。既然主文件 ~~很难~~ 没办法通过相对引用来找到工具代码，索性就把工具代码写成一个完整可安装的库，然后就像 `numpy`, `pandas` 一样在独立的 notebook 和 scripts 中引用。

实际使用的时候，需要安装 `projectname` 下的代码：

```bash
cd projectname
pip install -e .
```

要知道为什么这样做，需要理解 `setup.py` 这个文件。这篇文章已经够长了，所以这个话题还是下次再说吧。

## 参考链接

- [What's the difference between a Python module and a Python package?](https://stackoverflow.com/questions/7948494/whats-the-difference-between-a-python-module-and-a-python-package). all python files re modules, while package is a specific kind of modules. It is a subsection of module in the python documentation.
- Official explanation of python module: [https://docs.python.org/3/tutorial/modules.html](https://docs.python.org/3/tutorial/modules.html)
- [This stackoverflow  answer: "run as module" is different from "run as script".](https://stackoverflow.com/questions/14132789/relative-imports-for-the-billionth-time) run as module sets the "name" to the module's name, while running as script sets it to `__main__` . Here we use "name" instead of `__name__` because it also contains `__path__` in newer versions.
- A tutorial for project organization: [https://realpython.com/python-application-layouts/](https://realpython.com/python-application-layouts/)
- Official about packaging: [https://packaging.python.org/en/latest/tutorials/packaging-projects/](https://packaging.python.org/en/latest/tutorials/packaging-projects/)
- Gist: How to organize data science project: [https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510](https://gist.github.com/ericmjl/27e50331f24db3e8f957d1fe7bbbe510)
- From the gist there is a link: [http://drivendata.github.io/cookiecutter-data-science](http://drivendata.github.io/cookiecutter-data-science)

.py | import 引用现成的代码


马上要参加一个暑期学校，关于深度学习在显微图像处理当中的应用。

深度学习是机器学习的一个分支，机器学习中的绝大多数数据都可以抽象为向量（一阶张量），绝大多数的算法都可以分解为向量之间的运算，或者对向量的变换，表示为矩阵（二阶张量）。这就对张量计算相关算法的库函数产生了很大的需求。PyTorch 和 TensorFlow，还有其他的一些库，比如 Keras，Caffe 等等等等，都是为此而生。早期版本的 pytorch 和 tensorflow 有很大的区别，但是随着版本的迭代，两者逐渐兼并和挤掉了其他的竞争者，两者的相似之处也越来越多，“变成了自己曾经最讨厌的样子”。lol

不知道课上究竟要使用哪种机器学习的框架，所以决定把 PyTorch 和 TensorFlow 全都安装了（摊手）。正好可以接着上一篇的 [python 教程](python-interpreter-editor-virtualenv) 往下写。

先说一下自己的软硬件环境：Intel 家的 CPU 和集成显卡（玩不了《文明6》）。虽然不在官方支持 Linux 的名单上，但是自己安装了 Fedora，内核更新了几次之后已经没有了兼容性问题。python 版本 3.9.6，包管理器是 pip，编辑器是 vscode。

## 建立虚拟环境

为什么要建立虚拟环境的问题本系列的前一篇已经回答过了，这次直接开干。我给两个虚拟环境分别取名为 `torch` 和`tf` 。关于命令行部分的代码，为了表示各个虚拟环境，特别加上了命令提示符`(env)[me@mycomputer]$`，抄代码的时候注意去掉。

```bash

[me@mycomputer]$ mkvirtualenv torch
(torch)[me@mycomputer]$
```

## 安装

在 PyTorch 官网，找到自己的硬件配制对应的安装命令：[https://pytorch.org/get-started/locally/](https://pytorch.org/get-started/locally/)。比如我的就是 `Stable`>`Linux`>`Pip`>`Python`>`CPU`。把生成的命令复制到命令行：

```bash

(torch)[me@mycomputer]$ pip3 install torch==1.9.1+cpu torchvision==0.10.1+cpu torchaudio==0.9.1 -f https://download.pytorch.org/whl/torch_stable.html
```

等待各种提示信息显示安装完成。

## 验证和退出

按照 [官网给出的方法](https://pytorch.org/get-started/locally/#linux-verification)，验证安装是否成功：

```python

import torch
x = torch.rand(5, 3)
print(x)

# tensor([[0.3799, 0.4494, 0.4296],
#       [0.5800, 0.0180, 0.3110],
#       [0.9847, 0.0125, 0.2648],
#       [0.0296, 0.3142, 0.9266],
#       [0.3192, 0.9645, 0.5545]])
```

为了下一步安装 tensorflow，先要退出到默认的虚拟环境：

```bash

(torch)[me@mycomputer]$ deactivate
[me@mycomputer]$
```

## 说好的 TensorFlow 呢

本来这篇文章是打算把  pytorch 和 tensorflow 一起写了，结果 tensorflow 实在是不给力。

- 直接安装

在 [TensorFlow 的官网](https://www.tensorflow.org/install)上方导航栏找到 install 按钮，然后在页面左侧找到 package/pip，[安装命令](https://www.tensorflow.org/install/pip#3.-install-the-tensorflow-pip-package)也是只有一句话

```python

pip install --upgrade tensorflow
```

然而不行，虽然安装过程中没有报错，但是验证安装的时候报出一堆错误。

报错信息里有一句 `Could not load dynamic library 'libcudart.so.11.0'`，怀疑上面命令安装的是 GPU 版本。

- 安装 CPU 版本

在网页正文的“Package Location”一节找到了 CPU 版本的安装文件：`https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow_cpu-2.6.0-cp39-cp39-manylinux2010_x86_64.whl`，于是删除虚拟环境、重建虚拟环境、重新安装。

```bash

(tf)[me@mycomputer]$ deactivate
[me@mycomputer]$ rmvirtualenv tf
[me@mycomputer]$ mkvirtualenv tf
(tf)[me@mycomputer]$ pip install --upgrade pip
(tf)[me@mycomputer]$ pip install https://storage.googleapis.com/tensorflow/linux/cpu/tensorflow_cpu-2.6.0-cp39-cp39-manylinux2010_x86_64.whl
```

运行官方提供的测试之后依然会有警告信息：

```bash

(tf) [shixing@yoga-laptop ~]$ python -c "import tensorflow as tf;print(tf.reduce_sum(tf.random.normal([1000, 1000])))"
20XX-XX-XX XX:XX:XX.XXXXXX: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
tf.Tensor(-1338.4773, shape=(), dtype=float32)
```

[stackoverflow 的这个回答](https://stackoverflow.com/questions/47068709/your-cpu-supports-instructions-that-this-tensorflow-binary-was-not-compiled-to-u) 说，需要从源码编译 tensorflow，具体的方法在[官网也有](https://www.tensorflow.org/install/source#linux)，但是实在是太麻烦了，~~（还是鸽了）~~ 下次单独写成一篇吧。

.py | Fedora 上安装 CPU 版 pytorch


上一篇 《[在 Windows 10 上配置 python 开发环境](python-installation-and-configuration)》 很惭愧，只做了一点微小的工作，大概三件事：
- 一个，安装了 python 的解释器；
- 第二个，把 vscode 安装进了电脑；
- 第三个，就是我们知道的 virtualenv 虚拟环境。

如果说还有一点什么要讲的，就是在 how 之外，讲一点 what。为了让文章更通顺一点，我打算调整一下顺序，先讲编辑器，再讲解释器，最后再说虚拟环境。虽然文章是立足于 python 来谈，但是这些知识适用于几乎所有通用编程语言。因为我也不是计算机专业出身，这篇文章只是我的学习笔记，如果有不对的地方欢迎大家指出。

## 编辑器

首先我们来做一个实验，把上次教程里创建的 python 文件 `hello.py` 重命名，把拓展名 `.py` 改成 `.txt`, 然后双击鼠标打开文件，会发生什么？在 Windows 系统里，会弹出最最普通的记事本窗口，窗口里是白底黑字的 python 语句，不像 vscode 里面不同语句有不同颜色，但是内容完全一样。

甚至更进一步，你可以在命令行里直接让 python 编译器执行 `.txt` 文件的内容，（`py -m hello.txt`）效果和 `.py` 也是一样的。

`.py` 这个拓展名什么也没有做，和 `.txt` 文件一样，内容就是一串我们人类能够读懂的字符，这样的文件叫做[文本文件](https://zh.wikipedia.org/wiki/%E6%96%87%E6%9C%AC%E6%96%87%E4%BB%B6)。处理文本文件的程序，就叫做[编辑器](https://zh.wikipedia.org/wiki/%E6%96%87%E6%9C%AC%E7%BC%96%E8%BE%91%E5%99%A8)。记事本就是一种编辑器，vscode 也是。

既然记事本就可以编写 python 代码，那我还费劲安装 vscode 干嘛？确实有人真的只用记事本或其他操作系统自带的编辑器写 python 代码，（油管上还有一个视频是用 Microsoft Word 写代码；）然后用命令行调试程序，但是 vscode 毕竟是专为程序员而开发，提供了很多默认编辑器不具备的功能，比如前面提到将函数、变量、保留词显示成不同的颜色的语法高亮功能。

## 编译器 / 解释器

除了文本文件，这篇文章里涉及的第二种文件是[二进制文件](https://en.wikipedia.org/wiki/Binary_file)。

电脑并不能直接看懂人类认识的字符，在一切的最底层，经典计算机认识的是以不同方式表示的 0 和 1。虽然说所有文件在底层都是二进制的文件，但是“二进制文件”这个名词一般专门用来表示除了文本文件之外的文件，又因为图片文件、视频文件啥的都有自己的名字，所以这个词用来指代的文件，基本上都和软件程序，可以让计算机执行的文件有关。

人类只认识字符，计算机只认识 0 和 1，那么最直觉的思路就是把文本文件翻译成二进制文件。这个翻译过程叫做[编译](https://en.wikipedia.org/wiki/Compiler)，能够完成这一过程的软件就叫做编译器。编译器编译完成之后就退出了，要想执行程序，电脑直接执行编译之后的可执行文件就可以了。

但是编译存在一个问题，就是整个软件需要在所有的源代码文本文件都写好的情况下才能被编译成软件，编译耗费的资源和时间随着软件规模的增长而扩大；一旦修改某处，整个项目又要重新编译。很多时候我们只想快速地知道某个大型项目中的某一句命令的效果是什么，编译这种方法就不适合这种场景了。

于是就出现了[解释器](https://en.wikipedia.org/wiki/Interpreter_(computing))，这种程序比编译器复杂的多，在我们执行这种编程语言命令的时候始终运行，允许我们一句一句地输入命令，记得代码的上下文，还记得我们之前命令的结果，代价就是对于大型项目也需要一句一句地分析解释，计算资源的开销和速度都不如编译。

python 就是一种（官方实现）使用解释器的编程语言，我们在官网下载的那个 `python-***.exe` 文件就是 python 的解释器。这也导致了 python 程序的性能往往不如同水平的 C/C++ 程序员写出来的程序，但是由于单句执行适合试错，所以在 ~~经常犯错的~~ 科研领域还挺流行的。

当然了，python 的特点远不仅仅是解释型语言这么简单，它还是一种：
- [脚本语言](https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html)
- [动态语言](https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html)
- [面向对象语言](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)
- [函数式编程语言](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)
- [……](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)

## 虚拟环境

有一次我问我女朋友，她写 python 用什么 IDE，她很自豪地回答，她的 Macbook 自带 python，直接在命令行就可以运行……答非所问还不是最大的问题（仔细想想好像也不是答非所问，不过只回答了问题的一部分），而是直接在命令行运行系统自带的 python，或者其他编程语言的解释器或者编译器，本身就是编程初学者常干的一种危险行为。

Windows 还好，毕竟这是一个面向广大家用消费者的操作系统，防呆设计还是挺多的，没有原装的 python。更加极客向的操作系统，比如 Linux 和 BSD 家族可就不一样了，这些操作系统（的发行版）往往预装了 python。这个 python 可不是给用户拿来开发自己的程序用的，而是用来让很多 python 语言写成的操作系统工具调用的。既然如此，这个 python 的版本一般由发行版的安装包管理者来控制，往往落后最新的 python 版本一段时间，为了避免新版本 python 有什么 bug，也为了让操作系统工具的开发者有时间更新自己的代码。所以如果直接用这个版本的 python 做开发，而且不小心自己升级了 python 的版本，很有可能导致系统的某些功能失常。

虚拟环境就是 python 对这个问题的解决方案。我们可以安装不同于原装 python 的版本，但是并不将这个解释器加入系统路径，操作系统也就不知道这个版本 python 的存在。创建虚拟环境的时候，我们指定使用这一特定版本的 python，这样在虚拟环境激活之后就是我们开发需要的 python，退出虚拟环境就是系统工具使用的 python。

另外，即便两个项目适用于同一个 python 版本，而且都是系统自带的这个版本，虚拟环境也有用武之地。绝大多数程序都需要依赖别人写好的工具代码，这些代码叫做库 (library)，不同的项目可能依赖不同的库代码，或者同一个库的不同版本。这个时候，可以创建不同的虚拟环境，并在其中安装各个项目对应的库，项目之间可以互不影响。

## 编辑器 + 解释器 / 编译器 + 虚拟环境管理 + …… = IDE

为了开发 python 程序要安装这么多不同的程序，太麻烦了，就不能一键安装全搞定吗？当然可以了，这种集成了开发过程中用到的各种工具的程序，就叫做[集成开发环境 (IDE)](https://zh.wikipedia.org/zh-cn/%E9%9B%86%E6%88%90%E5%BC%80%E5%8F%91%E7%8E%AF%E5%A2%83)。对于 python，最有名的 IDE 当属 [Anaconda](https://www.anaconda.com/) 了。

那我为什么不用呢？当然用过，但是听说了 vscode 的大名，而且尝鲜之后，就再也回不去了。写 python 需要编辑 `.py` 文件，写博客需要编辑 `.md` 文件，博客的一些功能需要 JavaScript 实现，这些事情本质上都是编辑文本文件这一件事，在 vscode 这样的编辑器里全搞定就再自然不过了，那么 Anaconda 里的 Spyder 和 Jupyter Lab 就显得多余了。

“把一件事做好”，这也是 [Unix 哲学](https://zh.wikipedia.org/wiki/Unix%E5%93%B2%E5%AD%A6)的一部分。但是问题在于，不同的人对于“一件事”的定义是不同的，有些人觉得做早饭是一件事，有些人觉得是热牛奶煎鸡蛋烤面包等等好几件事，谁是对的？

也许都对，但是 编辑器 + 解释器 + …… 比起 IDE 就是处在鄙视链的上游。这一点可以不同意，但是应该要知道，不然别人抖包袱的时候你没捧上哏，挺尴尬的。


.py | 笔记：python 编辑器、解释器、虚拟环境


我的 python 版本之前一直停留在 3.7，目前最新已经到了 3.9。最近研究上要用一段别人写的 python 的代码，原作要求 3.6 版本的 python，所以卸载了 3.7 版本，重新安装了 3.9 和 3.6 两个版本的 python。

煽动爸妈学编程很久了，欠他们一篇教程。不论是打算不断精进者的第一门编程语言，还是浅尝辄止者打算学的唯一一门语言，python 都是一个很不错的选择。所以即便爸妈对编程可以说是毫无兴趣，我也还是把这篇教程写完了，希望能帮到其他人。因为是面向纯新手的，所以基于 Windows 10 操作系统。因为这套设置我自己也要用，出于个人偏好，所以没有直接使用 `conda`。

## ~~别看你今天闹得欢~~ 先拉个清单
- python
    - 在官网下载 `python` 解释器
    - 安装 `python` 解释器
- 虚拟环境
    - 设置环境变量
    - 用 `pip` 安装 `virtualenv` 
    - 用 `pip` 安装 `virtualenvwrapper`
    - 创建一个虚拟环境，安装 `jupyter`
- 编辑器
    - 在官网下载 `vscode`
    - 安装 `vscode` 和相关插件
    - 测试一下效果

## 教程本体

### 在官网下载 `python` 解释器

在 python 的官网上 ([https://www.python.org/downloads/](https://www.python.org/downloads/)) 下载

![](/photos/2021-03-07-python-official-website.png)

### 安装 `python` 解释器

执行下载的文件，可以看到如下图所示的界面，点击红框中的选项，因为我想更改安装路径。此处似乎也可以勾选最下面的 "Add Python 3.9 to PATH"，我安装的时候没有选，后面才发现还要手动完成这一工作。

![](/photos/2021-03-07-python-install.png)

接下来的界面里每个选项都勾选，next。

![](/photos/2021-03-07-python-next.png)

在接下来出现的界面中，选择 "Install for all users"，然后选择一个自己喜欢的安装路径。我之所以选择 `C:\Python39` 这个位置，是因为:
1. C 盘是系统盘，而且是固态硬盘，比较快；
2. 默认路径在个人文件夹里，非常难找
3. `C:\Program Files` 需要管理员权限，用 `pip` 做软件包管理不方便。

![](/photos/2021-03-07-python-install-path.png)

安装完成后进入命令提示符，输入 `py`，应该可以看到一串 python 版本信息，然后命令提示符变成 `>>>` 字样，此时就已经进入了 python 环境，可以按行运行 python 命令。输入 `exit()` 就可以退出 python。

### 设置环境变量

在 windows 的搜索框里输入 "environment variables"，没等你输完，应该就可以看到下图中的联想结果：

![](/photos/2021-03-07-environment-variable-search.png)

再按照下图，依次点击按钮，一共要做两件事:
1. 给 `Path` 变量添加 `C:\Python39` 和 `C:\Python39\Scripts` 两个新值。
2. 新建一个文件夹，用于存放 python 的虚拟环境（比如 `C:\PythonEnvs`）。创建一个名为 `WORKON_HOME` 的新变量，并将其值设为 `C:\PythonEnvs`.

![](/photos/2021-03-07-environment-variable-box.png)

### 用 `pip` 安装 `virtualenv` 和 `virtualenvwrapper`

按照刚才的步骤，此时 `pip` 应该已经安装，此时在命令行输入途中的命令，应该可以看到类似的返回信息：

![](/photos/2021-03-07-pip-check.png)

如果命令行说没找到 `pip`，可能需要按照[这个链接](https://pip.pypa.io/en/stable/installing/#installing-with-get-pip-py)里的方法重新安装。

在命令行中输入 `py -m pip install virtualenv`， 安装虚拟环境管理器：

![](/photos/2021-03-07-virtualenv-install.png)

显示安装成功之后，在命令行输入 `py -m pip install virtualenvwrapper-win`，结果应该和上图差不多，忘了截图。

### 创建一个虚拟环境，安装 `jupyter`

`virtualenv` 和 `virtualenvwrapper` 安装完成之后，在命令行中输入 `mkvirtualenv base`，新建一个名为 base 的虚拟环境。

然后输入 `workon base`，此时命令提示符的行首应该会多出一个 `(base)` 字样，这说明我们已经工作在了 base 这个虚拟环境里。此时 `pip --version` 的结果说明我们的 python 的地址已经和之前不同了。

![](/photos/2021-03-07-virtualenvwrapper-check.png)

在这个环境之下，安装 jupyter，输入命令 `pip install jupyter`，安装 jupyter。这一步不是必须的，但是这样我们将来安装 vscode 之后，可以获得和 conda 自带的 spyder 类似的体验，菜鸟逐行调试的时候非常方便。

### 下载和安装 `vscode`

从 vscode 的官网下载安装包（[链接在此](https://code.visualstudio.com/)），可以看到大大的下载按钮：

![](/photos/2021-03-07-vscode-download.png)

下在之后的安装过程就和一般的程序安装一样（安装很久了，没有截图）。

安装完成之后打开程序，点击左侧工具栏红框中的那个图标，搜索 python 的相关 vscode 插件。python 开发一般都需要 `python`, `pylance`, `jupyter` 这三个：

![](/photos/2021-03-07-vscode-plugin.png)

以后要运行 vscode 的时候，在你想开始写代码的文件夹里，鼠标右键单击，选择 "Open with Code":

![](/photos/2021-03-07-vscode-folder-open.png)

然后在 vscode 的界面，在文件树上单击红框中的按钮，新建一个文件，命名为 `*.py`，这里随便写了个 "hello".

![](/photos/2021-03-07-vscode-new-file.png)

在随后打开的文档编辑区输入 `print("Hello World")`，将光标停留在这一行，按 `Shift`+`Enter` 执行这一行：

![](/photos/2021-03-07-vscode-run.png)

因为是第一次执行，又因为安装了 `jupyter`，这时候 vscode 的右下角应该会出现一个提示框，询问是否用 jupyter interactive window 执行代码。然后关掉下方的这个 terminal (下半区右上角的叉号)。重新按 `Shift`+`Enter` 执行，此时的结果应该如下图，点击红圈中的变量浏览器，这就几乎和 spyder 的体验一样了。

![](/photos/2021-03-07-vscode-interactive.png)


.py | 在 Windows 10 上配置 python 开发环境


“图”这个字在英语中可以对应好几个词，picture, image, figure, plot... 其中的 plot，意思是展示两组或两组以上的数据之间关系的图像。用时髦一点的话说，就是数据可视化的产物。  

所谓`matplotlib`，顾名思义，~~`mat` 表示山寨 MATLAB~~，`plot` 的含义如上所述，`lib` 表示这是 python 的[一个第三方库 (library)，而不是某种领域专用的编程语言 (domain specific languange, DSL)](http://www.yinwang.org/blog-cn/2017/05/25/dsl)。

所谓 API，全称是 application programming interface, 应用程序接口，约等于在你有了自己的数据，想调用 matplotlib 来画图的时候，那些需要写在你自己代码里的语句的语法规则。

因为是代码库，所以在一切开始之前，需要在你的 python 代码开头声明引入

```python
import matplotlib.pyplot as plt
```

`plt` 可以换成你喜欢并且不和其他代码冲突的名字，但是这三个字母是大家的约定俗成的，网上的绝大多数示例代码都这么写，~~照抄就完事了。~~

## `matplotlib` 的两种 API

`matplotlib` 有两种 API，（其实还有第 3 种 `pylab`，但它没能经得起时间的检验，已经处于官方极不推荐的状态），分别是：

- 基于状态的 (state-based)
- 面向对象的 (object-oriented)

两种风格混用的话大概率没法玩得转，会产生各种出人意料的输出结果，新手 debug 的能力又比较差，所以最好先选边站队，有时间再学剩下的一个。

对于有 MATLAB 基础的朋友，基于状态的 API 语法和 MATLAB 几乎一模一样，几乎可以直接上手，当年 python 算是后起之秀，这一招当初就是为了从 MATLAB 那里吸引用户， ~~相当歹毒。~~ 这套接口本身也比较简单，适合在调试程序的时候快速看一下结果，检查错误。

对于一般的初学者，matplotlib 的代码本身就是用面向对象的编程范式写成的，学习这套 API 可以更好的理解代码，知道自己究竟在干什么，顺便还可以熟悉一下面向对象的编程范式。现在学 python 之前就会 MATLAB 的人越来越少，网上 ~~可供复制粘贴~~ 的示例代码越来越多地使用面向对象的语法，学习面向对象的接口也更加实用。

## 两种 API 的相同任务

![](/photos/2020-10-04_figure-and-axes.png)

上图来自网上随便找的一篇论文，可以看到，一般我们会把信息相关的几幅小图放在一起，在文章排版的时候，这张组合在一起的图片算作一个单位。在 matplotlib 里面，这样一个基本单位叫做 `figure`，而每一幅小图叫做 `axis` （变量名常简写作 `ax`）。平时的单图可以看作只有一个 `axis` 的 `figure`，多图的时候往往用一个 tuple `axes` 的 `__getitem__()` 方法来控制每个子图。

![](/photos/2020-10-04_anatomy-of-figure.png)

上图[来自官网](https://matplotlib.org/gallery/showcase/anatomy.html#anatomy-of-a-figure)，图中的蓝字就是 matplotlib 认为的一张只有一个 axis 的 figure 所包含的元素。

两种 API 要做的事情，就是建立 `figure` 和 `axis`，然后提供函数/方法来生成或者改变各个元素。

## 基于状态 (state-based)

所谓基于状态的 API，不太好解释，前面已经说过，在每个函数前面加上 plt，剩下的就和写 MATLAB 几乎完全一样。

看[官网给出的教程](https://matplotlib.org/tutorials/introductory/pyplot.html#sphx-glr-tutorials-introductory-pyplot-py)，可以观察到两个有趣的现象：

- 几乎没有赋值运算符 `=`
- 几乎所有的 `.` 前面都是 `plt`

也就是说，与 matplotlib 相关的命令都是函数，而且不需要将返回值赋给任何变量。`figure` 和 `axis` 的概念被隐藏起来了，`plt.figure()` 建立一个 figure；`plt.subplot()`建立多个 axes，并且将程序的注意力放到函数参数指定的子图上；紧跟着的设定各种元素的函数都会作用到之前最新一个 `plt.subplot()` 所指定的子图上。

没有赋值说明函数的返回值并不重要，这些函数都会作用在后台维护的 figure 和 axis 的状态机上面，也就是说这些函数都有副作用，不是纯函数。

## 面向对象 (object-oriented)

[作为对比](https://matplotlib.org/gallery/showcase/anatomy.html#anatomy-of-a-figure)：

- 头几句会有赋值运算符 `=`，被赋值的变量名一般就是 `fig` 和 `ax`。
- `.` 前面都是 `fig` 和 `ax`，其中 `ax` 居多。

`fig` 和 `ax` 分别是 `matplotlib.figure.Figure` 和 `matplotlib.axes.Axes` 两种对象的实例，画图和调整都是在调用两种对象的方法，主要是 `ax` 的方法。

## 不同之处 Cheat Sheet

绝大多数命令，在两种 API 之下的名字都一样，差别就在于开头究竟是 `plt.` 还是 `ax.`，但是少数命令不同，下面做了一个表格，进行一个不完全的列举：

| State-Based | 任务 | Object-Oriented |
|---|---|---|
|`plt.figure(**args)`|__新建 figure__|`fig = plt.figure(**args)`|
|`plt.subplot(**args)`|__新建 axis__|`ax = fig.add_subplot(**args)`|
|好像没有|__同时新建 figure 和复数 axes__|`fig,axes = plt.subplots(**args)`|
|`plt.title(**args)`|__设置 figrue 标题__|`ax.set_title(**args)`|
|`plt.xlabel(**args)`|__设置 x 轴名称__|`ax.set_xlabel(**args)`|
|`plt.ylabel(**args)`|__设置 y 轴名称__|`ax.set_ylabel(**args)`|
|`plt.xlim(**args)`|__设置 x 轴范围__|`ax.set_xlim(**args)`|
|`plt.ylim(**args)`|__设置 y 轴范围__|`ax.set_ylim(**args)`|

其他不同的命令，以后用到的时候会随手更新。


.py | matplotlib笔记：两种API


当初博客开张的时候，原计划在编程语言方面聊聊 C++、Java 和 Python。谁曾想半年多过去了，尚未写过 Python 的帖子。实在是说不过去啊！所以今天赶紧写一篇来凑数。

其实俺接触 Python 的时间，也不算太早（大概是2003年那会儿）。当时看到 Eric Raymond 关于几大编程语言的评价（原文在“这里”，翻译在“这里”），之后又看了他写的《Why Python?》。感觉这位大牛蛮器重 Python 滴，于是俺也就跟风学习了一番。从此一发不可收拾——现在 Python 已然成为俺最常使用的脚本语言了。

接下来，俺就从几个不同的角度来鼓吹一下 Python。假如你从来没有听说过或者从来没用过此语言，听了俺的忽悠之后，或许会有所心动 :-) 假如你觉得俺只不过是 Python 阵营的枪手，发发广告帖，那你就不用再浪费宝贵的时间去看后续的帖子了。

按照俺先前的习惯，会把接下来的内容拆成几个帖子来写......

为了方便阅读，把本系列帖子的目录整理如下（需翻墙）：

1. [作为脚本语言的 Python](RP-why-choose-python-1-script)
2. [作为动态语言的 Python](RP-why-choose-python-2-dynamic)
3. [作为面向对象语言的 Python](RP-why-choose-python-3-oop)
4. [作为函数式编程语言的 Python](RP-why-choose-python-4-fp)
5. [作为瑞士军刀的 Python](RP-why-choose-python-5-tool)
6. （未完待续）


> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：<br>
>
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html">https://program-think.blogspot.com/2009/08/why-choose-python-0-overview.html</a>

.py | 转载：为什么俺推荐 Python[0]·概述


### 文章目录

* [脚本语言好在哪？](#pros)
* [脚本语言有啥缺点？](#cons)
* [Python 和其它脚本语言的比较](#compare)
* [总结](#summary)

俺窃以为，Python 的所有特征中，作为脚本语言（“脚本语言”的定义参见“[这里](https://en.wikipedia.org/wiki/Scripting_language)”）是它的首要特征。因此，在本系列帖子中，俺首先来忽悠一下 Python 作为脚本语言，有些啥好处？

# 脚本语言好在哪？<a name="pros"></a>

要聊 Python 作为脚本语言的好处，首先得说说脚本语言自身有哪些优点。一般来说，当我们提及“脚本语言”，都是强调其解释执行的特性（虽然有些脚本语言也支持编译）。所以，后面陈述的这些优点，大都是拿编译型语言来进行对比。

## 更高层次的抽象和封装

大部分脚本语言都提供了（内置了）比较高层次的抽象和封装。像很多脚本语言都内置了字符串处理能力以及正则表达式（典型代表就是 Perl）。还有很多脚本语言都内置了高级的数据结构。比如 Python 在语言层面支持了链表（Python 的术语叫 List）、映射（Python 的术语叫 Dict）、元组（Python 的术语叫 Tuple）。

有了这些高层次的封装，你写起代码来，就特别滴简单、特别滴爽。比如，在 Python 中要把一个 List 翻倍，只需这么写：

```python

[1,2,3] * 2

```

就得到

```python

[1,2,3,1,2,3]

```

## 更少的代码量

得益于高层次的封装，在完成相同功能的前提下，脚本语言的代码量会比编译型语言少很多。

比如说，要打印出某个文本文件的内容，如果用 Java 实现，正常的写法大概要七、八行代码（把所有代码硬挤到一行的，不予讨论）；用 Python 也就三、五行。

再比如说，抓取某个网址对应的 web 网页，用 Python 自带的标准库实现，大概3到5行代码；但如果用 C++ 实现，代码量会增加许多（具体要写多少代码，取决于你用了哪个 http 的库）。

代码量少了之后，至少你看代码的时候（无论是看自个儿滴还是看别人滴），能少敲很多次翻页键，大大延长了键盘的寿命，顺便降低了手指头的劳损。

## 更好的可读性

当然啦，延长键盘寿命还不是关键，关键在于——代码量少了之后，（通常情况下）会有助于提高可读性。而可读性恰恰是 Python 的强项之一。

比方说：Python 在【语法层面】强制约定了作用域缩进（这是俺很喜欢 Python 的地方之一）。如此一来，即便是新手程序猿写出的 Python 代码，缩进风格也很统一。反观 C/C++/Java 的新手，写出的代码就没有这么整齐了。

## 更平缓的学习曲线

通常，脚本语言的语法都比较简单、傻瓜化。因此，入门也就容易很多。稍微有一些编程基础的人，就能够在短时间内上手。

比如俺手下的 C++、Java 程序员，以及某些测试人员，都可以在一周内（程序员用不着一周，一般就1、2天）掌握 Python 的语法并用来写一些辅助的小工具。大大节约了俺培训的口水。

## 支持“交互式”

很多脚本语言的 IDE 支持【交互式写代码】。也就是说，你每写完一行代码，解释器就执行一把。这样能很快发现输入错误，而且还可以立即看到执行结果。

# 脚本语言有啥缺点？<a name="cons"></a>

前面说了那么多优点，那脚本语言有啥缺点捏？

主要的缺点就是【性能差】。这是他们为上述优点所付出的沉重代价。所幸当今的计算机硬件突飞猛进，性能差的缺点已经越来越不明显了。

# Python 和其它脚本语言的比较<a name="compare"></a>

有同学可能要问了，脚本语言有很多，为啥俺独独青睐 Python 捏？

为了回答这个问题，下面俺拿 Python 和一些常见的脚本语言作一些【肤浅的】比较。

鉴于后面的内容极易引发语言的口水战，俺特此声明：虽然接下来会提及某些语言相对于 python 的缺点，但俺绝无贬低这些语言的企图，也无意证明 python 比这些语言优秀！俺只是陈述一下：当年是如何在几种脚本语言中进行取舍的？

除了 Python 之外，常见的脚本语言还有很多，比如：PHP、JavaScript（以下简称 JS）、Perl、VBScript（以下简称 VBS）、Ruby、Bash、Lua、Tcl（可别误以为是某家电厂商）......Python 是如何从这些脚本语言中脱颖而出的捏？俺挑选的时候，主要考虑了如下几点：

## 通用性（跨领域）

因为俺懒得学太多编程语言。所以，俺希望熟悉一门脚本语言之后，能够尽量多帮俺搞定不同领域的事儿。从这点来看，俺就不会选择 PHP（太偏重于 Web 服务端）、JS（太偏重于 Web 客户端）、诸如 Bash 之类的 Shell 脚本（太偏重于系统管理）。

而 Python 则属于通用的脚本语言，覆盖范围很广。比如 Web 开发、桌面 GUI 应用、系统管理、网络应用、科学计算等许多领域，Python 都可以轻易搞定。

## 人气够旺

关于“人气”的重要性，俺在《如何选择开源项目》一文中，有介绍过。人气越高、越流行，就意味着更多的资源（包括文档、相关软件），当你碰到问题需要解决，也有更多的人可以咨询。

关于编程语言的流行程度，可以大致参考 TIOBE 的排名（虽然 TIOBE 不能全面反映流行程度，但至少可作为某种参考）。

像 Tcl、PowerShell、Groovy、JavaFX 等都排在３０名之外（截至写本文的2009年8月），感觉用的人太少了，俺暂时不予考虑。而 Python 最近几年的排名则一路上升（请看“这里”），截止到2009年8月，已经高踞排行榜第６位。Perl 虽然也身居高位，但是最近几年的排名一路下滑（请看“[这里](http://www.tiobe.com/content/paperinfo/tpci/Perl.html)”）。俺个人认为，其人气不容乐观。

## 功能够强、库够丰富

另一个俺很看重的地方是功能是否够强大。在这点上，Python 和 Perl 都算是比较强悍的。关于 Python 如何强悍，俺会在本系列的第5篇帖子《作为瑞士军刀的 Python》中加以介绍。

反观 JS、Ruby、Tcl 等语言，则稍显不足（当然，也有可能俺孤陋寡闻）。

## 跨平台

由于俺平时会使用不同的操作系统，再加上俺负责的产品也是跨平台的。所以，俺对脚本语言有跨平台的要求。说到跨平台，诸如VBS、Bash之流就不予考虑了。

其实，很多脚本语言都支持跨平台。而 Python 在这方面，更为出众。不光支持主流的操作系统，还支持一些冷门的（比如古老的 DOS），还支持手持设备（比如智能手机和平板）。

## 和其它语言的整合、交互

最后这一点，估计大多数同学不会太关心。俺因为要在公司的产品中引入脚本技术，所以俺还得考虑该脚本语言和其它语言的整合能力。整合能力强的脚本语言，可以作为复杂系统中的胶水，用来把不同模块粘合在一起（关于 Glue Language，可以参见“[这里](https://en.wikipedia.org/wiki/Glue_language)”）。

在这方面，Python 和 Ruby 的表现都不错：

它们和 Java 的整合有Jython、JRuby；

和 dotNet 平台的整合有IronPython、IronRuby。

至于俺常用的 C++，Python 整合得比 Ruby 好。比如 C++ 社区大名鼎鼎的 Boost 库里面，就内置了一个 Boost.Python 的子库（参见“这里”）。

关于 Python 如何用作胶水，俺会在后续的帖子“作为胶合语言的 Python”中会详细介绍。

# 总结<a name="summary"></a>

基于上述几个方面的考虑，俺最终选择了 Python 作为日常使用的脚本工具，并把它引入到公司的产品中，作为模块之间的胶合剂。

啰嗦完Python作为脚本语言的方方面面，下一个帖子，咱来聊一下它作为动态语言的那些事儿。


[回到本系列的目录](RP-why-choose-python-0-overview)

> *版权声明*<br>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：<br>
> <a href="https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html">https://program-think.blogspot.com/2009/08/why-choose-python-1-script.html</a>

.py | 转载：为什么俺推荐 Python[1]·作为脚本语言的 Python


### 文章目录

* [动态语言扫盲](#overview)
* [为啥要学习动态语言？](#whyDynamic)
* [为什么是 Python？](#whyPython)
* [总结](#summary)

上一篇帖子介绍了脚本语言的优缺点，然后又拿 Python 和其它脚本语言PK了一下。今天主要是忽悠一下动态语言，捎带忽悠一下 Python。如果你看完本贴，觉得动态语言不错，那俺建议你从 Python 开始入手。

# 动态语言扫盲<a name="overview"></a>

考虑到还有很多同学对动态语言了解不深入，有必要先来普及一下它的基本常识。已经了解的同学，请略过本节。

通俗地说：能够在运行时修改自身程序结构的语言，就属于动态语言。那怎样才算是“运行时修改自身程序结构”捏？比如下面这几个例子都 算：在【运行时】给某个类增加成员函数及成员变量；在【运行时】改变某个类的父类；在【运行时】创建出某个函数......

从这些例子，你应该对动态语言有一个初步的感觉了吧？毕竟传统的静态语言（比如C、C++、Java），是很难达到这些效果滴。

另外，有个误区需要澄清一下。很多同学以为脚本语言也就是动态语言。其实两者是不等价滴——虽然两者有很大的交集。比如 C# 在4.0之后，就可以算是动态语言了，但它不能算是脚本语言；另外，有很多 Shell 脚本语言（比如 DOS & Windows 下的 bat），不能算是动态语言。

关于动态语言更深入的介绍，大伙儿可以看“这里”。

# 为啥要学习动态语言？<a name="whyDynamic"></a>

扫盲之后，就该来说一下，学习动态语言的动机了。搞明白动机，学起来才有干劲嘛 :-)

## 顺应大趋势

假如你经常关注 TIOBE 的排名，那你应该能察觉出来，动态语言近两年的发展势头比较迅猛（在 Top10 里面，至少占了半壁江山）。这能从某个侧面反映出动态语言的影响力在扩大。

假使你不相信 TIOBE 的排名，俺再举一个例子。两大开发阵营（Java 和 dotNet）最近几年也加大了对动态语言的支持力度。比如，dotNet 的 CLR 加入了对IronPython 和 IronRuby 的支持；Sun 当然也不甘示弱，JVM 也开始支持 Groovy，JRuby 等语言。

俺费了这许多口水，列位看官应该明白动态语言是大势所趋吧。在这动态语言大行其道的日子里，你如果连一门动态语言都没搞懂，那出门都不好意思跟人打招呼。

不过，话又说回来，静态语言也是不会消亡滴。毕竟，静态语言有自己的优势（比如严谨、性能）。长期来说，必定是动态语言和静态语言并存。各自弥补对方的缺点。

## 了解新思维、新理念

学习一门动态语言还有一个好处：有很多时候，多学习一门语言，并不一定是为了在工作中用它，而是为了学习新的思维方式、体会新的理念。比如俺就曾经花时间去看 Prolog，但是俺在工作中，从来不需要用到它。（以后有空的话，俺会介绍一下这玩意儿）

由于动态语言可以在运行时修改自身结构，因此就会产生很多静态语言所没有编程范式和手法（比如 eval、Mixin）。如果你以前只使用静态语言，那你在学习了动态语言之后，多半会从它身上领略到很多新的思想和理念。

（关于 eval 的招数，俺后来写了一篇《再举几个动态语言 eval 手法的例子》）

## 能够化繁为简

可能有些同学觉得，前面说的都有些务虚，那咱再来说点具体实在的。大牛 Edsger Dijkstra（图灵奖得主）曾经说过：编程的艺术就是处理复杂性的艺术。咱们来看看，动态语言是如何处理复杂问题滴。

假设要你实现一个函数，用来完成两个数的“某种运算”，具体的运算类型作为函数的参数传入，然后该函数返回运算结果。比如：

```python

Foo("+", 2, 4)  # 返回 6
Foo("*", 3, 5)  # 返回 15

```

对于上述需求，你会如何实现捏？

请先暗自盘算一柱香的功夫，然后再往下看。

．．．．．．

Ｔｈｉｎｋｉｎｇ

．．．．．．

如果你用静态语言（比如 C、C++、Java）来实现，你可能会在函数内使用一个 switch，根据不同的运算符，进行计算，然后返回计算结果。

对于某些比较 ＯＯ 的语言（例如 C++、Java），你或许还会抽象出一个运算的接口类（纯虚类），然后分别派生出若干个不同的计算类（比如加法类、乘法类），看起来似乎比 switch 要优雅一些。

当然，用静态语言还有其它一些玩法，但是代码量都不会少。具体详情可以看很早以前的一个老故事：《4个程序员的一天》。（其实俺这个例子的灵感就是从那个老故事剽窃滴）

现在，咱们来看看 Python 是如何【优雅地】实现该需求滴。用 Python 只需要【两行代码】即可。请看：

```python

def Foo(op, n1, n2) :
    return eval( "%d %s %d" % (n1, op, n2) )

```

不懂 Python 的同学可能要问了，这两行代码是啥子意思呀？

其实，第一行代码只不过是定义了一个函数头，第2行代码才是精华。这里面利用了动态语言常见的 eval 手法（具体参见“这里”）。在 python 里面，内置的 eval 函数可以把某个字符串当成一个表达式，并对其求值。而语句 "%d %s %d" % (n1, op, n2) 只不过格式化出一个表达式的字符串。

顺便再插一句，Python 还有一个 exec 的内置函数，可以把一段 Python 源代码作为字符串参数传递给它，让该函数去执行。两个函数结合起来，就能玩出很多花样。具体的花样可以参见“这篇博文”。

# 为什么是 Python？<a name="whyPython"></a>

说了动态语言的种种好话，有同学会问了，动态语言有很多种，为啥非要学习 Python 捏？

首先，俺在本系列的第1篇帖子，已经对比过 Python 和另外几种脚本语言。那几种“脚本语言”碰巧也是知名的“动态语言”。Python 相对于他们的优势，此处就不再重复啰嗦了。

其次，单就语法本身而言，Python 的语法对动态性的支持是很优雅、很简洁滴。通过刚才那个 eval 小例子，大伙应该已经看出来了。为了更形象一点，咱拿前面提到的 Mixin 来 Show 一下 Python 的语法是如何的简洁。

通俗地说，Mixin 手法需要在【运行时】给某个类增加基类（也就是父类）。对于 Python 而言，每一个类都有一个内置属性 __bases__，里面包含这个类【当前】的所有基类。假如要在【运行时】增加基类，只需操作 __bases__ 这个属性即可。

比如有一个类 A 和类 B。如果要在运行时把 B 加为 A 的父类，可以用如下语句：
A.__bases__ += (B,)

是不是也很简洁，而且可读性也不差？相比而言，有些动态语言（比如 JavaScript），要实现类似的效果，代码就相对复杂了。

由于 Mixin 不是今天的重点，就不再深入展开了。


# 总结<a name="summary"></a>


最后，来个总结发言：如果你之前没有接触过动态语言，建议去学习一下；如果你已经打定主意要学，Python 是比较好的候选者。

好了，今天就聊到这里。下一个帖子，咱们来讲讲 Python 作为一个纯粹的面向对象语言，有些啥特色。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明**<br>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：<br>
> [ https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html ](https://program-think.blogspot.com/2009/08/why-choose-python-2-dynamic.html)

.py | 转载：为什么俺推荐 Python[2]·作为动态语言的 Python


### 文章目录

* [抽象（Abstraction）](#abstract)
* [封装（Encapsulation）](#encap)
* [继承（Inheritance）](#inherit)
* [多态（Polymorphism）](#poly)
* [结尾](#summary)

本系列已经中断了很长时间 :( 直到最近一个读者来信问俺，为啥不继续写，俺才突然想起这个被遗忘的系列，实在是抱歉！前一个帖子介绍了作为动态语言的 Python，今天来聊一聊 Python 在面向对象编程（OOP）方面的特色。

本文主要针对那些熟悉 OOP，但还不熟悉 Python 的同学。为了让大伙儿有一个直观的认识，俺会拿 C++/Java 来进行语法上的对比。（这俩语言的名气够大，且号称支持 OO，也算有些可比性）

强调一下：本文虽然拿了某些语言来作对比，但丝毫没有贬低这些语言的意思，请这些语言的粉丝们，不要对号入座 :)

# 抽象（Abstraction）<a name="abstract"></a>

但凡介绍 OOP，自然会提到抽象。因为抽象，是 OO 的第一要素，也是其它要素的基础。而提到抽象，又不免提到对象（Object）。所以，俺首先来聊一下，Python 语言是如何体现“对象”这个思想的。

## Python的对象

如果要问俺，什么是 Python 中的对象，还真不好下一个严密又通俗易懂的定义。为了敷衍大伙儿，俺只好用一句话来概括，那就是 Python 语言中，【一切皆对象】。这句话该如何理解捏？简单来说，就是你在 Python 语言中涉及到的各种东东，都是“对象”。比如，函数是对象、各种数值（比如整数值、浮点数值、布尔值）是对象、模块（类似于 Java 的 package）是对象、None（类似于 Java 的空引用 null、C++ 的空指针 NULL）也是对象、甚至连类（class）也是对象......

对比一下 C++ 和 Java 的语法：只有【类的实例】才能算得上是对象。这2个语言的基本类型（比如“int、char、float”等）不是对象，至于函数，就更算不上了。

既然是一切皆对象，俺有必要稍微总结一下，Python 对象的共性，否则初学 Python 的同学还是会一头雾水。

## 对象的属性

首先，所有的 Python 的对象，都具有若干个属性。你可以通过内置的 dir() 函数进行反射，从而了解到某个对象分别都包含哪些属性。熟悉 Java 的同学，应该明白啥是“反射”。光懂 C/C++ 的同学，如果理解上有困难，可以先参考“维基百科的解释”。

另外，Python 还提供了若干内置的函数，用于在【运行时】操作指定对象的属性。具体如下：

```python

hasattr(obj, name)  #判断obj对象是否具有名为name的属性
setattr(obj, name, value)  #设置obj对象的名为name的属性值为value
getattr(obj, name)  #获取obj对象的名为name的属性值
delattr(obj, name)  #删除obj对象的名为name的属性

```

## 对象的类型

所有的 Python 对象，都可以通过内置的 type() 函数获取该对象的类型。这实际上就是 Python 的 RTTI 机制的体现。懂 C++ 的同学，可以回忆一下 C++ 的 typeid 关键字；懂 Java 的同学，可以想一想 Java 的 instanceof 关键字。

## 对象的标示

所有的 Python 对象，都可以通过内置的 id() 函数获取该对象的【唯一】标示。而且当一个对象创建之后，这个唯一标示就会始终保持不变。对于学过 C/C++ 的同学，不妨把这个“唯一标示”想象成该对象在内存的地址。这或许有助于你的理解 :)

Python 对象还有其它一些共性，考虑到本文的扫盲性质，就不再费口水了。有兴趣的同学，可以自己找些入门书研读一番。

## 【一切皆对象】的好处？

可能有同学会问，“一切皆对象”有啥好处捏？俺窃以为：当一切皆为对象，就可以把很多概念、操作、惯用手法统一起来，在语法层面体现出美感。

下面俺举几个例子，并拿 Java 来对比一下。

在 Java 里面，由于基本类型不是继承自 Object 类，引出不少麻烦。当初 Java 它爹刚开始设计容器类（比如 Vector、ArrayList ...）的时候，颇费了一番功夫。因为容器里面放置的东东必须是 Object，为了让容器能适应基本类型，只好给每一种基本类型分别对应一个派生自 Object 的包装类（Integer 类对应 int、Float 类对应 float ...）；后来又平添了自动装箱/拆箱的概念；搞来稿去，产生了 N 多复杂性。

而 Python 就没有这方面的困扰。

再拿刚才提及的“反射”来说事儿。虽然 Java 语言支持对象的反射，但是 Java 的 package 不是 Object，所以也就无法对 package 进行反射。反观 Python，任何一个 module（相当于 Java 的 package）import 之后，都可以直接通过前面提到的 dir() 函数进行反射，得知该 module 包含了哪些东东。仅仅需要2行代码：

```python

import xxx
dir(xxx)

```

# 封装（Encapsulation）<a name="encap"></a>

为了避免歧义，首先要明确一下：什么是“封装”？为了叙述方便，俺把【OOP 的封装】，分为“狭义”和“广义”两种。（关于“封装”的深入讨论，可以参见“另一篇博文”）

## 广义封装

OOP 很强调以数据为中心。所以 OOP 的广义封装，就是把数据和操作数据的行为，打包到一起。比如 C++/Java 里的 class，可以同时包含数据成员和函数成员，就算是满足“广义的封装”了。对于 Python 而言，其 class 关键字类似于 C++ 和 Java，也已经具有“广义的封装性”了。

## 狭义封装

而 OOP 的狭义封装，则更进一步，增加了信息隐藏（Information Hiding）。比如 C++ 和 Java 的“public、protected、private”等关键字，就是通过访问控制来达到信息隐藏的效果。Python 虽然没有针对访问控制的关键字来修饰类成员，但是 Python 采用了另外一套机制——根据命名来约定。在 Python 的对象中，如果某个属性以双下划线开头来命名（比如 __name），就能起到类似于 C++/Java 的 private 关键字的效果。

## 对访问控制的偏见

俺曾经在某技术论坛看到有人质疑 Python 的访问控制机制，说 Python 的私有属性，可以通过反射机制绕过，因此形同虚设。在此，俺想举 C++ 和 Java 来进行反驳。

在 Java 中，同样可以通过反射机制，来访问类的私有成员。至于 C++，得益于指针的强大，只要能访问某个对象（的 this 指针），通过计算该对象成员变量在内存中的偏移，一样可轻易对私有成员变量进行读写。虽然这么干挺变态滴，但技术上是可行滴。

# 继承（Inheritance）<a name="inherit"></a>

紧接着，咱再来说一下继承的话题。

## Python 的继承

Python 没有像 Java 那样，区分出“类继承”（OO 的术语中也叫“实现继承”）和“接口继承”；也没有像 C++ 那样，区分出“公有继承、私有继承、保护继承”这么花哨的玩意儿。Python 就只有一种继承方式。

## 继承的语法

Python 的继承语法，相比 C++/Java 而言，更加简洁。比如子类 Child 需要继承父类 Parent，代码只需如下：

```python

class Child(Parent) :
    # xxxx

```

如果是多继承，代码大同小异：

```python

class Child(Parent1, Parent2, Parent3) :
    # xxxx

```

假如你想知道某个类有哪些父类（基类），只需要通过 Child.__bases__ 便可知晓。

## 继承的动态性

其实上一个帖子已经介绍了动态改变继承关系的例子。但是考虑到上一个帖子年代久远（距本文将近1年），想必很多同学没看过或者看过又忘了。俺不妨再啰嗦一下：作为一种动态语言，Python 可以在【运行时】修改类的继承关系。这个特性比较酷，是 C++/Java 所望尘莫及滴。请看下面的例子：

```python

class Parent1 :
    def dump(self) :
        print("parent1")

class Parent2 :
    def dump(self) :
        print("parent2")

class Child :
    def dump(self) :
        print("child")

print(Child.__bases__)
Child.__bases__ += (Parent1, Parent2)  # 动态追加了2个父类
print(Child.__bases__)  # 此处打印出的父类信息中，已经包含 Parent1、Parent2

```

# 多态（Polymorphism）<a name="poly"></a>

至于 Python 的多态，和传统的 OO 语言差不多，似乎没有太多值得说道的地方。俺简单举个代码作例子。为了省打字，直接复用上述的3个类，并增加一个 test() 函数如下：

```python

def test(obj) :
    obj.dump()

```

然后对 test() 函数分别传入不同的类型的对象，输出结果俺就无需多说了吧？

```python

c = Child()
test(c)  # 打印出 child
p1 = Parent1()
test(p1)  # 打印出 parent1

```

# 结尾<a name="summary"></a>

今天的话题，主要是让不熟悉 Python 的网友，对 Python 在面向对象方面的特性，有一个粗浅、感性的认识。聊完了 OOP，下一个帖子会聊一下关于 FP（函数式编程）的话题。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明** <br>
> 本博客（编程随想的博客）所有的原创文章，原作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址: <br>
> [https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html](https://program-think.blogspot.com/2010/08/why-choose-python-3-oop.html)


.py | 转载：为什么俺推荐 Python[3]·作为面向对象语言的 Python


### 文章目录

* 什么是函数式编程
* FP 的特点
* FP 的优点
* Python 的函数语法
* 和 FP 相关的内置函数
* 消除控制流
* List Comprehension
* 闭包
* 结尾

春节前看到热心读者留言，提醒俺：Python 系列好久没更新了（不知不觉又过了一年多）。俺当时回复说：春节假期补上后一篇。昨天听到鞭炮声才发觉元宵已经到了，赶忙写出本文。

前一个帖子介绍了 Python 作为“面向对象编程”（以下简称 OOP）语言的特点，今天来聊一聊 Python 作为“函数式编程”（以下简称 FP）语言的特点。考虑到本系列面向的是 Python 的门外汉或刚入门的新手，故本文仅介绍若干浅显的 FP 特性。

# 什么是函数式编程

说实话，“函数式编程语言”是一个很大的话题。由于篇幅有限，本文不可能对这个话题做全面介绍。俺干脆偷一下懒，只简单说说。

从字面上看，所谓的函数式编程，就是以“函数”为中心的“编程范式”。估计有同学又会问了，啥是“编程范式”捏？哎呦，这又是一个很大的话题。通俗来讲，“编程范式”就是指编程的套路。比方说大家很熟悉的 OOP，就是一种“编程范式”。FP 跟 OOP 一样，都是一种编程的套路。做个简单类比：OOP 以“对象/类”作为程序设计的核心，而 FP 以“函数”作为程序设计的核心。

# FP的特点

既然说到 FP，自然要稍微说一下 FP 的特色。

## 函数很牛X

刚才说了，FP 是以函数为中心。既然如此，在支持 FP 的语言中，函数的功能自然十分牛X。通俗地说，OOP 语言中，类/对象能干的事情，FP 语言中的函数也能干。下面做一些对比，以加深大伙儿的印象。

OOP 中，对象可以互相赋值；FP 中，函数可以互相赋值。

OOP 中，对象可以作为函数的参数/返回值，FP 中，函数可以作为函数的参数/返回值。

某些 OOP 中，类可以嵌套定义；FP 中，函数可以嵌套定义。

某些 OOP 中，可以有匿名类；FP 中，可以有匿名函数。

## 避免副作用

在 FP 中，特别强调函数不要有“副作用”（洋文叫“side effect”）。没有副作用的函数，又称之为纯函数（pure function）。其输出完全依赖于输入。换句话说，只要输入一样，输出就一样。

要成为纯函数，函数内部不能读写函数外部变量、不能有设备 I/O（比如读写文件）......

无副作用是 FP 的重要特性。FP的很多优点来自于此特性。

## 避免控制流

在 FP 中，尽量避免用控制流语句（循环语句、判断语句）。对于控制流语句，FP 有另外的替代方式。比如：常用递归或高阶函数来替代循环。如此一来，FP 的代码会显得更简洁，更可读。

## 多态

大部分支持 FP 的语言，也都支持多态。函数参数支持多态化，便可实现非常灵活的功能。

说了这么多，不知道大伙儿明白了没？还是没整明白的同学，请看维基百科的英文词条（中文词条太简单，看不明白滴）。

洋文实在看不下去吗？那不妨看看 IT 大牛 Joel 写的《你的编程语言能这样做吗？》（中文版在“这里”）。此文以 JavaScript 来阐述 FP 的妙处。

# FP 的优点

再稍微说一下 FP 的好处，以强化大伙儿学习的动力。

## 模块化

在 FP 的思想中，函数最好是“纯”的，而且最好只完成“单一”的任务。在这种指导思想下，函数的模块化程度自然就高。

## 可复用性

模块化程度高，直接的好处就是可复用性好。

## 可读性

刚才说了，FP 的思想强调函数又纯又小。这样的函数，代码的可读性自然好，修改起来也方便。

## 易于调试

前面提到了纯函数。如果你的程序中大部分函数都是纯函数，则调试 Bug 会容易很多。像 OOP 中，类的多个成员函数都可以修改类的成员变量，有时候会导致调试极其困难。而纯函数没有此问题。

另外，多线程是调试的一大噩梦。当年俺还专门写过帖子，介绍 C++ 多线程的注意事项（在“这里”）。而纯函数由于没有副作用，不必担心各种“互斥”、“死锁”等问题。

## 易于测试

除了易于调试，纯函数的输出仅仅依赖于输入，这一特点注定了它很容易进行单元测试。

## 适合并行

在 FP 中，由于纯函数无副作用，很适合编写并行处理的代码。最典型并且在工业界获得巨大成功的例子就是 Erlang。

## 其它

当然啦，FP 的好处远不止上述这些（比如还有：利于形式化证明）。限于篇幅，俺就不展开了。

# Python 的函数语法

Python 中，常见的函数定义和函数调用，想必各位都晓得了。下面说几种不太常见的，且跟 FP 有关的语法。

## 函数赋值

Python 可以把函数直接赋值给一个变量。举例如下：

```python

def square(n) :  # 这是一个计算平方的小函数，后面会反复用它举例
    return n ** 2

f = square  # 此处赋值给变量 f
f(10)  # 此处返回100。注意：对该变量使用小括号，等同于调用函数

```

## 匿名定义

Python 可以用 lambda 关键字定义【单行】的匿名函数。套用刚才的例子

```python

square = lambda x : x**2  # 定义一个单参数的匿名函数，并把该函数赋值给变量
square(10)  # 此处返回 100

```

## 嵌套定义

Python 支持函数的嵌套定义（请看如下例子）。这种语法，在“闭包”中经常出现（后面会具体介绍“闭包”）。

```python

def outer() :  # 外层函数
    s = "hello"
    def inner() :  # 内层函数
        print(s)  # 此处引用的是外层作用域的变量

    inner()  # 输出 hello
    s = "world"
    inner()  # 输出 world

```

# 和 FP 相关的内置函数

Python 内置了一大坨用于 FP 的函数，以方便程序猿写出简洁的代码。在接下去聊之前，俺有必要先介绍其中的2个。

## map(func, iter)

为了省事，俺只介绍2参数的 map（正宗的 map 支持 N 参数）。

参数 func 是个函数，参数 iter 是个迭代器（也可以理解为集合）

map() 会把 iter 的每个元素传给 func，并把每次调用的结果保存到一个 list 中，然后返回此 list。

举例：

挨个计算整数 list 的平方：

```python

map(square, [1, 2, 3])  # 返回 [1, 4, 9]

```

## filter(func, iter)

参数含义同 map

filter() 会把 iter 的每个元素传给 func，如果 func 返回结果为 True，就把元素保存在一个 list 中，最后返回此 list。

举例：

要过滤出所有奇数，代码如下：

```python

def odd(n) :
    return (n%2) == 1

filter(odd, [1, 2, 3])  # 返回[1, 3]

```

此处可以用上 lambda，把代码简化为一行：

```python
filter(lambda n: (n%2)==1, lst)
```

# 消除控制流

为了让大伙儿更深刻体会 FP 风格同传统风格的差别，俺把刚才两个例子组合一下——要求返回整数list 中所有奇数的平方。

传统的写法（有控制流）：

```python

def func1(old_lst) :
    new_lst = []
    for n in old_lst :
        if odd(n) :
            new_lst.append(square(n))
    return new_lst

```

FP 的写法（无控制流）：

```python

def func2(lst) :
    return map(square, filter(odd, lst))

```

怎么样？是不是更简洁？连 for / if 这两个关键字都不需要了。

# List Comprehension

这个洋文比较难翻译。有人叫做“列表推导”，也有人称为“列表展开”或“列表解析”。（俺比较喜欢头一个翻译——不禁让人联想到“推倒”:）

在 Python 中，这是一个很好吃的语法糖——可以让你写出很简洁、很优雅的代码。

举例1：

还拿刚才过滤奇数的例子。

```python

filter(lambda n: (n%2)==1, lst)

```

上述写法可以等价替换为列表推导：

```python

[n for n in lst if (n%2)==1]

```

举例2：
　　
再来一个稍微复杂的例子。假设有两个整数 list，分别存储矩形的宽度和高度。现在想把所有的宽度和高度进行两两组合，把大于 10 的面积打印出来。
　　
传统的写法（2层循环，4行代码）

```python

for w in width :
    for h in height :
        if w*h > 10 :
            print(w*h)

```

FP 的写法（无循环，1行代码，多精致啊）

```python

print( [w*h for w in width for h in height if w*h > 10] )

```

除了列表推导，Python 中还有字典推导、集合推导等等。为了省点口水，暂且打住。

# 闭包

闭包，洋文叫“closure”，解释在“这里”。它是 FP 的常见手法。那闭包到底有啥用捏？俺举一个微积分中，函数求导的例子。（不懂微积分或者对高数有心理阴影的同学，别担心，请把注意力集中在代码上）

```python

def d(f) :
    def calc(x) :
        dx = 0.000001  # 表示无穷小的Δx
        return (f(x+dx) - f(x)) / dx  # 计算斜率。注意，此处引用了外层作用域的变量 f
    return calc  # 此处用函数作为返回值（也就是函数 f 的导数）

```

现在，假设要计算二次函数 f(x) = x2 + x + 1 的导数，只需如下代码：

```python

f = lambda x : x**2 + x + 1  # 先把二次函数用代码表达出来
f1 = d(f)  # 这个f1 就是 f 的一阶导数啦。注意，导数依然是个函数

```

有了一阶导数，就可以很容易地计算该函数在某点的斜率

比如要计算 x=3 的斜率，只需：

```python

f1(3)

```

如果要想得到二阶导数（导数的导数），只需依样画葫芦（瞧这代码写得多优雅）

```python

f2 = d(f1)

```

看到这里，大伙儿不妨设想一下：如果不用 FP，改用 OOP，上述需求该如何实现？俺觉得吧，用 OOP 来求导，这代码写起来多半是又丑又臭。

# 结尾

今天聊了不少 FP 的语法特性，可惜还是没聊完。由于俺比较懒，而且怕写得太长没人看，所以一些高级话题（比如：迭代器、生成器、等），今天就不介绍了。假如列位看官对那些玩意儿感兴趣，再抽空单独写一帖。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明**<br>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：<br>
> <a href="https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html">https://program-think.blogspot.com/2012/02/why-choose-python-4-fp.html</a>


.py | 转载：为什么俺推荐 Python[4]·作为函数式编程语言的 Python


> **文章目录**
>
> * 短小精悍
> * 功能强大之1——跟非常多的语言整合
> * 功能强大之2——既可以跨平台，又可以跟操作系统深度整合
> * 功能强大之3——具有很丰富的第三方模块


本系列几乎变成年度系列了——上一篇帖子是去年元宵节发的。这几天正值春节假期，赶紧抽空补上本系列新的一篇，免得大伙儿以为本系列“烂尾”了。

“瑞士军刀”，大伙儿应该很熟悉，俺就不解释了。拿“瑞士军刀”来比喻 Python 就是想说明：Python 不但短小精悍，而且功能强大。今天就来介绍一下 Python 的这两个特点（尤其是后者）。

# 短小精悍

## 轻量级的的代码

要吹嘘 Python 的轻量级，首先要吹嘘的，自然是它简洁的代码。为了让大伙儿有个初步的印象，举几个例子。

举例1

要得到100-200之间所有奇数的3次方，只需如下一行

```python

[x**3 for x in range(100, 200) if (x%2)==1]

```

举例2

如果要把上述结果拼成一个逗号分隔的字符串，还是只要一行

```python

','.join([str(x**3) for x in range(100, 200) if (x%2)==1])

```

举例3

可能有人觉得上面2个例子是小儿科，再来举一个稍微复杂点的。只需一行代码，即可实现网络扫描（用的是第三方的 Scapy 工具）。

```python

# 传统的 ping 扫描，基于 ICMP 协议
ans,unans = sr(IP(dst="192.168.1.1-254")/ICMP())
# 局域网扫描，基于 ARP 协议
ans,unans = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst="192.168.1.0/24"), timeout=2)

```

## 轻量级的安装环境

比如 Python 的安装包只有十几兆，而 Java 的 JDK 安装包动辄接近100兆。

## 轻量级的运行环境

同样是运行一个“Hello World”，用 Python 写的进程，占用的内存会更小（相比大多数其它编程语言）。而且 Python 的运行环境（Python 虚拟机）可以很方便地嵌入到 C/C++ 程序中，只需额外带一个动态库即可。

# 功能强大之1——跟非常多的语言整合

很多程序员喜欢“在一棵树上吊死”——始终只用一种编程语言。俺非常反对这种倾向。要想成为一个优秀的程序员，有必要掌握【不同风格/不同范式】的编程语言。编程语言多样化的好处在于，你可以利用不同语言的特色，以取长补短。

而 Python 在跨语言整合方面，堪称佼佼者——你很难找到哪个语言，能像 Python 这样，跟如此多的语言进行整合。

下面简单举几个例子：

## 跟 C/C++ 整合

咱们常用的 Python 运行环境也称为 CPython，是用 C 语言写的。所以 Python 天生就具有跟 C/C++ 整合的能力。而且这种整合是双向的——也就是说，既可以在 Python 模块调用 C/C++ 模块，也可以在 C/C++ 模块调用 Python 模块。

Python 跟 C/C++ 整合，可以有如下三个优点：

1. 丰富的第三方资源

因为 C/C++ 具有非常丰富的第三方模块（包括开源和闭源），其丰富程度超过 Java。所以 Python 可以利用这种整合能力，直接调用各种 C/C++ 的模块，来丰富自己的功能。

举个例子

比如 cURL 是一个C语言编写的应用层网络工具，功能非常强。而 Python 可以通过整合 cURL 直接获得 cURL 的强大功能。

2. 性能的提升

除了第三方模块丰富，C/C++ 开发的模块还有一个优点——性能好。所以，Python 整合了 C/C++ 模块之后，还能趁机获得性能提升。

举个例子

比方说你要写一个 3D 游戏，其中的 3D 渲染引擎是性能瓶颈。那么你可以用 Python 整合一个 C/C++ 的 3D 渲染引擎。而 Python 只用来实现跟游戏高层应用逻辑相关的部分。这样可以一举两得：性能不差，代码不多。

顺便说一下：如今有不少游戏都走这个开发思路——底层引擎用【重型的】C 或 C++ 实现，以确保高性能；而高层的业务逻辑则用【轻型的】脚本语言来开发。

3. 跟操作系统整合

地球上的操作系统，只要是有点名气的，内核都是 C 语言写的；除了操作系统内核，大部分操作系统的运行库也都是 C/C++ 编写的。所以，Python 跟 C/C++ 整合，可以带来第三个好处——跟操作系统的整合。关于这点，待会儿俺还会专门聊。

## 跟 JVM（Java） 整合

通过 Jython 这个开源项目，Python 可以无缝整合到 JVM 环境中。如此一来，Python 能直接调用所有 JVM 标准库（比如 JDBC）和第三方库（比如 Lucene），还可以跟各种 JVM 语言（比如“Java、Scale、Groovy”等）进行互操作。

## 跟 dotNet 整合

通过 IronPython 这个开源项目，Python 可以无缝整合到 dotNet 环境中。如此一来，Python 能直接调用所有 dotNet 的标准库（比如 ADO.NET）和第三方库，还可以跟各种 dotNet 语言（比如“C#、F#”等）进行互操作。

顺便说一下：Jython 跟 IronPython 貌似同一个作者，牛人啊！

# 功能强大之2——既可以跨平台，又可以跟操作系统深度整合

## Python 语言如何体现“跨平台性”？

说到跨平台这个话题，俺给编程语言分一下类：

1. 可以跨平台，但无法跟操作系统深度耦合（比如 JavaScript、PHP）

2. 可以跟操作系统深度耦合，但无法跨平台（比如 VB、VBScript）

3. 既可以跨平台，又可以跟操作系统深度耦合（比如 C C++ Python）

为啥第三类语言能做到两者兼得？因为这类语言把选择权留给了程序猿——

一方面，如果程序猿遵循跨平台的开发规范，那么写出来的代码就是跨平台的；

另一方面，程序猿也可以写出跟系统耦合很紧密的代码——这样的代码虽然不能跨平台，但可以发挥特定平台的强项。

显然俺喜欢第三类编程语言，因为这类语言给了程序猿自由。

## Python 语言如何“与操作系统深度整合”？

Python 的跨平台特性，懂 Python 的同学估计都晓得了。所以俺单独说一下 Python 如何跟操作系统深度整合。为了照顾到大多数人，俺拿 Windows 来说事儿。

在 Python 社区有一个很有名气的库，叫做 PyWin32。通过这个库，可以让 Python 代码很容易地调用 Windows 的 API 以及 COM 组件。

比方说，可以用 Python 代码直接操作 Windows 注册表

比方说，可以用 Python 代码直接读写 Windows 的系统日志

比方说，可以用 Python 代码直接操作某个窗口句柄

比方说，可以利用 COM 组件，直接调用 Word 来处理 doc 格式的文档

......

# 功能强大之3——具有很丰富的第三方模块

最后一个方面，也是最重要的一个方面，就是 Python 社区具有非常非常丰富的资源（第三方库），而且几乎都是开源的。形形色色的编程领域几乎都可以看到 Python 的身影。

为了让众多程序员读者领略 Python 的丰富资源，俺特地整理了一个 wiki 页面（请用鼠标猛击“这里”），放上 Python 在各个编程领域的常用模块。为了显示出 Python 代码的简洁，某些模块还放上示例代码。

最后感叹一下：

写这篇博文只花了不到一小时，而整理这个 wiki 页面累计超过10个小时。不过这时间没白花——整理的时候顺便对某些领域有了更多的了解。这也就是写博客的好处，既可以帮助别人，又可以帮助自己。

大伙儿如果觉得俺整理的清单有遗漏，欢迎到本页面留言补充。

[回到本系列的目录](RP-why-choose-python-0-overview)

> **版权声明**
>
> 本博客（编程随想的博客）所有的原创文章，作者皆保留版权。转载必须包含本声明，保持本文完整，并以超链接形式注明作者编程随想和本文原始地址：<br>
>
> <a href="https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html">https://program-think.blogspot.com/2013/02/why-choose-python-5-tools.html</a>

.py | 转载：为什么俺推荐 Python[5]·作为瑞士军刀的 Python


2024 年 9 月 30 日起，本站网址
- 从 `https://mountaye.github.io/blog/` 
- 变更为 `https://blog.mountaye.com`.

因为网站仍然架设在 GitHub Pages 上，所以旧网址可以自动跳转到新网址。

但是下一步计划把网站迁移到 Cloudflare Pages 上，因为 Next.js 项目不同构建之间文件差异过多，不适合作为 git 仓库的内容进行托管。

所以无法保证将来旧网址依然可以自动跳转。请使用浏览器收藏功能的读者更新收藏夹，使用 RSS 订阅功能的读者更新 RSS 源。

根据初步计划，过渡期将持续到 2024 年 12 月 31 日。


通知：本站网址変更


## 技术选型

### 不再选择静态网站生成工具

我的博客本来是用 Jekyll 生成的静态网站，因为网站架在 GitHub Pages 上，而 Jekyll 是 GitHub Pages 默认的构建工具。但是 Jekyll 的核心开发者年事已高，有的甚至已经去世，所以我感觉这个项目未来的活力堪忧。

Jekyll 是用 Ruby on Rails 写成的，其他编程语言，和 Jekyll 功能类似的工具有：

- Python 的 Pelican
- JavaScript 的 Hexo

但是我还想做些更复杂的事情，预计需要靠服务端来实现。所以与其花时间移植到一个和 Jekyll 功能类似的工具，不如直接一步到位，学习一个全栈框架。

### Next.js

虽然不同的编程语言也都有自己的全栈框架，比如 Python 有 Django，但是既然浏览器主要支持 JavaScript，所以索性前后端都用 JS 比较方便，而且这样想的人很多，社区规模使得遇到问题更容易找到答案（这个优势在生成式语言模型的时代似乎没那么重要了）。

JavaScript 语言之下，也存在至少 React 和 Vue 两大阵营。之所以选择 Next.js 这样一个基于 React.js 的框架，主要是路径依赖，很久很久以前学过[赫尔辛基大学的全栈公开课](https://fullstackopen.com/zh/)，那里教的就是 React。

对于 Next.js 本身，Youtube@Fireship 有一个很简洁的介绍：[https://www.youtube.com/watch?v=Sklc_fQBmcs](https://www.youtube.com/watch?v=Sklc_fQBmcs)

官网提供的教程在这里：[https://nextjs.org/learn](https://nextjs.org/learn)，和我学习的时候已经不一样了，那时候只有 page router，没有 app router。开发这一框架的 Vercel 公司也提供 Next.js 的云服务。但是鉴于其有过把用户引诱到 app router 架构然后给自家服务提价的黑历史，所以短期内不打算学和用 app router.

### TailwindCSS

[https://tailwindcss.com/](https://tailwindcss.com/)

早就学过了，但是一直没有机会用。这次本来也可以不用的，直到决定使用 Shadcn.ui 组件库，因为 TailwindCSS 是它的一个依赖项。既然已经安装了，那不用白不用。

### Shadcn.UI 而非 HeadlessUI

https://ui.shadcn.com/

一套组件库，也就是网页中经常出现的功能单元。这个库相对于竞品的最大优势，是允许直接复制粘贴代码而不用安装，用多少抄多少～

TailwindCSS 自家也有一个组件库 [HeadlessUI](https://headlessui.com/)，但是主要是 `<form/>` 表单及其成员，侧重于向后端传数据的 HTML 元素的封装。而 Shacn 有很多炫酷的交互方面的组件，突出一个现成且好看。

### 没用 Figma

有用的功能都收钱，免费的功能不如直接 `next dev` 实时预览。

## ~~踩过的坑~~ 学到的经验

### 组件化作为一种思路

正常的网页，HTML 负责内容，CSS 负责装饰，JavaScript 负责交互。这种分工，专业上叫做解耦。

工程实践表明，这种解耦方式非常反人类。用户看到和使用的网页，是以功能上的相似、空间上的相邻为组织的，而要对其修改时，则需要到不同源代码的不同位置去；反之，某处代码的改动，无意中可能对远处的另一部分视觉效果和功能造成破坏。

于是较新的全栈框架，其解耦的方式都是以组件为单位的，内容、样式、交互逻辑都写在一起。

### JavaScript/JSX 语法中的 `{}`

JSX 是对 JavaScript 语法的扩展，添加了类似于 HTML 标记的写法 `<MyComponent></MyComponent>`，用来表示 react 组件。

在 jsx 语言的内部写 Javascript 时，需要将 JS 外面包裹一层 `{}`

JavaScript 里类似 Python f-string 的结构写作``${}``，名叫 template literal: ``this is var: ${var}``

——以上规则结合起来，会产生让初学者迷惑的现象：

- `<MyComponent className=’dark’/>`: 一个正常的类名，直接用引号
- `<MyComponent className={dark}/>:` 类名是一个 JS 字符串变量
- 类名的一部分根据一个变量取值:
  ```javascript
  <MyComponent className={`bg-${dark}`}/>
  ```

### JavaScript 箭头函数中的 `{}` 和 `()`

JavaScript 的箭头函数类似于 python 的 lambda 纯函数，但是有不同。

`(var) => (expression(var))` 相当于 Python 中的 `lambda x: expression(x)` 

但是箭头函数的右侧可以是 `{}` 包裹的若干表达式，此时需要显式 return：

```jsx
(var) => {
    expression1(var);
    expression2(var);
    return expression3(var);
}
```

Python 的 lambda 必须是单一表达式的纯函数，不允许上面第二种写法。

### 对象解包中的 `{}`

当有一个包含若干键值对的对象时

```jsx
obj = {
		k1: "value1",
		k2: "value2",
		k3: "value3",
		...
}
```

可以用 `const { k2 } = obj;` 的方式拿到 `obj[’k2’]` 的值，赋给 `k2`。

结合上一节，

- `(k1,k2)=>(k1+k2);` 是一个两个自变量的函数；
- `({k1,k2})=>(k1+k2);` 是以一个 Object 为自变量的函数，这个 Object 的名字无所谓，也不确定一共有多少个属性，但属性中至少包含 `k1` 和 `k2`.

### TailwindCSS 的 arbitrary value、JavaScript 的模板字符串、Shadcn 中的 `cn()` 函数

TailwindCSS 的很多属性都允许在方括号中使用任意值，比如背景色 `bg-[#a4b4c4]`

本以为可以直接在 `className` 里面用 template literal `<div className={`bg-[${myColor}]`}>`，但是并不总是生效。

这个“并不总是”是个大坑，一开始在开发模式用得好好的，结果某次刷新页面之后就挂了，简直莫名其妙。

好在 Shadcn 提供了一个 [`cn()` 函数](https://github.com/shadcn-ui/ui/blob/main/apps/www/lib/utils.ts)，接受一个或多个 TailwindCSS 类名字符串作为输入，就可以正常使用 template literal 了，例如 `<div className={cn("block","border-0",`bg-[${myColor}]`)}></div>`

### HTML + CSS 布局

两类套路：

1. 传统的 `display`, `position`, `float` 属性；
2. Flex 和 Grid 布局，看阮一峰先生的博客里的教程就挺方便：[Flex](https://www.ruanyifeng.com/blog/2015/07/flex-grammar.html), [Grid](https://www.ruanyifeng.com/blog/2019/03/grid-layout-tutorial.html).

理论上后者新一些，消耗的脑力也更少一些，应该是更好的选择。

但是前者也有一些优势场景。比如现在整个博客页面的上边栏和剩下的部分就是一个上下结构的 flex 布局，这导致屏幕最右侧的滚动条其实是页面一部分的，而不是整个页面的的滚动条。在 iOS 的 Safari 浏览器下，会导致网址栏不能自动隐藏，浪费很大一片屏幕空间。之后可能会换回传统功夫。

而像是目录，文章跳转开头和评论区的按钮等等，需要在页面滚动时相对屏幕静止的元素，就不得不用 position，而且为了锚定在正文上，还需要嵌套好几层。

按照传统功夫——

- `display`可选的取值有 4 个: block | inline | inline-block | none
    - block: 竖排，哪怕同一行内仍有空间容纳 html 中的下一个元素。
    - inline: 横排，像文字内容一样，没有盒模型
    - inline-block: 横排，但是有盒模型
    - none: 不显示，和 `visibility:hidden` 的区别是，后者依然占有显示时的空间。
- `position`可选的取值有 5 个: static | relative | fixed | absolute | sticky
    - static: 默认值，按照 html 文件的顺序排列。
    - relative: 相对于 static 默认值进行偏移，偏移量由 `top`, `right`, `bottom`, `left` 四个性质决定。所谓 `left: 50px` 的意思是左侧 margin 外多出 50 像素的空间，实际是向右偏移的效果。
    - fixed: 相对于**视窗**的位置固定，位置由 `top`, `right`, `bottom`, `left` 四个性质决定。`left: 50px` 的意思是该元素的左侧 border **外沿**距离窗口左边 50 像素。
    - absolute: 相对于最近一层父元素的位置固定，位置由 `top`, `right`, `bottom`, `left` 四个性质决定。`left: 50px` 的意思是该元素的左侧 border **外沿**距离父元素左侧**内沿** 50 像素。设计的时候需要考虑 border 宽度。
    - sticky: 网页加载时按照 html 文件的顺序排列，直到网页滑动到某一位置，之后该元素固定在视窗，就像 fixed 一样，行为改变的位置由 `top`, `right`, `bottom`, `left` 四个性质决定。
- `float`:  none | left | right | inherit
    - none: 默认值，按照 html 文件的顺序排列。
    - left: 保持在父元素左侧，其他元素环绕之。
    - right: 保持在父元素右侧，其他元素环绕之。
    - inherit: 和父元素的 float 的取值一致。

### Unified.js 将 Markdown 文档转换为基于 JSX 的 HTML

Jekyll 等静态网站生成器的核心功能，就是把 markdown 文档翻译成 html 网页文档。在 Next.js 框架下，这一工作由以 unified.js 为基础的一群第三方库来完成。

最早看到这个框架是在 DIYGOD 的博文《[如何优雅编译一个 Markdown 文档](https://diygod.cc/unified-markdown)》里，但是直接抄他在 xlog 里面的代码的话，在 next.js 之下好像会报错。所以又去官网仔细读了一下文档，现在可以说是略懂。

这个话题本身值得专门写一篇文章，所以不在这里展开了。

### Giscus 评论区切换黑夜模式

自己写的组件的亮暗切换，是通过在 `<html/>` 元素添加和删除 `dark` 类，然后搭配 TailwindCSS 的 `dark:` 来实现的。

Giscus 官方支持切换黑夜模式：[https://github.com/giscus/giscus/blob/main/ADVANCED-USAGE.md#parent-to-giscus-message-events](https://github.com/giscus/giscus/blob/main/ADVANCED-USAGE.md#parent-to-giscus-message-events)。这套方法的关键，在于服务端返回的 iframe 有一个名为 `giscus-frame` ****的类。

Giscus 为 react 提供了一套组件可以直接使用，但是在这套组件里面并没有这个类。

所以只能弃用官方的组件，自己用 `useEffect` 模拟官网的 `<script/>`

```jsx
export function MyGiscus() {
  useEffect(
    () => {
      const onPageLoad = () => {
        console.log("<MyGiscus/>: activated on page load.")
        // START real business
        const script = document.createElement('script');
        script.src = "https://giscus.app/client.js";
        script.setAttribute('data-repo',              '');
        script.setAttribute('data-repo-id',           '');
        script.setAttribute('data-category',          '');
        script.setAttribute('data-category-id',       '');
        script.setAttribute('data-mapping',           '');
        script.setAttribute('data-strict',            '');
        script.setAttribute('data-reactions-enabled', '');
        script.setAttribute('data-emit-metadata',     '');
        script.setAttribute('data-input-position',    '');
        script.setAttribute('data-theme',             '');
        script.setAttribute('data-lang',              '');
        script.crossOrigin = 'anonymous';
        script.async = true;
        document.getElementById("comments").appendChild(script);
        // END real business
      };
      // Check if the page is already loaded
      if (document.readyState==='complete') {
        onPageLoad();
      } else {
        // Add event listener for page load
        window.addEventListener('load',onPageLoad);
        // Cleanup the event listener on component unmount
        return () => { window.removeEventListener('load',onPageLoad); }
      };
    },
    []
  );
  return (<div id='comments'></div>);
}
```

### Next.js 的构建参数部分

要让 next.js 构建静态网站，需要在 next.config.js 中写：

```jsx
module.exports = {
  basePath: '/blog',
  output: 'export',
  generateBuildId: async () => "buildID",
  // i18n: {
  //   locales: ['zh-CN', 'en'],
  //   defaultLocale: 'zh-CN',
  //   localeDetection: false,
  // },
}
```

`basePath` 是因为博客的 GitHub 仓库 blog 不是默认的个人网站仓库；需要注意的是，next.js 自己的 Link 组件的 `href` 参数不需要包含这个值，但是图片等等的 `src` 参数需要。

`generateBuildId` 函数的返回值是随便写的，不设定的话会导致输出里的 `_next/` 文件夹里有很多哈希值为名的文件夹，在 git 下会被当成不同的 blob 一直留在项目里。

`i18n` 参数被注释掉了，因为静态生成的 next.js 项目不支持自动 i18n.

### RSS 源和 sitemap

RSS 由 feed 这个 npm 包来构建；

sitemap 则是在 ChatGPT 的帮助下手写字符串。

写好的字符串，通过在主页或者历史归档页面的 `getStaticProps()` 函数，写入 next.js 项目的 `public/` 文件夹。

## 还没解决的问题

### 手机端搜索框的汉字输入问题

页面顶端的搜索框在手机触摸屏上，用汉字输入法输入关键词之后，直接按回车键，会导致已经输入的汉字被当成拼音，传递给搜索引擎。

暂时的办法是在输入汉字之后，按回车键之前按一下空格。

### Shadcn.Drawer 组件的上游代码报错；Google Ads

新博客把谷歌广告撤了。赚不到多少钱不说，它还会往网页里动态添加元素，破坏原来的排版。

话虽如此，每篇文章的右下角还是有个[要饭的图标](https://lucide.dev/icons/hand-heart)，计划用 shadcn 的 Drawer，放赞赏二维码，或者交换来的友站链接。

但是目前 Drawer 的上游代码会报错，看起来作者已经在修复了，等更新。

### Google Analytics

next.js 提供了 Google analytics: [https://nextjs.org/docs/pages/building-your-application/optimizing/third-party-libraries](https://nextjs.org/docs/pages/building-your-application/optimizing/third-party-libraries)

但是加入之后没有反应，google 后台看不到，数据一落千丈。

据说把相应的代码放到 `pages/_app.js` 可以解决问题，还没试。

.js | 博客改用 Next.js + TailwindCSS + Shadcn.UI


> 一直听说“全栈项目 = Next.js + TailwindCSS + HeadlessUI”
但是 TailwindCSS 到底是啥，之前一直妹整明白
> 

## 思路：utility-first

> [https://tailwindcss.com/docs/utility-first](https://tailwindcss.com/docs/utility-first)
> 

传统设计需要根据 html 中的结构，在 CSS 中给相应的元素/class/id 定义所需要的所有样式 style。

问题很明显：

- 最低效的情况下，每个 `<div/>` 都要定义一个 class。
- 每个定义里包含若干不同的性质，背景颜色、字体、边框样式等等都挤在一个大括号里，耦合过强。

TailwindCSS 的思路名叫 utility-first, 预先定义一批“性质-取值”的组合，每个组合给出一个有规律命名的类。使用时，一个 `<div/>` 后面声明几个甚至几十个不同的 class。缺点就是不灵活了，每个性质只搭配有限几种取值，且类的数量很多。好处是——

- 不用绞尽脑汁给类取名字
- CSS 不会再变大了（也可以说已经大得不能再大了）
- 修改视觉效果时更换一个类，而不是修改类的定义，也就不用担心对类的修改在自己不记得的地方生效。

与之相对的另一种思路，是直接用 html 元素的 style 属性，或者用 module.css 让样式只对某一 component 生效。TailwindCSS 派对这种方法的批评是：

- 每个取值都是设计者拍脑袋想出来的，一个项目要拍太多次脑袋，容易风格不统一。
- 难以做 responsive design （真的吗？很怀疑）
- 难以处理鼠标悬浮、聚焦等等状态（这玩意应该由 CSS 处理吗？）

utility-first 在维护性方面收到批评的一点是，很多地方要不断重用相同的组合，少了一点封装和抽象。TailwindCSS 对此的辩护是，可以抽象出 components 和 partials（见下节），或者使用编辑器的多光标功能。（绷……）

## 技术细节

- 样式重用
- 状态，比如鼠标悬浮、聚焦
- Responsive design
- 夜间模式
- 添加自定义样式
- 函数和 directives

### 状态，比如鼠标悬浮、聚焦

在正常的类名字之前添加 `<状态>:` 标记，用来指明在相应状态时的样式。这些状态可以叠加，之间用 `:` 分隔。比如 `<button class="hover:bg-sky-700">`

可以标记的状态：[https://tailwindcss.com/docs/hover-focus-and-other-states#appendix](https://tailwindcss.com/docs/hover-focus-and-other-states#appendix)

- Pseudo-classes
    - 举例： [https://tailwindcss.com/docs/hover-focus-and-other-states#pseudo-class-reference](https://tailwindcss.com/docs/hover-focus-and-other-states#pseudo-class-reference)
        - `hover:`, `focus:`, `active:`
        - `first:`, `last:`, `odd:`, `even:`
        - `required:`, `invalid:`, `disabled:`: 主要用在 `<form>` 中
    - 需要父元素的状态信息时，
        - 如果因为嵌套，存在多个 group 时，可以给每一个父元素的类命名 `group/<name>`, 子元素的类名需要写在伪类的后面，有点反直觉 `group-hover/<name>:`
        - 给父元素添加 `group` 的 class，然后给需要变化的子元素添加 `group-<pseudo-class>:` 前缀。如 `group-hover:`
        - 当需要更细致的选择时，可以在子元素的 group 后面添加自定义内容，如 `group-[.is-published]:`, `group-[:nth-of-type(3)_&]:`
    - 需要姊妹元素的状态信息时：
        - 给被跟踪的姊妹元素添加 `peer` class, 被跟踪的元素只能在跟踪元素的前面。
        - 其余特性类比 group
- [Pseudo-elements](https://tailwindcss.com/docs/hover-focus-and-other-states#pseudo-elements), like `::before`, `::after`, `::placeholder`, and `::selection`
    - 写作 `before:` 等等，默认相当于 `before:content-['*']`
    - 当想要调整 content 以外的性质时，需要指明 `before:block`, `before:absolute`, `before:-inset-1` 等等
    - `placeholder:` 用于调整表格中代填内容的样式
    - `file:` 上传文件按钮的样式
    - `list:` 列表开头的
    - `selection:` （鼠标）选中文字之后的样式
    - `first-line:`, `first-letter:` 杂志常用的首行、首字母的特殊样式
- [Media and feature queries](https://tailwindcss.com/docs/hover-focus-and-other-states#media-and-feature-queries), like responsive breakpoints, dark mode, and `prefers-reduced-motion`
    - 结合响应式设计 responsive design 一节，使用 `md:`, `lg:` 等前缀
    - `dark:` 黑夜模式
    - `motion-reduce:` 用户选择屏蔽动画效果时的样式，`motion-safe:` 只有不屏蔽动画才会生效的样式
    - `portrait`,`landscape` 屏幕朝向
    - `print:` 打印时的样式
    - `supports-[...]` 当浏览器支持某种特性时启动。也可在 `tailwind.config.js` 文件中设置 `theme.supports` 变量
- [Attribute selectors](https://tailwindcss.com/docs/hover-focus-and-other-states#attribute-selectors), like `[dir="rtl"]` and `[open]`
    - `aria-*` modifier to conditionally style things based on [ARIA attributes](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes).
    - `data-[key=value]` data 参数的值
    - `ltr:` & `rtl:` 从右往左书写的文字
    - `open:` & `close:` 用于可以展开的元素
    - 自定义选择符：用中括号包围，`&` 开头选择元素，下划线表示空格，如 `[&:nth-child(3)]:`, `[&_p]:mt-4`, `[@supports(display:grid)]:grid`

### Responsive design

| Breakpoint prefix | Minimum width | CSS |
| --- | --- | --- |
| sm | 640px | @media (min-width: 640px) { ... } |
| md | 768px | @media (min-width: 768px) { ... } |
| lg | 1024px | @media (min-width: 1024px) { ... } |
| xl | 1280px | @media (min-width: 1280px) { ... } |
| 2xl | 1536px | @media (min-width: 1536px) { ... } |

移动端优先的思路，所有尺寸限定的都是大于该宽度时的样式。

要限定上限，要用 `max-<size>:` 比如 `md:max-xl:flex`

要想自定义 breakpoints，可以看 [customizing breakpoints documentation](https://tailwindcss.com/docs/breakpoints).

也可以单独设定 `min-[320px]:`, `max-[600px]:` 等等

### 夜间模式

默认使用操作系统的设定。

要想手动设定，须在 tailwind.config.js 中加入

```jsx
/** @type {import('tailwindcss').Config} */
module.exports = {
  darkMode: 'class',
  // ...
}
```

然后含有 `class=’dark’` 的元素的子元素都时夜间模式的效果

这个[链接](https://tailwindcss.com/docs/dark-mode#supporting-system-preference-and-manual-selection)包含了同时兼容系统设置和手动设置的做法

### 样式重用

- 编辑器的多光标功能：[https://code.visualstudio.com/docs/editor/codebasics#_multiple-selections-multicursor](https://code.visualstudio.com/docs/editor/codebasics#_multiple-selections-multicursor)
- 标记语言的循环语法
- react 等框架的 component 概念
- `@apply` and `@layer` in the [Functions & Directives](https://tailwindcss.com/docs/functions-and-directives#layer) documentation.
- 避免提前过度抽象

### 添加自定义样式

- 编辑 `tailwind.config.js`, 文档在此：[https://tailwindcss.com/docs/theme](https://tailwindcss.com/docs/theme)
- [Arbitrary properties](https://tailwindcss.com/docs/adding-custom-styles#arbitrary-properties) 和 [arbitrary variants](https://tailwindcss.com/docs/adding-custom-styles#arbitrary-variants)
- [Using CSS and @layer](https://tailwindcss.com/docs/adding-custom-styles#using-css-and-layer), 使用多个 CSS 文件时，需在 postcss.config.js 文件中添加 `plugins: {’postcss-import’:  {},}` 字段
- [Writing plugins](https://tailwindcss.com/docs/adding-custom-styles#writing-plugins)

### 函数和 directives

directives 是 CSS 文件中的 `@` 开头的语句

`@layer` 用来把一些需要打包的样式绑在一起，后面三个取值：base, components, utilities

`@apply` 后面接 TailwindCSS 已经定义的类，表示把类的定义移植于此处。

**[`@config`](https://tailwindcss.com/docs/functions-and-directives#config)** 指定所在 CSS 文件需要使用的 TailwindCSS 配置文件，放在 @import 语句后面

```css
@tailwind base;
@tailwind components;
@tailwind utilities;

@layer base {
  h1 {
    @apply text-2xl;
  }
  h2 {
    @apply text-xl;
  }
}

@layer components {
  .btn-blue {
    @apply bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded;
  }
}

@layer utilities {
  .filter-none {
    filter: none;
  }
  .filter-grayscale {
    filter: grayscale(100%);
  }
}
```

TailwindCSS 还自定义了一些 CSS 函数：

- `theme()`: 返回 config 文件中的参数，比如
    
    ```css
    .content-area {
      height: calc(100vh - theme(spacing.12));
    }
    ```
    
- [`screen()`](https://tailwindcss.com/docs/functions-and-directives#screen): 以预定义的 breakpoint 为参数，避免代码中间出现硬编码的数值
    
    ```css
    @media screen(sm) { /* ... */ }
    ```
    

## 在 Next.js 项目中安装 TailwindCSS

> [https://nextjs.org/docs/pages/building-your-application/styling/tailwind-css](https://nextjs.org/docs/pages/building-your-application/styling/tailwind-css)
> 

在命令行

```bash
npm install -D tailwindcss postcss autoprefixer
npx tailwindcss init -p
```

如此会在项目的根目录新建 `tailwind.config.js` & `postcss.config.js` 文件

然后编辑 `tailwind.config.js` 文件，添加需要用到 TailwaindCSS 的路径

```jsx
/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    './app/**/*.{js,ts,jsx,tsx,mdx}', // Note the addition of the `app` directory.
    './pages/**/*.{js,ts,jsx,tsx,mdx}',
    './components/**/*.{js,ts,jsx,tsx,mdx}',
 
    // Or if using `src` directory:
    './src/**/*.{js,ts,jsx,tsx,mdx}',
  ],
  theme: {
    extend: {},
  },
  plugins: [],
}
```

在全局样式表 `styles/globals.css` 中引入 TailwaindCSS

```css
@tailwind base;
@tailwind components;
@tailwind utilities;
```

在 `pages/_app.js` 中引入全局样式表。`@` 的含义不明

```jsx
// These styles apply to every route in the application
import '@/styles/globals.css'
import type { AppProps } from 'next/app'
 
export default function App({ Component, pageProps }: AppProps) {
  return <Component {...pageProps} />
}
```

在项目的 components 中使用 TailwindCSS 的类：

```tsx
export default function Page() {
  return <h1 className="text-3xl font-bold underline">Hello, Next.js!</h1>
}
```

.css | TailwindCSS 笔记


## 生成式语言模型

### 模型

- OpenAI/GPT
- Claude
- `bloomchat`, 可以商用 [[GitHub](https://github.com/sambanova/bloomchat)]
- `falcon40B`
    - apache 2.0 许可证，可商用[[huggingface](http://huggingface.co/tiiuae)]
    - gpt3 的性能，更少的运算资源，其中Falcon 7B可以跑在苹果Mac上 [[推特](https://twitter.com/rickawsb/status/1666148546285043714)]
- `TigerBot`: 一款国产自研的多语言任务大模型，70亿参数和1800亿参数两个版本 [[GitHub](https://github.com/TigerResearch/TigerBot)]
- `QLoRA`: 单个GPU，ChatGPT 99%的能力，消费级GPU微调12个小时就可以达到97%的ChatGPT水平，4B就可以保持16B精度的效果 [[论文](https://www.notion.so/Endocytic-trafficking-promotes-vacuolar-enlargements-for-fast-cell-expansion-rates-in-plants-6b8f0a313c184ccba9fb5a035bb04a0e?pvs=21)] [[GitHub](https://www.notion.so/pdf-14a94950d61c42d3b03bb132f7655589?pvs=21)]
- `MBT 30B`: 开源商用模型为数不多的选择里出现了一个比Falcon 40B更好的模型 [[Twitter](https://twitter.com/fi56622380/status/1672137540281974784)]
- `GLM-6B` & `GLM2-6B`: 智谱AI发布，对学术研究完全开放，并且在完成企业登记获得授权后，允许免费商业使用。[[Twitter](https://twitter.com/GanymedeNil/status/1679892021807550465)][[微信公众号@GLM大模型](https://mp.weixin.qq.com/s?__biz=MzkxNjMzMjM3NA==&mid=2247484214&idx=1&sn=e42153f987a74d1ffc7882f7cc09670d)]
- `Llama 2`: Meta开源大语言模型Llama 2，可免费商用. [[微信](https://mp.weixin.qq.com/s/9pcmrCEyp2AQsL3MbPYx-Q?utm_source=pocket_saves)介绍]
    - Jim Fan 评论 [[推特，翻译](https://twitter.com/dotey/status/1681553916373135362?utm_source=pocket_saves)]
    - 很多团队几乎都达成共识， RLHF 不重要，SFT 就够了。现在 Llama2 的论文说 RLHF 非常非常重要。[[推特](https://twitter.com/oran_ge/status/1681793774685659136?utm_source=pocket_saves)]
    - `LLaMA-2-7B-32K`, context为32K的模型 [[推特](https://twitter.com/JefferyTatsuya/status/1685423475979325440)][[Twitter](https://twitter.com/togethercompute/status/1685048832168714240)]

### 基于模型，直接可用的产品

- OpenAI/GPT
    - ChatGPT
        - 2023年6月13日，GPT提供了函数调用，让ChatGPT来自己调用函数。[[Twitter](https://twitter.com/cryptonerdcn/status/1668733300070924288)][[OpenAI](https://openai.com/blog/function-calling-and-other-api-updates)][[用法 Twitter@宝玉](https://twitter.com/dotey/status/1668728109376450566)]
    - ChatGPT - Code Interpreter
        - 介绍 [[推特](https://twitter.com/fuyufjh/status/1684191835210809344)][[YouTube](https://www.youtube.com/watch?v=4wGlRrir_u4)]
        - 《ChatGPT 探索：Code Interpreter 高级指南》[[微信@浮之静](https://mp.weixin.qq.com/s/K_csi1oWDv5tEaeeKSlvwA?utm_source=pocket_saves)]
        - 源码可能被套出。[[Twitter](https://twitter.com/fuergaosi/status/1679457847237820416)]
        - 对 code interpreter 的逆向工程 [[Twitter](https://twitter.com/Yampeleg/status/1678045605527003136)][[Mem](https://mem.ai/p/xyy8ULiAce1BecTxnU0M)]
    - OpenAI API
        - 2023年8月23日，OpenAI 开放了 GPT-3.5 的微调的API [[推特](https://twitter.com/dotey/status/1694207797351616703)]
    - OpenAI on Azure 内置了一个内容过滤器 [[推特1](https://twitter.com/jw1dev/status/1666613728106938368)][[推特2](https://twitter.com/jw1dev/status/1666622878962548740)]
    - `forefront`: 完全免费 GPT-4 的工具 [[登录](https://accounts.forefront.ai/)]，大概基于 `gptfree-ts` [[GitHub](https://github.com/xiangsx/gpt4free-ts)]
    - `BratGPT`: ChatGPT的激进版本。[[官网](https://bratgpt.com/)]
    - `SmartStudy`: 提供文本文档，创建10个问题的小测验。[[官网](https://smartstudy.streamlit.app/)]
    - `XrayGPT`: 通过给定的 X 光片来促进围绕胸部 X 光片的自动化分析的研究。[[GitHub](https://twitter.com/CarsonYangk8s/status/1661588037892198401)]
    - `FinGPT`: 类似BloomBerg的开源方案，RLHF 和 Lora 的低秩技术 [[Twitter](https://twitter.com/JefferyTatsuya/status/1668433680887615488)]
- 微软
    - BingAI
        - 本地部署方案 [[推特](https://twitter.com/geekbb/status/1665692703055552513)][[GitHub](https://github.com/adams549659584/go-proxy-bingai)]
    - VsCode Copilot
    - Office 365 Copilot: 每月每名用户30美元. [[verge](https://www.theverge.com/2023/7/18/23798627/microsoft-365-copilot-price-commercial-enterprise)][[微信](https://mp.weixin.qq.com/s/9pcmrCEyp2AQsL3MbPYx-Q?utm_source=pocket_saves)]
- Claude+
    - 例子：阅读多份行业报告 [[推特](https://twitter.com/iamshaynez/status/1684398211958730753)]
- `Llama`
    - llama2.ai: 一个基于 llama 2 的聊天机器人，非官方。[[网站](https://llama2.ai/)]
    - WizardCoder 34B based on Code Llama 写代码 [[推特](https://twitter.com/dotey/status/1696202647269785875)]
- WebGLM: 清华开源的带网络搜索功能的 GLM 实现 [[GitHub](https://www.notion.so/pdf-14a94950d61c42d3b03bb132f7655589?pvs=21)]
- mendable: 根据开发文档进行问答 [[官网](https://www.mendable.ai/usecases/documentation)]
- 阅读 PDF 文档
    - Humata.ai
    - explainpaper
    - ChatPDF
    - [[对比](https://twitter.com/oran_ge/status/1683432444169711616?utm_source=pocket_saves)] Claude2支持超长上下文，摘要信息量更大，更适合长文提炼。ChatDOC 具有页码溯源、表格解析、原文定位功能，数据找得准，也方便二次验证，能够限制大语言的幻觉问题。
- Obsidian-copliot: 快速获取文字的核心观点
- 视频内容梗概
    - Glarity: 浏览器插件，基于ChatGPT和字幕生成Youtube摘要，20秒看完梗概 [[Twitter](https://twitter.com/starzqeth/status/1640867876109422595)]
    - summarize-tech: 5分钟了解长视频的要点. [[Twitter](https://twitter.com/starzqeth/status/1640867876109422595)]
- webpilot: 可联网可读网页链接的插件 Webpilot 推出的 Chrome 版插件 [[chrome](https://chrome.google.com/webstore/detail/webpilot-copilot-for-all/biaggnjibplcfekllonekbonhfgchopo?utm_source=link)]

### 模型教程、评论、二次开发

- 一般性原理
    - 《Prompt 编写模式》[[phodal](https://prompt-patterns.phodal.com)]
    - 《LLM+Embedding构建问答系统的局限性及优化方案》[[知乎](https://zhuanlan.zhihu.com/p/641132245)]
    - 基于检索的 LM，外挂一个数据库用来检索。[[推特](https://twitter.com/cosmtrek/status/1678077835418955781)][[GitHub.io](https://acl2023-retrieval-lm.github.io/)]
    - 一篇泼冷水的论文 [[ACL Anthology](https://aclanthology.org/2023.findings-acl.426/)]
    - 即刻出的Prompt调试工具。[[Twitter](https://twitter.com/vista8/status/1678784460786135040)][[官网](https://promptknit.com/)]
- GPT
    - GPT best practice [[OpenAI](https://platform.openai.com/docs/guides/gpt-best-practices?utm_source=pocket_saves)]
    - Andrew Ng 吴恩达 & Isa Fulford from OpenAI 《Build system with [#ChatGPT](https://twitter.com/hashtag/ChatGPT?src=hashtag_click) API》[推特@**[金田達也](https://twitter.com/JefferyTatsuya)**]
        - 借助 CoT 的思路，翻译字幕，返回正确的 JSON 格式 [[推特](https://twitter.com/dotey/status/1665476562219573249)]
        - 同样的加入了CoT（Chain of Though）的Prompt，如果让GPT打印出来步骤，效果非常好，但是如果不让GPT打印（省点token，以及更容易解析），那么GPT就会偷懒 [[Twitter](https://twitter.com/dotey/status/1668736426286915590)1][[Twitter2](https://twitter.com/dotey/status/1664335473500626946)]
    - 熊猫吃短信是 Twitter@威力狈 开发的垃圾短信过滤工具。将其与 GPT 结合的一些讨论
        - [Twitter@威力狈](https://twitter.com/waylybaye/status/1664253928970788864)：尝试了下用 ChatGPT 自动标注数据，效果太差了。
        - [Twitter@宝玉](https://twitter.com/dotey/status/1669028955842650139)：通常如果我写的话，会做一些小调整
        - [Twitter@IIInoki](https://twitter.com/IIInoki)：是的，感觉八爷用 API 用得有点糙……就只是很简单的 prompt 达到的效果都还不错
    - 《ChatGPT 越过山丘之后，再来谈谈 LLM 应用方向》[[橘子汽水铺](https://quail.ink/orange/p/chatgpt-cross-over-the-hills-and-discuss-llm-application-directions)]
- `LangChain`:
    - 官方教程 [[推特](https://twitter.com/LangChainAI/status/1665009694627250176)][[streamlit](https://blog.streamlit.io/langchain-tutorial-1-build-an-llm-powered-app-in-18-lines-of-code/)]
    - 一个使用 LangChain 和 GPT Index 的教程 [[leanpub, 收费](https://leanpub.com/langchain)][[Pocket](https://getpocket.com/read/3839490971)]
    - LangChain for LLM Application Development 基于LangChain的大语言模型应用开发 [[YouTube](https://t.co/JXV1SBI2OA)]
        - 基于Embedding的文档问答。stuff, map reduce, refine, map rerank [[Twitter@宝玉](https://twitter.com/dotey/status/1667790801420558342)]
    - Chanin Nantasenamat: LangChain tutorial #1: Build an LLM-powered app in 18 lines of code [[streamlit](https://blog.streamlit.io/langchain-tutorial-1-build-an-llm-powered-app-in-18-lines-of-code/?utm_source=pocket_saves)]
    - 把一篇很长的 PDF 内容喂给 ChatGPT，然后向他提问
        - 纯 JS 开源工具推荐 [[推特](https://twitter.com/Barret_China/status/1638119945749037056)]
        - 用 `LangChain` 六七行代码就可以搞定了 [[LangChain](https://js.langchain.com/docs/get_started/introduction)]
- `AutoChain`
    - 介绍 [[推特](https://twitter.com/zhangjintao9020/status/1683996172980199429)][[GitHub](https://github.com/Forethought-Technologies/AutoChain)]
    - 《我为什么放弃了 LangChain》[[推特](https://twitter.com/Barret_China/status/1683135367862718465)][[微信](https://mp.weixin.qq.com/s/jIbz9JYc8-_ua-QLENX__A)] 推友提出的 AutoChain 替代方案 [[推特](https://twitter.com/Barret_China/status/1684211570186887170?utm_source=pocket_saves)]
- `OpenDAN`: 为各类 AI 模块提供运行环境，并提供它们之间的互操作性协议。可创建诸如律师、医生、教师，甚至男女朋友等角色 [[GitHub](https://twitter.com/Barret_China/status/1666455683758161920)]
- “视频语音↔文字”任务相关
    - 指定视频URL，识别文字，翻译 [[GitHub](https://github.com/lewangdev/autotranslate)]
    - `WhisperX`: 按照单词对齐时间戳，生成的字幕都是完整的句子 [[GitHub](https://github.com/m-bain/whisperX)]。[[Twitter@宝玉](https://twitter.com/dotey/status/1667394662628204546)] 写了一个可以根据 YouTube Url 识别 YouTube 字幕的 [Jupyter Notebook](https://github.com/JimLiu/whisper-subtitles/blob/main/whisperx_youtube_subtitle.ipynb)
    - `audiocraft`: audio processing and generation with deep learning. [[GitHub](https://github.com/facebookresearch/audiocraft)]
    - [[推特]](https://twitter.com/Barret_China/status/1684218981639413760) 小作文
    - `yt-dlp` 一行命令下载视频字幕的工具，不需 puppeteer 无头浏览器 [[推特](https://twitter.com/Barret_China/status/1684228477644570624)][[GitHub](https://github.com/yt-dlp/yt-dlp)]
- ChatGPT + AI agent + ScholarAI + Noteable 写的小综述 [[链接失效](https://t.co/eqVc2LIfSz)]
- `MusicGen`: 将文本和旋律转化为完整乐曲 [[Twitter](https://twitter.com/Fenng/status/1668141100610248705)][[ReadHub](https://www.notion.so/3753e42dc4204a99ab83a725b655a632?pvs=21)]
- `MMS`: 一个声音模型 [[HuggingFace](https://huggingface.co/docs/transformers/main/en/model_doc/mms)]
- `FRVR Forge`: AI-Powered End-to-End Game Creation [[Twitter](https://twitter.com/FRVRGames/status/1669758477789540365)][[官网](https://www.notion.so/ai-University-Cloud-8078b4682e454a5fba982f67e4530498?pvs=21)]

### 开发平台

Runpod: 租用 GPU 跑模型并创建 Serverless API 一站式服务，最低只要0.2刀/hr。[[官网](http://runpod.io)]

### 杂项

- 2023年5月27日、28日，OpenAI 使用 Sentry 审计工具封禁来自中国的用户，解决方案：
    - 路由器 Clash 规则 [[推特](https://twitter.com/wey_gu/status/1663003950214438912?utm_source=pocket_saves)]
    - 改用 Azure OpenAI service [[推特](https://twitter.com/zhangjintao9020/status/1662865819041402880)]
    - Cloudflare WARP [[左耳朵](https://haoel.github.io/)]

## 生成式图像模型

2023年5月31日，Adobe 添加人工智能相关功能 generative fill。[[推特](https://twitter.com/CodeByPoonam/status/1663824055164887040)]

- 配置要求极低，连Win掌机都能跑，但是不能断网。[[推特](https://twitter.com/OfflineHelper/status/1666042746866663424)]
- 填充将横屏的视频转换为竖屏。[[推特](https://twitter.com/Alex_Cerrato/status/1681677307843432449)]

`MidJourney`

- 在提示词中添加相机镜头信息。[[推特](https://twitter.com/4rtofficial/status/1663310457854099458)]
- zoom [[Twitter](https://twitter.com/jesselaunz/status/1674210886695923712)]

`StableDiffusion`

- Eric Fu: 训练指南. [[Coding Husky](https://ericfu.me/stable-diffusion-finetune-guide/?utm_source=pocket_reader)]
- 文字或者符号融合生成图片 [[Twitter](https://twitter.com/op7418/status/1680223090138316800)][[微信](https://mp.weixin.qq.com/s/rvpU4XhToldoec_bABeXJw)]

`StyleDrop`: Google 基于 MUSE 的样式迁移 transformer [[推特](https://twitter.com/recatm/status/1665056017107886080)][[GitHub.io](https://styledrop.github.io/)]

`Redream`: 从视频到二次元动画 [[推特](https://twitter.com/heyBarsee/status/1665034805384290307)][[GitHub](https://github.com/Fictiverse/Redream)]

`Runway` Gen-2: 文本生成视频和图片生成视频, 4 秒钟 [[推特](https://twitter.com/op7418/status/1666461595818504192)][[需注册](https://app.runwayml.com/login)]

一个 AI 视频解决方案，来自南洋理工，代码尚未开源 [[Twitter](https://twitter.com/op7418/status/1669026494885285888)] [[GitHub.io](https://anonymous-31415926.github.io/)][[Twitter2](https://twitter.com/rickawsb/status/1672310994390126593)][[arxiv](https://arxiv.org/abs/2306.07954)]

`AWPortrait1.1`: 图像生成 [[Twitter](https://twitter.com/dynamicwangs/status/1673730591462928385)][[LibLibai](https://www.liblibai.com/modelinfo/721fa2d298b262d7c08f0337ebfe58f8)] 

`Anything AI`: 可以取代照片中的任何物体。免费，不需要注册. [[官网](https://www.anything-ai.com/)]

`PixelLab`: 草图创建2D图像. [[官网](https://www.pixellab.ai/)]


·如是我闻 | 生成式人工智能


## 0

这是一篇酬和之作。

徵文标题说的是：

> **機器會製造「內涵」嗎？**
> 

但是正文提出的问题是：

> AI透過程式組合出回答你問題的文字組合，有「涵義」嗎？
> 

可是，「內涵」和「涵義」两个词的——内涵/涵义——就不完全一样啊……

“内涵”(connotation) 通常指词语或表达方式所隐含的情感、态度、暗示或附加的意义。它涉及到词语或表达方式所引起的情感、联想或隐含的观点。也就是弦外之音。

而“涵义”(meaning) 一般指词语、表达方式或行为所传达的字面意义或字面上的定义。它强调的是直接的、明确的意义。

看热闹不嫌事大，那我们再把问题搞复杂一点——在逻辑学里也有一个“内涵”(intension)，和“外延”(extension) 相对应。用**面向对象编程**的说法来理解，一个类里面定义的所有状态量和内部方法的集合，就构成这个类的“**内涵**”；所有（已经和将来能够）从这个类实例化出来的对象的集合，就构成这个类的“**外延**”。

所以看起来，征文者想问的是日常“内涵”也就是言外之意，但是怕杠精（比如我）用有严格定义的逻辑“内涵”解构掉，所以换了“涵义”一词。

这个问题很显然是因应最近大语言模型掀起的这一波 AI 浪潮。这个问题往前再问一句，就是“大语言模型是智能体/有智能吗？”

- 前两年 DeepMind 的 AlphaGo/AlphaZero 系列 AI 在围棋中击败人类棋手时，人们也在问这个问题。
- 上世纪四五十年代专家系统 (expert system) 刚刚开发的时候，人们也在问这个问题。
- 从电子计算机往前追溯到机械计算机，甚至是巴比奇的差分机的时候，人们就已经开始问这样的问题了。

这些问题求并集，然后在问题数量趋近于无穷下的极限，就是“什么是智能”。

这样的问题每每得不到回答，是因为它的逆问题“智能是什么”没有答案。我们并没有智能的准确定义，只能一事一论。而之前的智能和非智能体的区别太明显，以至于作出判断也不能对智能的定义有所启发。

## 1

而对“智能是什么”的探究，哲学、逻辑学、计算机科学、生物学、管理学，不同领域的研究者有着不同的思路。

### 古哲学·洞穴之壁与理念世界

古希腊哲学家柏拉图在《理想国》里提到了“洞穴之壁”的寓言故事。

有一群被囚禁在一个深洞的囚徒，从出生开始就被束缚在这个洞穴里，脖子和腿都被铁链锁住，没办法转身或离开。囚徒身后的洞穴入口处有一道火焰，火焰后有人持物体走过，物体的投射在洞穴内的墙壁上形成了影子。囚徒们就以为这些影子就是唯一的存在。

这里的囚徒代表着人类，洞穴代表着世界，影子则代表着我们对于现象世界的感知和观念。人们的知识和信念往往受限于自己的经验和感知，就像囚徒们只看到了洞穴墙壁上的影子，而在影子之外还存在一个理想的理性世界。柏拉图用这个寓言故事表达了他对于人类认识和智慧的理解。所谓智慧，就是从洞穴的影子反过去推测火把前物体的能力。

当然，这种思想被 Marx 主义定性为一种客观唯心主义、唯理论，是受其批判的。

### 逻辑学·从命题到希尔伯特算符

柏拉图的学生亚里士多德，今天在低年级的物理教科书里基本是个反面典型，但他对逻辑学进行了系统化和全面的研究，提出了许多逻辑学的基本概念和原理。这些成果后来成为了欧洲哲学和逻辑学的基石，对西方哲学和科学的发展产生了深远影响。

所谓逻辑，就是研究命题的对错，以及如何判断命题对错的学问。而命题，就是能被判断对错的句子。但是句子显然可以再分成不同成分，于是就发明/发现了主体、客体、谓词、谓词的量词……等等概念，以及用这些概念构造命题的方法。

但是要注意，虽然逻辑主要由语言来表达，但是逻辑还是和语言不同，主体、客体也不等于句子的主语、宾语。这两者的区别，基本可以类比于之前洞穴之壁寓言里的实体和影子。

这种努力到目前为止的巅峰，基本上要数希尔伯特形式化逻辑系统了。感兴趣的朋友可以自行查阅戈得门特《代数学教程》的第一章，这玩意相当于思想界的引体向上，反正我是一个也拉不上去……

### 计算机·从半导体到抽象语法树

希尔伯特是德国的数学家，《代数学教程》也是数学而不是哲学教材。显而易见，逻辑虽然由哲学家奠基，但是主导权很快落到数学家，至少是哲学家兼数学家手里了。

命题的“真”与“非真”同构于 {1, 0}，各种逻辑运算都可以分解成“或”与“非”两种基本逻辑运算的组合，这就是以数学家乔治·布尔 (George Boole) 命名的布尔代数。因为 {1, 0} 又可以同构于半导体电路的高低电位，和各种类似继电器的门电路组合，所以很容易用计算机在物理世界表示出这些逻辑运算。

我们的电脑由上亿个这样的电位和逻辑门组成，一般的科普文章应该会去介绍芯片啊光刻机之类的东西，本文关注的是另一个方面：虽然生产电脑配件的厂商很多，不同的型号的元器件设计不同，组装出的成品应该千差万别，但是他们可以运行同样的程序，理想条件下（虽然实际工程中常常不理想）我们也可以期望他们跑出同样的结果。

这说明所谓计算机科学，并不等同于研究计算机元件的电子科学和工程，这里电科和电子工程相当于洞穴岩壁上的影子，而计算机科学就相当于火光前的物体。这种超越物理的计算本质，一般用一种叫做“抽象语法树”的数据结构来表示。

### 生物学·从神经元到神经网络

人们发明计算机的时候，基本上还是把它当作工具，就没期望它有什么主体性和智慧。

而随着生物学逐渐发现了神经系统及其作用，也随着物理学在二十世纪初的大发展之后的相对平静，很多物理学家开始插手其他学科。既然生命和非生命体的背后都服从同一套物理规律，既然物理学的众多成功经验说明，搞清楚构成系统的所有微观组成就可以理解宏观的系统，那么搞清楚人类的智力器官的基本单元以及相互作用，按理说也就能够理解什么是智慧。

![a cartoon illustrating a neuron](/photos/2023-06-17-neuron.png)

上图是一个神经细胞的结构示意图。从其他神经细胞释放出来的名为神经递质的化学物质，到达神经元左侧短且密集的树突之后，激活细胞膜表面的离子泵，主动运输离子跨过细胞膜，从而产生电信号。电信号沿细胞膜传导到右侧的树突，刺激凸触释放神经递质给下一个细胞。

![a handdrawing style illustration of perceptron](/photos/2023-06-17-perceptron.png)

上图就是根据神经元的工作原理抽象出的数学模型，名为 perceptron。一个 perceptron 就是一个函数，接受多个输入的自变量，加权求和之后套一个非线性的激活函数，得到一个输出。很多个这样的 perceptron 并连和串联，就构成下图，计算机算法中的神经网络。

![a handdrawing style illustration of a neural network](/photos/2023-06-17-neural-network.png)

而从实验方向研究神经系统，我们隔壁系就有，经常来我们系招人。基本上就是在小鼠的天灵盖上锯开一个天窗，然后给它带上个头盔，头盔上有能从天窗伸进去的电极，采集脑神经的电信号。以前头盔有网线伸到实验室天花板，实时传到数据中心的超算。现在好像进步了，改用 Wi-Fi 了。

这实验怎么通过的伦理审查，咱也不知道，咱也不敢问……

### 管理学·DIKW “数据-信息-知识-智慧”模型

![a pyramid of DIKW model](/photos/2023-06-17-DIKW.png)

DIKW 四个字母分别代表 data, information, knowledge, wisdom，即数据、信息、知识、智慧，是一种知识管理中的心智模型。

四个层次，前一层都是后一层的基础，后一层都是对前一层的理解。

如果是书面文字，数据就是笔画和字母；如果是语言，数据就是人声的响度、频率和音色。由笔画/字母/声音组成的有含义的字词就是信息。表示信息之间的关系的，可以判断对错的命题就是知识。包含和统摄各条知识的思想体系，就是智慧。

反过来说，虽然智慧高于思想，但它仍需要通过把各条知识的表达汇总起来，才能被人感知。对知识的命题的理解依赖于构成名字的各个概念的涵义，属于信息水平的内容。而每个字都有不考虑其涵义的笔画字母构成。

这层与层之间**看似**并没有插入额外的内容，智慧可以直接由笔画构成。但是我们一层层理解的深入，其实是不自觉地借用了我们当前社会约定俗成的解读方式。

比如下面这个图片里的符号，对于现代人就只是数据，无法解读成信息。但是对于苏美尔人，这是用楔形文字表示的数字，是等腰直角三角形的腰和直角边的比值，也就是 $$\sqrt{2}$$ 的近似值。

![sumerian numerical approximation to square root of two](/photos/2023-06-17-ancient-root-2.png)

约定俗成的数据解读方式，也就是关于**数据的数据**，根据西方的构词法，可以叫做“**元**数据”(meta-data)。

数据和元数据一起构成信息，信息和元信息一起构成知识，知识和元知识一起构成智慧。俺坚持写博客的动机，就是用费曼学习法，把无意间使用的元知识显式地表达出来，而且记录下来，争取学而不退转。

## 2

回顾了这些，再来看大语言模型，就会发现它落在了各方努力的延长线的交点。

大语言模型里有一个重要概念叫做“嵌入”(embedding)，就是把语言的基本字元 (token) 可逆地映射到一个超多维度的向量空间里。本来“国王”和“儿子”之间没办法加减乘除，但是嵌入后的向量空间里有加法和数乘，如果嵌入函数选得好，“国王”的向量 + “儿子”的向量，结果向量就约等于“王子”的向量。

![illustration of vector addition from wikipedia](/photos/2023-06-17-vector-addition.png)

生成式语言模型的核心就是一个超多元函数，接受前一个字嵌入后的向量作为输入，给出另一个向量作为输出，用嵌入函数的逆映射翻译成字元；再把旧的输出作为新的输入，直到输出结果是“语段结束”这样一个特殊字元为止。模型训练的过程，主要就是通过现成的语料，拟合这个超多元函数的参数。

从 DIKW 模型来看，语言模型操作的是最基本的数据，它的输出究竟是什么信息，是不是正确的知识，体现了多少智慧，是人根据当下的社会文化来解读的。

而实现 AI 的电子计算机，或是复杂生命的大脑，他们和智能之间的关系，应该就类似于具体的计算机电路和抽象语法树之间的关系。以此类比，未来的智能科学应该会成为一门独立的专业，它和计算机科学和神经生物学的区别，就像今天的电子科学与工程，和计算机科学之间的区别一样。当下神经生物学的热度，将来恐怕多半会被分流。

这种对字符的计算不同于逻辑运算，语言模型不判断输出结果在逻辑上的正确与错误，这既给了他啥都能说几句的 feature，又给了它经常编假消息的 bug。

想要改掉这种错误，引入对 AI 的纠错机制，治本之道恐怕还是诉诸于对世界的正确描述，与理论相关的还是要靠逻辑，与现实相关的还是要靠科学。

只不过，大语言模型提供了一种数据结构，有希望把人类已知的真理储存在一起。对这种数据结构本身的研究，有可能反过来启发科学的发展。柏拉图的洞穴之壁可能不再是一个比喻，未来更大的语言模型的，亿万维度的参数空间有希望成为洞穴门口的那团火。

只不过这一切都是“可能”，现在还只是 AI 的萌芽阶段，还没有足够的证据来证实或者证伪这种畅想。而且 AI 的参数量再大也是有限的，它所能表达的信息也就有限，而真理应当是无限的，就像科学一样，总要训练更新更大的模型，总要发现已知的未知，然后欣然接受更多未知的未知之存在。

如果电子计算机实现的 AI 独立于人类产生了意识和超出人类的智慧，很难想象他们会继续用人类语言这种对他们来说很不方便的方式来交流。

所以，哪怕是做个 AI 生成内容的质检员，科学家依然有事可做。这算是科学的堕落吗？当然不算，如果算的话，那从计算物理也被当作理论物理的那天起，人类就已经投降了（逃）

## 3

现在正面来回答问题：AI透過程式組合出回答你問題的文字組合，有「涵義」嗎？

答：有。

因为语言的「涵義」来自于语言的内容，和整个社会的文化，并不来自于这句话的作者的身份。即便是人与人之间的交流，诉诸身份也是一种非形式逻辑谬误，是理性不足的表现。只有在信息不足仍不得不下结论的时候才该使用，比如法律判决时的自由心证主义和/或法定证据主义。

而鹿妈眼里真人鹿酱与 AI 鹿酱的区别，如果有的话，好像主要体现在动机的区别。动机这种东西，很多智慧不高的生物，比如小猫小狗都会有；而现在的 AI，似乎还没有展现出超出编程者设计的动机。编程写入的信息有限，现有 AI 的动机也就有限，鹿酱的赢面还是很大的。

而动机是生物与非生物的区别吗？而什么是生物 ≠ 生物是什么，那就是另一个含混而复杂的问题了。

## 4

这篇博文发布的时候，高考应该已经结束了，马上该填报志愿了。

那么，西元 2023 年，AI 来袭的当下，该选个啥专业在 AI 浪潮中幸存，或者选个啥专业给 AI 老爷带路呢？

![a screenshot of a quotation from Three Body about attitudes towards aliens](/photos/2023-06-17-three-body-quotation.png)

我的建议是，不要听别人的建议，按自己的兴趣来就好了。

刚刚改开的时候，有一个超级热门的专业，叫科技英语。科技落下了好多年，对外开放需要语言交流，两者一结合应该是热门又稀缺了。结果呢，你现在还听说过这个专业吗？

科技很重要是不错，语言很重要也不错，但是搞科技的人自己可以学英语，学英语的有几个搞得了科技？社会的进步主要靠创新，而创新的方向难以预测，不论这种预测分析听起来多有道理。

如果真的找不到兴趣，那就在能力范围之内，找个难度最高的。如果想从事智力劳动，那数学含量是个不错的衡量标准；如果不排斥体力劳动，那训练时间越长越值得考虑。

但这只是填志愿来不及时的权宜之计，发掘兴趣是人一生的课题。

兴趣不是为了让你成功的时候更得意，毕竟成功的话不论做什么都很得意；

兴趣是为了你不成功时也可以不失意，毕竟平凡才是人生的真谛。


.tex | 什么是智能≠智能是什么


> 本文是《[Scientific Machine Learning Through Physics–Informed Neural Networks: Where we are and What’s Next](https://link.springer.com/article/10.1007/s10915-022-01939-z)》这篇综述的读书笔记。
> 

年前，今年新入职的天文学方面的一位老师给我们群发邮件，宣传某国家实验室超算的 GPU 编程马拉松活动，他可以担任指导老师。于是毫不意外地，我报了名。该编程马拉松项目还需要专门申请，申请材料里要写清楚打算干什么，于是报名的五六个人七嘴八舌地想创意。基于物理的神经网络 PINN 就是天文老师的点子。

~~写到这里，我才意识到，老哥是不是想拿我们当免费劳动力啊~~~

神经网络可以看作是一个复杂的非线性函数，接受一个（一般来说维度很高的）向量作为输入，一番计算后输出另一个向量。训练神经网络，就是找到这个函数的参数，绝大多数找参数的方法涉及计算网络输出对参数的偏导数，因此神经网络计算框架的核心功能就是自动微分 (auto-differentiation)。

而很多物理问题，都可以用（偏）微分方程来描述，微分方程的解不是变量，而是函数，而且往往是复杂的非线性函数。所以基于物理的神经网络 (PINN) 就是以神经网络来表达这个函数，然后把这个函数带入到物理的微分方程中，把神经网络输出和真正的物理解之间的差距当作损失函数，反向传播回去来优化神经网络的参数。代入方程时的微分计算，正好可以利用现成框架的自动微分功能。

在以 GPT 为代表的 transformer 类神经网络模型出现之前，自然语言处理类的机器学习项目，往往要在网络之外，利用人类的语法知识，对语段进行语义分割等等“中间任务”。Transformer 一出，算力出奇迹，中间任务逐渐变得没有必要了。

在 GPT 崭露头角，并且越来越有迹象表明其将会涌现出通用人工智能的今天，这些基于物理的神经网络，会不会还未成熟就已过时？这种心情，就和《三体》第二卷开始，章北海和吴岳面对焊渍未漆的“唐”号航空母舰时差不多吧……

<hr class="slender">

- Abstract
    - PINNs are neural networks that encode model equations. a NN must fit observed data while reducing a PDE residual.

1. Introduction
    - The “curse of dimensionality” was first described by Bellman in the context of optimal control problems. (Bellman R.: Dynamic Programming. Sci. 153(3731), 34-37 (1966))
    - Early work: MLP ([multilayer perceptron](https://en.wikipedia.org/wiki/Multilayer_perceptron)) with few hidden layers to solve PDEs. ([https://doi.org/10.1109/72.712178](https://doi.org/10.1109/72.712178))
    - 感觉可能更全面的一篇综述：[https://doi.org/10.1007/s12206-021-0342-5](https://doi.org/10.1007/s12206-021-0342-5)。该文关注 what deep NN is used, how physical knowledge is represented, how physical information is integrated，本文只关于 PINN, a 2017 framework。

    1. What the PINNs are
        - PINNs solve problems involving PDEs:
            - approximates PDE solutions by training a NN to minimize a loss function
            - includes terms reflecting the initial and boundary conditions
            - and PDE residual at selected points in the domain (called **collocation points**)
            - given an input point in the integration domain, returns an estimated solution at that point.
            - incorporates a [residual network](https://en.wikipedia.org/wiki/Residual_neural_network) that encodes the governing physical equations
            - can be thought of as an **unsupervised strategy** when they are trained solely with physical equations in forward problems, but **supervised learning** when some properties are derived from data
        - Advantages:
            - [mesh-free](https://en.wikipedia.org/wiki/Meshfree_methods)? 但是我们给模型喂训练数据的时候往往已经暗含了 mesh 了吧
            - on-demand computation after training
            - forward and inverse problem using the same optimization, with minimal modification
    2. What this Review is About
        - 提到了一个做综述找文章的方法：本文涉及的文章可以在 Scopus 上进行高级搜索：`((physic* OR physical)) W/2 (informed OR constrained) W/2 “neural network”)`
2. The Building Blocks of a PINN
    - question:
    
    $$
    F(u(z);\gamma)=f(z),\quad z\ \in\ \Omega \\ B(u(z))=g(z), \quad z\ \in\ \partial \Omega
    $$
    
    - solution:
    
    $$
    \hat u_{\theta}(z)\approx u(z)\\ \theta^* = \arg\min_{\theta}\left(\omega_F L_F(\theta)+\omega_BL_B(\theta)+\omega_{data}L_{data}(\theta)\right)
    $$
    
    1. Neural Network Architecture
        - DNN (deep neural network) is an artificial neural network that is deeper than 2 layers.
        
        1. Feed-Forward Neural Network: 
            - $$u_{\theta}(x) = C_{K} \circ C_{k-1} ...\alpha \circ C_1(x),\quad C_k(x) = W_k x_k + b_k$$
            - Just change CNN from convolution to fully connected.
            - Also known as multi-layer perceptrons (MLP)
            
            1. FFNN architectures 
                - Tartakovsky et al used 3 hidden layers, 50 units per layer,  and a hyperbolic tangent activation function. Other people use different numbers but of the same order of magnitude.
                - A comparison paper: *Blechschmidt, J., Ernst, O.G.: Three ways to solve partial differential equations with neural networks –A review. GAMM-Mitteilungen 44(2), e202100,006 (2021).*
            2. multiple FFNN: 2 phase [Stephan problem](https://en.wikipedia.org/wiki/Stefan_problem).
            3. shallow networks: for training costs
            4. activation function: the swish function in the paper has a learnable parameter, so — [how to add a learnable parameter in PyTorch](https://discuss.pytorch.org/t/how-could-i-create-a-module-with-learnable-parameters/28115)
        2. Convolutional Neural Networks: 
            - I am most familiar with this one.
            - $$f_i(x_i;W_i)=\Phi_i(\alpha_i(C_i(W_i,x_i)))$$
            - performs well with multidimensional data such as images and speeches
            
            1. CNN architectures: 
                - `PhyGeoNet`: a physics-informed geometry-adaptive convolutional neural network. It uses a coordinate transformation to convert solution fields from irregular physical domains to rectangular reference domains.
                - According to Fang ([https://doi.org/10.1109/TNNLS.2021.3070878](https://doi.org/10.1109/TNNLS.2021.3070878)), a Laplacian operator can be discretized using the finite volume approach, and the procedures are equivalent to convolution. Padding data can serve as boundary conditions.
            2. convolutional encoder-decoder network
        3. Recurrent Neural Network
            - $$f_i(h_{i-1})=\alpha\left(W\cdot h_{i-1}+U\cdot x_i+b\right)$$, where f is the layer-wise function, x is the input, h is the hidden vector state, W is a hidden-to-hidden weight matrix, U is an input-to-hidden matrix and b is a bias vector. 我认为等号左边的 $$h_{i-1}$$ 应当作为下标
            - 感觉有点像 hidden Markov model，只不过 Markov 中间的 hidden layers 好像与序号无关（记不清了），~~RNN 看起来各个 W 和 H 似乎不同~~。**RNN cell is actually the exact same one and reused throughout.** (from [https://blog.floydhub.com/a-beginners-guide-on-recurrent-neural-networks-with-pytorch/](https://blog.floydhub.com/a-beginners-guide-on-recurrent-neural-networks-with-pytorch/)). Cartoon from Wikipedia:
                
                ![RNN 的构成单元](/photos/2023-03-20-rnn-unit.png)
                
            - From [https://blog.floydhub.com/a-beginners-guide-on-recurrent-neural-networks-with-pytorch/](https://blog.floydhub.com/a-beginners-guide-on-recurrent-neural-networks-with-pytorch/):
                
                ![RNN 的种类](/photos/2023-03-20-rnn-types.png)
                
            1. RNN architectures
                - can be used to perform numerical Euler integration
                - 基本上输出的第 i 项只与输入的第 i 和 i-1 项相关。
            2. LSTM architectures
                - 比 RNN 多更多中间隐变量，至于怎么做到整合长期记忆的，技术细节现在可以先略过
        4. other architectures for PINN
            1. Bayesian neural network: weights are distributions rather than deterministic values, and these distributions are learned using Bayesian inference. 只介绍了[一篇文章](https://doi.org/10.1016/j.jcp.2020.109913)
            2. GAN architectures: 
                - two neural networks compete in a zero-sum game to deceive each other
                - physics-informed GAN uses automatic differentiation to embed the governing physical laws in stochastic differential equations. The discriminator in PI–GAN is represented by a basic FFNN, while the generators are a combination of FFNNs and a NN induced by the SDE
            3. multiple PINNs
    2. Injection of Physical Laws
        - 既然是要解常/偏微分方程，那么微分计算必不可少。四种方法：hand-coded, symbolic, numerical, auto-differentiation，最后一种显著胜出。所谓 auto-differentiation, 就是利用现成框架，框架自动给出原函数的导数的算法。
        - Differential equation residual:
            - $$r_F[\hat u_\theta](z)=r_\theta(z):=F(\hat u_\theta(z);\gamma)-f$$
            - $$r_F[\hat u_\theta](z)=r_\theta(x,t)=\frac{\partial}{\partial t}\hat u_\theta(x,t)+F_x(\hat u_\theta(x,t))$$: 原文给出了来源，但是从字面上看不出来与前式的等价性
        - Boundary condition residual: $$r_B[\hat u_\theta](z):=B(\hat u_\theta(z))-g(z)$$
    3. Model Estimation by Learning Approaches
        1. Observations about the Loss
            - $$\omega_F$$ accounts for the fidelity of the PDE model. Setting it to 0 trains the network without knowledge of underlying physics.
            - In general, the number of $$\theta$$ is more than the measurements, so regularization is needed.
            - The number and position of residual points matter a lot.
        2. Soft and Hard Constraints
            - Soft: penalty terms. Bad:
                - satisfying BC is not guaranteed
                - assignment of the weight of BC affects learning efficiency, no theory for this.
            - Hard: encoded into the network design. [Zhu et. al](https://doi.org/10.1007/s00466-020-01952-9)
        3. Optimization methods
            - minibatch sampling using the Adam algorithm
            - increased sample size with L-BFGS (limited-memory Broyden-Fletcher-Goldfarb-Shanno)
    4. Learning theory of PINN: roughly in DE, consistency + stability → convergence
        1. convergence aspects: related to the number of parameters in NN
        2. statistical learning error analysis: use *risk* to define *error*
            - Empirical risk: $$\hat R[u_\theta]:=\frac{1}{N}\sum_{i=1}^N \left\|\hat u_{\theta}(z_i)-h_i\right\|^2$$
            - Risk of using approximator: $$R[\hat u_{\theta}]:=\int_{\bar \Omega}(\hat u_{\theta}(z)-u(z))^2dz$$
            - Optimization error: the difference between the local and global minimum, is still an open question for PINN. $$E_O:=\hat R[\hat u_{\theta}^*]-\inf_{\theta \in \Theta}\hat R[u_\theta]$$
            - Generalization error: error when applied to unseen data. $$E_G:=\sup_{\theta \in \Theta}\left\|R[u_\theta]-\hat R[u_\theta]\right\|$$
            - Approximation error: $$E_A:=\inf_{\theta \in \Theta}R[u_\theta]$$
            - Global error between trained deep NN $$u^*_\theta$$ and the correct solution is bounded: $$R[u^*_\theta]\le E_O+2E_G+E_A$$
            - 有点乱，本来说 error 是误差，结果最后还是用 risk 作为误差
        3. error analysis results for PINN
3. Differential Problems Dealt with PINNs：读来感觉这一部分意义不大，将来遇到需要解决的问题时，回来看看之前有没有人做过就行了——另一方面看，一类方程就需要一类特殊构造的神经网络来解，那么说明神经网络解方程的通用性并不好~
    1. Ordinary differential equations: 
        - Neural ODE as learners, a continuous representation of **ResNet**. [[Lai et al](https://doi.org/10.1016/j.jsv.2021.116196)], into 2 parts: a physics-informed term and an unknown discrepancy
        - LSTM [[Zhang et al](https://doi.org/10.1016/j.cma.2020.113226)]
        - [Directed graph models](https://doi.org/10.1016/j.compstruc.2020.106458) to implement ODE, and Euler RNN for numerical integration
        - Symplectic Taylor neural networks in [Tong et al](https://doi.org/10.1016/j.jcp.2021.110325) use symplectic integrators
    2. Partial differential equations: steady/unsteady的区别就是是否含时
        1. steady-state PDEs
        2. unsteady PDEs
            1. Advection-diffusion-reaction problems
                1. diffusion problems
                2. advection problems
            2. Flow problems
                1. Navier-Stokes equations
                2. hyperbolic equations
            3. quantum problems
    3. Other problems
        1. Differential equations of fractional order
            - automatic differentiation not applicable to fractional order → [L1 scheme](https://doi.org/10.1515/fca-2019-0086)
            - [numerical discretization for fractional operators](https://doi.org/10.1137/18M1229845)
            - [separate network to represent each fractional order](https://doi.org/10.1038/s43588-021-00158-0)
        2. Uncertainty Estimation: [Bayesian](https://doi.org/10.1016/j.jcp.2020.109913)
    4.  Solving a Differential Problem with PINN
        - 1d non-linear Schrödinger equation
        - dataset by simulation with MATLAB-based Chebfun open-source(?) software
4. PINNs: Data, Applications, and Software
    1. Data
    2. Applications
        1. Hemodynamics
        2. Flows Problems
        3. Optics and Electromagnetic Applications
        4. Molecular Dynamics and Materials-Related Applications
        5. Geoscience and Elastiostatic Problems
        6. Industrial Application
    3. Software
        1. `DeepXDE`: initial library by one of the vanilla PINN authors
        2. `NeuroDiffEq`: PyTorch based used at Harvard IACS
        3. `Modulus`: previously known as Nvidia SimNet
        4. `SciANN`: implementation of PINN as Keras wrapper
        5. `PyDENs`: heat and wave equations
        6. `NeuralPDE.jl`: part of SciML
        7. `ADCME`: extending TensorFlow
        8. `Nangs`: stopped updates, but faster than PyDENs
        9. `TensorDiffEq`: TensorFlow for multi-worker distributed computing
        10. `IDRLnet`: a python toolbox inspired by Nvidia SimNet
        11. `Elvet`: coupled ODEs or PDEs, and variational problems about the minimization of a functional
        12. Other Packages
5. PINN Future Challenges and Directions
    1. Overcoming Theoretical Difficulties in PINN
    2. Improving Implementation Aspects in PINN
    3. PINN in the SciML Framework
    4. PINN in the AI Framework
6. Conclusion


.tex | 基于物理的神经网络 (PINN) 综述笔记


## Mathematica 的原生体验暨山寨目标

本科的时候老师总是跟我们念叨，让我们学点科学计算软件，可学的不多，不过 MatLab, Mathematica, Maple, Origin 和 Labview.  ~~作为编程语言的 MatLab 是世界上语法最垃圾的（没有之一）~~ ，Maple 实在是太小众了，Origin 和 Labview 不仅应用场景有限而且繁琐还有版权问题，于是 MMA 就成了我主要的折腾对象。不敢说拿手，起码是略懂。

Wolfram 和 python 一样也是[动态语言和解释型语言](python-interpreter-editor-virtualenv)，而且默认的新建文件类型就是 `.nb` 笔记本文件，命令按块执行，输出结果直接显示在代码块下方，强烈怀疑 Jupyter Notebook 就是山寨了 Mathematica。当然另有一种 `.m` 文件，用于执行文件内的所有命令，适用于比较大型的独立应用。

![](/photos/2022-06-19-mathematica-notebook.gif)

虽然现在的学校给学生买了正版许可证，但是只能用在一台电脑上，所以笔记本上就安装不了。虽然百度贴吧的精华帖里有传统艺能算号器教程，但是现在 Wolfram 开放了免费的 Wolfram Engine，所以我们还是来点正大光明的，用完全合法的免费手段搭建一个免费的 Wolfram Languange 运行环境，效果尽可能贴近 Mathematica。

需要用到的工具有：

- Wolfram Engine
- Wolfram Script
- Wolfram Engine For Jupyter
- jupyter
- vscode

## Wolfram Engine 和 Wolfram Script 下载和安装

《How do I install Mathematica on Linux?》：[https://support.wolfram.com/12453](https://support.wolfram.com/12453)

在 Google 上搜索“Wolfram Engine”后可以找到官网的下载地址：[https://www.wolfram.com/engine/](https://www.wolfram.com/engine/)

根据自己的操作系统点击下载之后会弹出获取许可证的页面 ([https://account.wolfram.com/access/wolfram-engine/free](https://account.wolfram.com/access/wolfram-engine/free))，没有 Wolfram 账号的需要注册一个账号。

完成之后在下载文件夹打开 terminal, 输入以下命令，其中 xyz 是下载文件名中的版本号：

```python
sudo bash WolframEngine_xxx.yy.zz_LINUX
```

强烈建议按照默认设置完成安装，不做要任何个性化的调整，理由见下方引用块。

> 我把第二个选项，也就是 Wolfram Engine 可执行文件的路径设置成了自己 home 下安放一般独立软件的文件夹，结果激活过程出现了问题：输入 `wolframscript` 之后说找不到 WoflramEngine，填入自己的路径之后提示 Wolfram Engine 尚未激活，手动启动 `WolframEngine` 之后提示输入激活密钥 activation key，但是各处遍寻不得。
解决方法来自以下 StackOverflow 回答：[https://mathematica.stackexchange.com/questions/198822/the-wolfram-kernel-must-be-activated-for-wolframscript-to-use-it](https://mathematica.stackexchange.com/questions/198822/the-wolfram-kernel-must-be-activated-for-wolframscript-to-use-it)
在wolfram官网登陆自己的账号之后，在一个新的标签页输入以下网址 [https://www.wolframcloud.com/users/user-current/activationkeys](https://www.wolframcloud.com/users/user-current/activationkeys)，即可看到自己的 activation key，在 terminal 中打开 Wolfram Engine，根据提示把 activation key 复制粘贴到指定位置，即可完成激活。
但是第二天配置好 vscode 和 Jupyter 之后，再次在命令行打开 WolframScript 的时候提示激活失败，重新按照上述方法操作后，显示 activation key 已被使用。即便是删除后按照默认设置重装，也依然会提示超过许可证限制。
后来在官网给出的联系方式给客服发了消息，客服回信给了新的激活码。
> 

再下载 [WolframScript](https://account.wolfram.com/products/downloads/wolframscript)，这是 Wolfram 的前端。然后按照各个操作系统自己的规矩安装 WolframScript，我的 fedora 就是双击 rpm 文件然后根据提示操作。完成后在命令行输入 `wolframscript`, 根据提示输入 Wolfram 账号和密码，Wolfram Engine 就会联网激活自己。

激活成功之后，在 terminal 输入 `wolframscript`, 显示的结果如下，即说明 Wolfram Engine 和 Wolfram Script 配置成功。

```bash
Wolfram Language 13.0.1 Engine for Linux x86 (64-bit)
Copyright 1988-2022 Wolfram Research, Inc.

In[1]:=
```

在 `In[1]:=` 处输入 `Exit[]` 并按回车，即可退出 Wolfram 回到命令行。

## 将 Wolfram Engine 设为 Jupyter 的后端

[https://github.com/WolframResearch/WolframLanguageForJupyter](https://github.com/WolframResearch/WolframLanguageForJupyter)

根据上面网址的指示，将官方 repo 克隆到本地，因为我们的 python 分隔成了多个[虚拟环境](https://virtual.env)，所以比官网教程多一步 `workon base`:

```bash
[me@my_computer dev]$ git clone https://github.com/WolframResearch/WolframLanguageForJupyter.git
# Cloning into 'WolframLanguageForJupyter'...
# remote: Enumerating objects: 649, done.
# remote: Counting objects: 100% (140/140), done.
# remote: Compressing objects: 100% (52/52), done.
# remote: Total 649 (delta 93), reused 126 (delta 88), pack-reused 509
# Receiving objects: 100% (649/649), 321.55 KiB | 2.23 MiB/s, done.
# Resolving deltas: 100% (411/411), done.
[me@my_computer dev]$ cd WolframLanguageForJupyter
[me@my_computer WolframLanguageForJupyter]$ workon base
(base) [me@my_computer WolframLanguageForJupyter]$ ./configure-jupyter.wls add
(base) [me@my_computer WolframLanguageForJupyter]$
```

## 用法和效果

打开 vscode，按 `Ctrl+Shift+P` 呼出命令搜索框，找到 "Jupyter: Create Interactive Window":

![](/photos/2022-06-19-jupyter-start.png)

单击 Jupyter 后端内核的图表（下图中右上角的"base(Python 3.9.12)"字样），把内核切换为 "Wolfram Language ##"

![](/photos/2022-06-19-switch-kernel.png)

等待后端内核切换完成，就可以输入 Mathematica 命令查看效果了：

![](/photos/2022-06-19-final-result.png)

完成！


.nb | Mathematica 入门：免费正版、vscode、近似原生体验


> 本文也是马克思·普朗克复杂物理研究所《非平衡态集体过程》第9讲的笔记。
> 

最近在蹭一门数学系的读书课，题目叫“非线性时间序列分析”。本来以为会是数学系的人抢物理系动力学方向的饭碗用的（可能实际上也确实是，或者更有可能是反过来），但是老师在前几讲一直把重点放在何种定理如何证明上面。数学系的嘛，这种对公理化系统的喜爱可以理解。但是发现我们几个上课的对这些证明都不太感兴趣之后，~~直接一个发卡弯漂移，教我们用 R 语言分析现实数据，现在新课还没上，不过可能是以股票数据做例子，我的老天鹅，这也太“经世济民”了吧……~~ 最后期末作业发现大家居然又都选择做 PPT 讲中心极限定理的证明，经世济民计划无疾而终。

以下是为了新课程，我自己提前做的准备。

## 下载、安装、环境配置（精神病版）

- [https://cloud.r-project.org/](https://cloud.r-project.org/)
- 看这一个链接就够了：[https://marketplace.visualstudio.com/items?itemName=Ikuyadeu.r](https://marketplace.visualstudio.com/items?itemName=Ikuyadeu.r)
- [https://github.com/randy3k/radian](https://github.com/randy3k/radian)
- [https://github.com/nx10/httpgd](https://github.com/nx10/httpgd)

`Fedora Linux` + `R` + `radian` + `vscode` + `R extension for vscode`

1. 在官网（[https://cloud.r-project.org/](https://cloud.r-project.org/)）下载并安装 R [解释器](https://python-interpreter)。
2. 在命令行输入 `R` 打开解释器，在 R 中输入 `install.packages("languageserver")` 
3. 在 vscode 的市场页面搜索 “R”，安装 R 语言插件。
4. 安装 radian：
    1. 在合适的 python [虚拟环境](https://pyhton-virtualenv) 里输入 `pip intall radian`
    2. 用 radian 取代 R：编辑 `~/.bashrc` , 在其中加入一句`alias r="radian"` ，重启命令行
    3. 在 vscode 的设置中找到 `R>Rterm: Linux`, 输入 radian 的安装路径（在命令行中输入 `which R` 可以找到）
5. 在 vscode 的市场页面搜索 “R debugger”，安装 `R debugger for vscode`
6. 在命令行输入 `R` 打开解释器，在 R 中输入 `install.packages("httpgd")`，安装可视化工具 `httpgd`

## 简单语法

来自马克思·普朗克复杂物理研究所《非平衡态集体过程》第9讲，这老师的讲课顺序简直了……

R 的语法也简直了……

### 简单数据结构 Some data types

```r
# vector
a <- c(1,2,3,NA)
b <- c("m","f","f","m")
# using a value
b[2]

# list
list.ab <- list(number=a, gender=b)
list.ab$number
list.ab[[1]]

# factors (categorial variable)
f <- factor(b)
f
# [1] m f f m f m m
# levels: f m
levels(f) <- c("female", "male")

# dataframe (lists of vectors of the same length)
x <- c(1,2,3)
y <- c("aa","bb","cc")
z <- c(TRUE, FALSE, TRUE)
df <- data.frame(first=x, second=y, third=z)
View(df)
# |      | first | second | third |  
# |    1 |     2 |     aa |  TRUE |
# |    2 |     3 |     bb | FALSE |
# |    3 |     5 |     cc |  TRUE |
```

### 控制流 Loops, conditional statements

```r
# for loop
for(i in 1:5) {
	print(i)
}
# while loop
while(!finished) {
	print("Hello")
}
# if statement
if(i<5) {
	print("Hello")
} else {
	print("Not Hello")
}
```

### 函数 Functions

```r
# calling a function
rnorm(5,mean=1,sd=1)

# defining a function
mysum <- function(a,b,c=1) { a + b + c }
mysum(1,1)
```

### 复杂数据类型 `data.table`

Some comparison:

- `data.table`: R package, fast and memory efficient
- `python.pandas`: python implementation of data frames
- `dplyr`: highly popular, easy to learn

```r
library(data.table)
dt <- as.data.table(df)
```

```r
# read and write
flights <- fread("path/to/your/flights.txt")
weather <- fread("path/tp/your/weather.txt")
```

Making data tidy can simplify the following analysis.

- Every column is an observable.
- Every row is an observation.

```r
# making data tidy
melt( dt,
      id.vars = "ID",
      value.name = "expression",
      variable.name = "cell"
)
# making data messy
dcast(dt, ID ~ cell+expression) # not understand
```

Get item

```r
d[i, j, by] # take `d`, subset rows using `i`, then **calculate** `j` grouped by `by`
# examples
planes[engines == 4]

# slice the 2 columns
planes[, .(tailnum, year)] 
# groupby and calculate
flights[, .(mean_delay = mean(dep_delay, na.rm=T)), by=carrier]
flights[time_hour>20, .(mean_delay=mean(dep_delay,na.rm=T)), by=.(month, origin)]
# math calculations
flights[, speed_kmh := 60*1.61*distance/air_time]
flights[, resc_distance := distance/mean(distance), by=carrier]
```

Merge 2 tables

```r
# left join
merge(a,b,all.x=T)
b[a] # same as above

# right join
merge(a,b,all.y=T)
a[b] # same as above

# inner join
merge(a,b, all=F)
a[b, nomatch=0]

# full join
merge(a,b,all=T)
```

Chaining operations

```r
# data.table way
weather[, ws_kmh:=1.61*wind_speed][, .(mean_ws=mean(ws_kmh)), by=month]
# use operator %>% to take the result on the left as the 1st argument on the right
library(magrittr)
weather[, ws_kmh:=1.61*wind_speed] %>%
.[, .(mean_ws = mean(ws_kmh)), by=month] %>%
head()
```


.r | R语言入门笔记


On youtube.

## What is Rust

fast and powerful, system language

web development through webAssembly

No garbage collection, also no need to manege memory, which makes language more tedious

Use Cargo to manage package

## Install

Windows: .exe

Linux: run the curl script.

```bash
rustup --version
rustc --version 
cargo --version
```

vscode Rust(rls) plugin

## empty folder and compile

```bash
mkdir rustsandbox
cd rustsandbox
touch hello.rs
```

```bash
fn main() {
	println("Hello World!");
}
```

## initialize a project with cargo

```bash
cargo init
```

bettertmil plugin for highlight of `.tmil` file.

```bash
cargo run # compile and debug
cargo build
cargo build --release # for production
```

## print line

```bash
touch src/print/rs
```

```rust
// in print.rs
pub fn run() {
	println!("Hello World!");
	// Basic formatting
	println!("Number: {}",1); 
	println!("{} is from {}","Brad","Mass");
	// Positional arguments
	println!("{0} is from {1} and {0} likes to {2}.","Brad","Mass","code");
	// Named argument
	println!("{name} likes to play {activity}.", name="John", activity="baseball")
	//Placeholder traits
  println!("Binary: {:b} Hex: {:x} Octal: {:o}", 10,10,10);
	//Placeholder for debuging
  println!("{:?}", (10,True,"hello"));
	//Basic Math
	println!("10+10={}",10+10)
}
```

```rust
// in main.rs
mod print;

fn main() {
	print::run();
}
```

## Variable

```rust
// var.rs
pub fn run() {
	let name="Brad";
	let age = 37;
  age = 38; //cannot assign twice
	let mut age = 37;
	age = 38;
	println!("My name is {} and I am {}",name, age);
	// constant
	const ID:i32 = 001;
	println("ID: {}",ID);
	// assign multiple variables
	let ( my_name, my_age ) = ("Brad", 37);

}
```

## Primitive Types

```rust
// type.rs
/*
Primitive Types:
Integers: u8,i8,u16,i16,...u128,i128
Floats: f32,f64
Boolean: bool
Characters: char
Tuples
Arrays
*/

// Rust is a static type language, but compiles usually can infer
 
pub fn run() {
	// default is i32, f64
	let x = 1; 
	let y = 2.5;
	let z: i64 = 454544445554;
	// find max size
	println!("Max i32:{}", std::i32::MAX);
	println!("Max f64:{}", std::f64::MAX);
	// boolean
	let is_active = true;
	// get boolean from expression
	let is_greater = 10 > 5;
	// char
	let a1 = 'a'; // has to be single quotes
	let a2 = 'ab'; // error, can only be one character
	let a3 = '\u{1F600}';
}
```

## Strings

```rust
// string.rs

// primitive str = immutable fixedlength string
// String = growable heap-allocated data structure - use when I need to modify or own srtring data

pub fn run() {
	let mut hello = String::from("Hello ");
	//get length
	println!("Length: {}", hello.len());
	hello.push('W');
	hello.push_str("orld");
	// immutable
	let hello2 = "Hello";
	// methods
	println!("Capacity {}", hello.capacity());
	println!("Is empty {}", hello.is_empty());
	println!("Contains 'World' {}", hello.contains("World"));
	println!("Replace {}", hello.replace("World","there"));
	// loop through string by whitespace
	for word in hello.split_whitespace() {
		println!("{}",word);
	}
	// Create string with capacity
	let mut s = String::with_capacity(10):
	s.push('a');
	s.push('b');
	// Assertion testing
	assert_eq!(2,s.len());
}
```

## tuple

```rust
//tuples.rs

// can be different types
pub fn run() {
	let person: (&str,&str,i8) = ("Brad","Mass",37);
	println!("{} is from {} and is {}", person.0, person.1, person.2);	
}
```

## Array

```rust
// array.ts

use std::mem

pub fn run() {
	let numbers: [i32,5] = [1,2,3,4,5]; // length has to be exact
	println!({:?},numbers);
	// get single value
	println!("Single value{:?}",numbers[0]);
	let mut numbers1: [i32,5] = [1,2,3,4,5];
	numbers1[2] = 20;
	println!("Array length: {}", numbers1.len());
	//arrays are static allocated
	println!("Arry occupies {} bytes", mem::size_of_val(&numbres1));
	// get slice
	let slice: &[i32] = &numbres[0..2];
	println!("")
}
```

## Vector

```rust
//vector.rs

// vectors are resizable arrays
pub fn run() {
	let mut numbers: Vec<i32> = Vec![1,2,3,4];
	// add 
	numbers.push(5);
	numbers.push(6);
	//pop off las values
	numbres.pop();
	// loop through vector values
	for x in numbers.iter(){
		println!("Number: {}", x);
	}
	for x in numbers.iter_mut(){
		*x *= 2; // no idea what the 1st * does
		println!("Number: {}", x);
	}
}
```

## conditional

```rust
//conditional.rs

pub fn run() {
	let age: u8 = 18;
	let check_id: bool = false;
	let knows_person_of_age = true;

	// if/else
	if age >= 21 && check_id || knows_person_of_age {
		println!("Bartender: what would like to drink?");
	} else if age < 21 && check_id {
		println!("Bartender: sorry you have to leave.");
	} else {
		println!("Bartender: I'll need to see your ID.");
	}

	// short if
	let is_of_age = if age>=21 {true} else {false};
	println!("Is of age: {}", is_of_age);
}
```

## loop

```rust
//loop.rs

pub fn run() {
	let mut count = 0;
	//infinite loop
	loop {
		count += 1;
		println!("Number: {}", count);

		if count > 20 {
			break;
		}
	}
	// while loop (FizzBuzz)
	while count <=100 {
		if count%15 === 0 {
			println!("fizzbuzz");
		} else if count%3 == 0 {
			println!("fizz");
			else if count%5 == 0 {
			println!("buzz");	
		} else {
			println!("{}",count)
		}
		count += 1;
	}	
	// for loop
	for x in 0..100 {
		// ...
	}
}
```

## function

```rust
// function.rs
pub fn run() {
	greeting("Hello","Jane");
	let get_sum = add(5,5);
	//closure
	let n3 = 10;
	let add_sums = |n1: i32, n2: i32| n1+ n2 + n3; //need to find out more
}

fn greeting (greet: &str, name: &str) {
	println!("{} {}, nice to meet you.", greet, name);
}

fn add(n1: i32, n2: i32) -> i32 {
	n1 + n2 // no semi-colum here
}
```

## Pointer/Reference

```rust
// pointer.rs

pub fn run() {
	// primitive
	let arr1 = [1,2,3];
	let arr2 = arr1;
	println!("Values: {:?}", (arr1,arr2));
	// with non-primitive, if you assign another variable to a piece of data, the 1st variable will no longer hold that value. You'll need to use a reference (&) to point to the resource
	let vec1 = Vec![1,2,3];
	let vec2 = &vec1;
	println!("Values: {:?}", (&vec1, vec2))
}
```

## Struct

```rust
// struct.rs

// used to create custome data types

// traditional struct
struct Person {
	first_name: String,
	last_name: String
};

impl Person{
	fn new(first: &str, last: &str)-> Person {
		Person {
			first_name: first.to_string(),
			last_name: last.to_string()
		}
	}
	fn full_name(&self) -> String {
		format!("{} {}", self.first_name, self.last_name)
	}
	// set last name
	fn set_last_name(&mut self, last: &str){
		self.last_name = last.to_string();
	}
	// name to tuple
	fn to_tuple(self)->(String,String){
		(self.first_name,self.last_name)
	}
}

struct Color {
	red: u8,
	green: u8,
	blue: u8,
};

// tuple struct
struct ColorTuple(u8,u8,u8); 

pub fn run() {
	let mut c = Color{
		red: 255,
		green: 0,
		blue: 0,
	};
	c.red = 200;
	println!("Color: {},{},{}",);
	
	let mut ct = ColorTuple(255,0,0);
	ct.0 = 200;
	println!("Color: {},{},{}",ct.0,ct.1,ct.2);

	let mut p = Person::new("John","Doe");
	println!("Person {} {}", p.first_name, p.last_name)
	p.set_last_name("Williams");
	println!("Person {}", p.full_name());
	println!("Person {:?}", p.to_tuple());
}
```

## enumerate

```rust
//enum.rs

// enum is a type with a few definitive values

enum Movement {
	// variants
	Up, 
	Down,
	Left, 
	Right
}

fn move_avatar(m:Movement) {
	match m {
		Movement::Up => println!("Avatar Moving Up"),
		Movement::Down => println!("Avatar Moving Down"),
		Movement::Left => println!("Avatar Moving Left"),
		Movement::Right => println!("Avatar Moving Right")
	}
}

pub fn run() {
	let avatar1 = Movement::Up;
	let avatar2 = Movement::Down;
	let avatar3 = Movement::Left;
	let avatar4 = Movement::Right;

	move_avatar(avatar1);
	move_avatar(avatar4);
	move_avatar(avatar2);
	move_avatar(avatar3);	
}
```

## Command line interface

```rust
// cli.rs

use std::env;

pub fn run() {
	let args: Vec<String> = env::args().collect();
	let command = args[1].clone();
	let name = "Brad";
	let status  = "100%"

	println!("Args: {:?}", args);
	println!("Command: {}", command)

	if command == "Hello" {
		println!("Hi {}, how are you?", name);
	} else if command == "status" {
		prinln!("Status is {}", status);
	} else {
		println!("That is not a valid command.");
	}
}
```

.rs | Rust 入门笔记


What is TypeScript:

- static types
- types from 3rd parties can be added with type definition

Dynamic vs Static types

- dynamic: types associated with run-time values, and not explicitly in code
- static: explicitly assign types

Pros and Cons

- pros: more robust, debug, predictability
- cons: more codes to write, requires compilation, **not true typing**

Compiling

- `.ts` or `.tsx` extension
- `TSC` is used
- `tsconfig.json`

# Hands on

## Install

```bash
sudo npm i -g typescript
tsc -v
touch index.ts
```

```tsx
let id: number = 5 
id = `5` // error

```

```bash
tsc index
tsc -- watch index
```

```bash
tsc --init # produces tsconfig.json
```

```json
{
	"outDir": "./dist",
	"rootDir": "/src"
}
```

## Types

```tsx
let id: number = 5
let company: string = "Media"
let isPublished: boolean = true
let x: any = "hello"
x = true // no errors

// array
let ids: number[] = [1,2,3,4,5]
ids.push("hello") // error

let arr: any[] = [1, true, 'hello']

//tuple
let person: [number, string, boolean] = [1, 'Brad', true]

// tuple array
let employee: [number, string][]
employee = [
	[1, 'Brad'],
	[2, 'Sam']
]

// union
let pid: string | number = 22

// enum
enum Direction1 {
	Up, // default is 0
	Down,
	Left,
	Right
}

enum Direction2 {
	Up   = "Up", // default is 0
	Down = "Down",
	Left = "Left",
	Right= "Right"
}

//objects
const user: {
	id: number,
	name: string
} = {
	id: 1,
	name: 'John'
}

type User = {
	id: number,
	name: string
}

const user: User

// type assertion
let cid: any = 1
let customerId = <number>cid
let customerId = cid as number

```

## function

```tsx
function addNum(x: number,y: number): number {
	return x+y
}
//void

function log(message: number | string): void {
	console.log(message)
}
```

## Interfaces

```tsx
interface UserInterface {
	readonly id: number,
	name: string,
	age?: number // optional property
	register(): string
}
const user1: UserInterface = {
	id: 1, // error , read only
name: "brad"
}

interfce MathFunc {
	(x: number, y: number): number
}

const add: MathFunc = (x: number, y: number): number => x+y
```

## Class

```tsx
class Person implements UserInterface{
	private id: number	 // within the class
	protected name: string // within class or extended classes
	salary: number

	constructor(id: number, name: string) {
		this.id = id
		this.name = name
	}
	register() {
		return `${this.name} is registered.`
	}
}

const brad = new Person(1,'Brad')
```

## Subclass

```tsx
class Employee extends Person {
	position: string

	constructor(id: number, name: string, position: string) {
		super(id,name)
		this.position = position
	}
}
const emp = new Employee(3,"Shawn","developer")
console.log(emp.register())

```

## Generics

```tsx
function getArray(items: any[]): any[] {
	return new Array().concat(items)
}
let numArray = getArray([1,2,3,4])
let strArray = getArray(['a','b','c','d'])

numArray.push('hello') // no error, but not what we want

function getArray<T>(items: T[]): T[] {
	return new Array().concat(items)
}
let numArray = getArray<number>([1,2,3,4])
numArray.push('hello') // error
```

## With React

```bash
npx create-react-app . --template typescript
npm start
touch header.tsx
```

```tsx
export interface Props{
	title: string
	color?: string
}
const Header = (props: Props) => {
	return (
		<header>
		  {% raw %}
			<h1 style={{ color: prps.color ? props.color: "blue" }}>
				{props.title}
			</h1>
		  {% endraw %}
		</header>
	)
}
```

.ts | TypeScript 入门笔记


很显然，我不可能把“阿掖山”这个名字写到论文里，与研究相关的项目、组里的代码和数据，都由另一个实名的 GitHub 账号来处理。这就有个问题——如何告诉 GitHub 某个项目文件夹该由哪个账号来做版本管理。

于是 STFW，结果看到了GitHub  官方的回答：[“这边建议您把两个账号合并呢～”](https://docs.github.com/en/account-and-profile/setting-up-and-managing-your-github-user-account/managing-user-account-settings/merging-multiple-user-accounts)

其实这个问题在建立这个博客站之前就解决了，但是因为很长时间我的研究代码都是自己在用，而且只在台式机上用，一直没有推到 GitHub 上去，实名账号一直没在笔记本上用过。具体细节忘得差不多了，这次复习一下。

作为例子，两个账号的用户名分别是 `USER1` 和 `USER2`，注册邮箱分别是 `USER1@EMAIL.com` 和 `USER2@EMAIL.com`。

## 多个计算机用户

当然了，最简单的方法就是新建一个操作系统用户，每个用户登录一个 GitHub 账号。这种方法好处很多：

- 不需要特殊操作。
- 适用于不同操作系统。
- 切换身份需要专门切换账号，有助于防止操作者忘记自己所处的身份。

但是这篇文章不会涉及这种方法，因为当初买电脑的时候并没有注意到需要做身份隔离，等到发现事情不妙的时候已经混装和两个身份需要的不同软件，积重难返。于是采用了以下两节的解决方案。

## 单个计算机用户@Windows: GitHub Desktop

![](/photos/2021-12-26-github-desktop.png)

- 在官网下载、安装、打开 [GitHub Desktop](https://desktop.github.com/) 客户端。
- 在 GitHub 网页版上切换到新的账户。
- 点击左上角 `File > Options`，默认界面就是账户信息。点击 `Sign Out` 退出登录，然后再点击 `Sign In`，根据弹出窗口的提示操作，就来到了新的账户。

## 单个计算机用户@Linux : `.ssh/config`

具体操作看以下两个连接就够了：

- [https://gist.github.com/JoaquimLey/e6049a12c8fd2923611802384cd2fb4a](https://gist.github.com/JoaquimLey/e6049a12c8fd2923611802384cd2fb4a)
- [https://docs.github.com/en/authentication/connecting-to-github-with-ssh](https://docs.github.com/en/authentication/connecting-to-github-with-ssh)

~~但是为了水字数，~~ 还是写得详细一点……

### 本地：生成并启用 SSH key

打开命令行，输入以下命令，生成 SSH key：

```bash

ssh-keygen -t rsa -b 4096 -C "USER1" 
ssh-keygen -t rsa -b 4096 -C "USER2"
```

其中 `-t` 指定加密算法，`-b` 指定密钥的位数，`-C` 相当于注释。

然后命令行会弹出几个选项，可以一路按回车使用默认值。

上述命令完成后，在 `~/.ssh` 文件夹应该会有两对四个密钥文件：

- `~/.ssh/USER1`
- `~/.ssh/USER1.pub`
- `~/.ssh/USER2`
- `~/.ssh/USER2.pub`

然后输入以下命令，启用刚刚生成的密钥。

```bash

eval "$(ssh-agent -s)" # 启动 ssh-agent
ssh-add ~/.ssh/USER1   # 添加 USER1 的密钥
ssh-add ~/.ssh/USER2   # 添加 USER2 的密钥
```

### 网页：把密钥添加到对应的账号

在网页端以 `USER1` 身份登录 GitHub 之后，在 "Settings" 页面找到 "SSH and GPG keys" 选项卡，点击绿色的 "New SSH key" 按钮之后，将 `~/.ssh/USER1.pub` 中的内容复制到 "Key" 填空区，然后起一个名字，点击 "Add SSH key" 按钮。

![](/photos/2021-12-26-github-key.png)

USER2也照此办理。

**千万要注意**复制的应该是 `.pub` 后缀的文件！

### 本地：编辑 `~/.ssh/config` 文件

在 ~/.ssh/ 找到或者新建一个名为 config 的文本文件。打开之后，将以下内容添加到文件中：

```

Host github.com-user1
	Hostname github.com
	User git
	IdentityFile ~/.ssh/user1
Host github.com-user2
	Hostname github.com
	User git
	IdentityFile ~/.ssh/user2
```

### `git clone` 时 repo 地址的改动

一般的 git clone, 直接把 GitHub 提供的命令复制粘贴到命令行就行了。

![](/photos/2021-12-26-git-clone.png)

但是我们这个不同，首先是只能选择 SSH 模式，然后是需要在域名`github.com` 后面加上`-user1`:

```bash

git clone git@github.com-user1:User/Repo.git
```

这里就体现出之前在 `~/.ssh/config` 把 Host 命名为 `github.com-****` 的好处了。

### `git commit` 前填写在 repo 中填写账户信息

 第一次做完改动推送到 GitHub 之前，需要专门在 repo 级别写明自己的身份，也就是在命令行输入：

```bash

git config --local user.name  "USER1"
git config --local user.email "USER1@EMAIL.com"
```

### **注意：** 为了防止操作者忘记自己所处的身份

强烈建议去掉用户信息的全局设置：

```bash

git config --global --unset user.name
git config --global --unset user.email
```

这样假如忘记之前的 `git config --local`, 第一次 git commit 的时候会报错，提示信息缺失。

这样操作一次之后，之后的操作几乎感受不到账户的不同。


.git | 管理 GitHub 不同用户身份的仓库


今年感恩节三天假期加上周末，一共五天的时间，别的啥也没干，憋在家里给博客换了个主题模板。现在新版本已经上线，基本上已经能用，明显的 bug 都已经解决了。主要的工作内容如下：

- 从 Tufte 风格转换到 material 风格
- 评论区迁移到现成的 ~~[utterance](https://utteranc.es/)~~  [giscus](https://giscus.app/)。
- 将旧模版中的侧边栏注记功能移植到新的模板。
- 调整了 CSS，包括字体、代码模块、博客标题限制高度、博客博客实现类似纸张的卡片效果。
- 重写了 index.html, /History.html, /Links.html 等页面，尤其是 /Topics.html，实现了一个响应式的两列结构。
- 重写了博文前面的元信息。
- 将之前的 repo 重命名并且归档，新建一个同名的 repo，推送上线。

下面挨个来说。

## 风格转换

![](/photos/2021-12-06-blog-old.png)

之前的风格名字叫做 Tufte，好像是根据一个美国教授的设计，主要设计元素包括一套自己加载的衬线字体（很漂亮，但是对中文没用），还有博文占据页面宽度的大约 60%，右侧剩下的空间可以做边注，有一个设计很精美的横向分割线 `<hr class="slender">`。

这个模板很漂亮，但是衬线字体搭配背景色，就跟人一种上个世纪古董网站的感觉（没有对卢昌海老师不敬的意思）。

Material Design 是 Google 推出的一个组件库，提供类似纸张和卡片的视觉效果，就给人一种很现代的感觉，内心觊觎已久。[GitHub 的这个 repository](https://github.com/naveenshaji/material) 就用了这套设计风格，虽然已经不再更新维护了，但是已有的功能，比如点击链接之后的加载页面，页面顶端的阅读进度条，我觉得让我自己来的话，十年之内都不一定能学到做出这些效果的技术，于是就直接拿来用了。

## 评论区

### 旧版：jQuery 搭配 GitHub Milestones

之前的评论区是根据 [farseerfc](https://farseerfc.me/zhs/pages/about.html) 大佬的[博文](https://farseerfc.me/zhs/github-issues-as-comments.html)自己仿写的 JavaScript 函数。原文是把 issue 作为一个博文的评论区，issue 下面的 comment 作为评论，这样每一条评论都是平级的，没办法实现对某一条评论的回复，只能在评论内容中指明回复的对象。

除了像博文里一样自己手搓代码，也有现成的第三方工具 [utterance](https://utteranc.es) 来完成这一工作，但是我还是不喜欢这种单层评论系统，于是决定自己仿写一个类似的系统，但是让一个 milestone 对应一篇文章，一个 issue 对应一条评论，一个 comment 对应一条回复。

这就需要我在博文的 Markdown 页面注明对应的 milestone 的编号，然后在网页加载完成之后向 GitHub 对应的 milestone 发送一个 GET 请求，询问是否存在 issues。 得到肯定的回答之后，再依次发送请求 GET 每一条 issue 的内容，显示在博文下方。代码位于 `[/_includes/comments.html` 页面](https://github.com/MountAye/blog-tufte/blob/source/_includes/comments.html)，当年从异步编程开始学起，颇费了我几个周末。

问题出在 GitHub 的用户权限上，只有作者和管理员才有权给某条 issue 指定一个 milestone，所以读者建立 issue 进行评论之后并不会直接显示在博文下面，还需要我回到 repo 把那条 issue 手动挪到对应的文章，几乎不可用。

### 新版：giscus 搭配 GitHub Discussions

这次改版的时候觉得用户体验比“老子可以手搓评论区代码”的自我满足更重要，直接换用了 utterance。评论区在博客页面就提供了编辑区，新版本第一次上线不久就有朋友留言，说明这个评论区还是很好用的。

后来GitHub推出了 Discussion 功能，每一条 discussion 下方可以有不同评论，评论下面可以有针对的回复，这就和一般的评论区和BBS 的“楼层-单元”同构了。

然后又在阮一峰老师的博客看到了 [giscus，](https://giscus.app/)就是在 Discussions 架构下和 [utterance](https://utteranc.es/) 类似的一个工具，只需要在官网按照流程配置，然后把生成的几行代码嵌入到自己的页面里就好了，比原来方便太多了：

```html
<script src="https://giscus.app/client.js"
        data-repo="[ENTER REPO HERE]"
        data-repo-id="[ENTER REPO ID HERE]"
        data-category="[ENTER CATEGORY NAME HERE]"
        data-category-id="[ENTER CATEGORY ID HERE]"
        data-mapping="pathname"
        data-reactions-enabled="1"
        data-emit-metadata="0"
        data-theme="light"
        data-lang="en"
        crossorigin="anonymous"
        async>
</script>
```

之前 utterance 创建的评论也可以直接从 Issue 移动到 Discussion 板块，所以刚刚那条评论可以正常显示。但是因为换了新的 repo，旧版本的两条评论就移植不过来了，请萌狼和 HK 兄弟包涵。 

## 旧版特有功能：侧边栏注记、正文图片

早就想给博客改版了，一直拖着不办的原因主要是直接把博文复制粘贴到新模板的 `/_posts` 文件夹之后会报错，不知道排错需要多长时间，于是压根就不动手了。因为旧版通过 jekyll 实现了一些正常 markdown 文档没有的功能，我用到的主要就是侧边栏的边注 `sidenote`，以及在正文内部插入图片的 `maincolumn`。

jekyll 是建立在 ruby on rail 上的一个软件，所以这些功能也是用 ruby 语言写成的。本以为会很难，结果认真一看，其实根本没什么工作量，就直接把旧模板的 `/_plugins`文件夹复制到新模板就不再报错了，当然显示效果需要调整 CSS，下一节会讲到。`{% raw %}{% sidenote %}{% endraw %}` 就可以继续用了。

 至于正文图片，这个功能和 markdown 已有的图片功能重复了，我觉得不值得为了一点点显示效果牺牲可移植性，于是直接把相关组件删除了，然后把博客文章中用到的地方换成了 markdown 插入图片的语法，重复性体力劳动，不提了。

## 调整 CSS

### 新建 `.paper` 取代 `.cover`

![](/photos/2021-12-06-material-card-cover.png)

这个模板主打的一个内容卡片如图所示，很漂亮，但是整个元素的宽度是由封面图片 `.cover` 决定的：

```css
@media (min-width: 1600px) {
    .scroll-1 {
        width: 1200px;
        margin-left: -600px;
    }
    .scroll-1 .card .cover {
        width: 1200px;
    }
}
```

而我的很多博文都是纯文字的，直接不添加图片会有大半个卡片没什么内容，去掉图片区域之后整个卡片的宽度会缩水到文字的最大宽度，丑。解决方法是新建了一个新的类 `.paper`，把 `.cover` 中和宽度相关的设置移动到新的类，然后把新类应用在整个卡片的 `<div />` 上。

```css
@media (min-width: 1600px) {
    .scroll-1 {
        width: 1200px;
        margin-left: -600px;
    }
    .paper {width: 1065px;}
    /* .sidenote {width: 300px;} */
}
```

### 考虑侧边栏的页面宽度响应式布局

响应式布局指的是同一个网页，在不同的终端设备上都又能够有适合的视觉效果，主要方法就是根据不同的屏幕宽度设定某些元素的不同取值：

```css
@media (min-width: 1600px) { /* ... */ }
@media (max-width: 1600px) { /* ... */ }
@media (max-width: 1200px) { /* ... */ }
@media (min-width: 768px) and (max-width: 979px) { /* ... */ }
```

具体到这个博客：

- 屏宽大于一个很大的值之后，博客正文和侧边栏的宽度固定，不再增加；
- 屏幕小于这个值，但是大于能够正常显示侧边栏的宽度时，博客正文和侧边栏都占据给定的百分比；
- 屏幕小于能够正常显示侧边栏的宽度时，侧边栏不再显示，正文宽度固定在之前最小的像素值；
- 正文像素数占据屏幕全部宽度之后，宽度设定为 100%。

## 复习 Liquid，重写非博文页面

非博文页面和之前的布局基本上相同，除了 `/Topics` 从一个无序号列表变成了响应式的两个竖栏。这是得益于模板引用的 `materialize.css`采用了 [flexible grid](https://materializecss.com/grid.html)。

具体来说，一个`container` 可以动态调整内部元素的占宽，以适应不同大小的设备，包含两级子元素，两级子元素顾名思义，分别显示为行和列的元素：

```html
<div class="container">
	<div class="row">
		<div class="col s12 m6 l4"></div>
		<div class="col s12 m6 l4"></div>
	</div>
</div>
```

然后将父元素的宽度分成 12 个基本单位，方便指定某一个元素所占的宽度和高度。比如 `class = "col s12 m6 l4"` 表示该元素在小设备 (small) 上占据 12/12=100% 屏宽，在中设备 (medium) 上占据 6/12 = 50% 屏宽，在大设备 (large) 上占据 4/12=1/3 屏宽。 

### Liquid

Jekyll 本身的编程语言是 Ruby，但是被 Jekyll 编译之前的网页文档中的特殊标记，是一种叫做 Liquid 的领域专用语言。

一般的命令和控制流结构用 `{% raw %}{% %}{% endraw %}` 括起来 

```html
 for i in (1..len1) %}
	 assign idx = i | times: 2 | minus:2 %}
   assign cate = category[idx] %}
 endfor %}
```

直接在网页中显示内容和变量使用 `{% raw %}{{  }}{% endraw %}`

```html
post.title }}
```

函数调用的语法最奇葩，是 `input | function` 或者 `input | function: parameter`：

```html
assign category = site.data.category %}
assign length = category | size %}
assign   len1 = length | plus: 1 | divided_by: 2 %}
assign   len2 = length | divided_by: 2 %}
```

## 调整博文元信息

每篇博文的开头两道分割线之间的 YAML 是绑定在页面上的变量，可以被 Liquid 引用 `{% raw %}{{ post.VAR_NAME }}{% endraw %}`。

```yaml
---
layout:  post
title:   .html | 翻译：为什么说物理不是一门学科
keywords: html
excerpt: 一篇稍微硬核的科普文章，讨论物理在生物学当中的可用性。
date:    2019-06-19
categories: post
milestoneID: 5
---
```

新版本简化了很多，删掉了没有用的 `date`, `categories`, `milestoneID` 字段，同时把 `keywords` 变成了一个数组，也就是说同一篇文章可能出现在多个 `/Topics` 页面的卡片中。

```yaml
---
layout:  post
title:   .en | 翻译：为什么说物理不是一门学科
keywords: [html,inter]
excerpt: 一篇稍微硬核的科普文章，讨论物理在生物学当中的可用性。
---
```

## 下一步计划

- 进一步优化排版:
    - 给博文的标题添加视觉效果，现在的一二级标题之间很难区分。
    - 超链接的样式不够明显，一眼看不出哪里有链接。
    - 侧边注距离正文的距离不合适，CSS 相关参数的效果很奇怪。
    - 现在的 /Links 页面在宽度缩小之后用户头像会和介绍卡片挤到一起去。
    - 网站整体字号在笔记本上比较合适，在台式机上看起来太大了，移动端更大。
- 加入 google analytics
- 欢迎大家提建议。
- 欢迎有独立博客的朋友互相链接。
- ~~本期博文点赞过 5 亿，下篇文章写用 jekyll 在 GitHub Pages 上搭建静态博客的教程。~~



.md | 博客外观现代化升级



## 一

4月初的时候，系秘书转发了一封邮件，耶鲁和斯坦福有两个关于量子计算的学生社团，打算举办为期一周的[线上训练营](https://www.quantumcoalition.io/)，然后在周末举办一个24小时的编程马拉松 ([hackathon](https://en.wikipedia.org/wiki/Hackathon)) 的活动。只要年满18岁就可以参加，并不限定本科生。

整个活动由几家从事量子计算的科技公司赞助，前面的线上训练营基本就是各家轮流上来介绍一下自己家的量子计算平台的使用方法，最后的编程马拉松也由他们每家出一套题，所以这个活动也有在学生和公司之间搭桥，给参与者争取实习机会的目的在里面。参与者可以自由组队，但是在项目提交的的时候每个人只能属于一支队伍。虽然参与者可以参加任意数量的题目，但是每一名参与者最终只能成为一家公司的优胜者。如果预感到自己在某一个项目的赢面比较大，可以在提交之前通知自己参加的其他队伍把自己除名。24小时的时间限制还是比较紧迫的，所以基本上认准一家答题就可以了。

女朋友也收到了一样的邮件，所以理所当然地一起组队。我之前在本科阶段上过一门一学期的量子信息和量子通信课程，内容约等于在量子力学之后再上一个学期的习题课，以及在不讲群论的情况下应用 SU(2) 群，并没有接触过这个活动中会用到的编程语言。女朋友没有上过这门课，基本就是物理专业普通研究生的量子力学水平。周中的线上训练营，我只参加了第一天的，是 Microsoft 的 Quantum Development Kit (QDK) 和 Q# 编程语言相关的，顺便介绍了一下量子计算中很有名的 Deutsch 算法。剩下的讲座我基本上都没有参加，一方面是知道前面的规则之后就懒下来了，另一方面是实验室的工作仍然需要继续，再有就是线上活动实在是太容易摸鱼了没有效率。周五的晚上，女朋友看了一晚上我的量子信息笔记，我看了看 Q# 的语法规则，在台式机上安装了开发环境。以上就是我们参加编程马拉松之前的基础和准备。


## 二

Hackathon 美东时间周六上午10点开始，周日上午10点结束。因为我们只看了 Microsoft 相关的内容，所以直奔[相关题目](https://github.com/quantumcoalition/qchack-microsoft-challenge)。

题目一共分为两部分。

第一部分一共四道题，就像是一般的计算机课程的作业一样，参赛者只需要在举办方写好的主程序文件里的指定区域填入代码，然后运行主办方写好的测试文件检查结果，测试通过即可得分。四道题目要求如下：

1. 判断一个3-5位的2进制数能否被4整除。
2. 判断一个3比特位当中是否至少有两位不同。
3. 同第2题，但是要求量子比特门最多只能使用 3-比特，而且 3-比特门最多使用一次。
4. 给定一个有两种颜色的无向图，判断图当中不含有任何单一颜色的三角形。

第二部分内容比较自由，要求用 Grover's 算法解决一个自己感兴趣的问题，打哪指哪，然后写一篇文章介绍自己的这个项目，并提交相关的代码。根据问题深度(6分)、工具使用(5分)、创新性(4分)、教育价值(5分) 四方面进行评分。


## 三

### I.1.

第一道题最简单，但是我们当时约等于0基础，所以做起来也颇费了一些时间。不过由于我听过第一天的课，知道 `oracle` 在 Q# 编程语言中是一个很重要的概念，所以在题目给出的参考教程 [Quantum Kantas](https://github.com/Microsoft/QuantumKatas/) 里找到了[oracle 相关的教程](https://github.com/microsoft/QuantumKatas/tree/main/tutorials/Oracles)。里面有个名为 `ControlledOnBitString` 的 function，可以根据一串量子比特的取值是否等于一个特定的二值串而对另外一个比特做一个特定的操作。前一天晚上又知道了 `Microsoft.Quantum.Convert` 的 namespace 里有各种数据类型转换的函数，搭配 `IntAsBoolArray`，就做出了第一题的初版。后来看到了更简单的 `ControlledOnInt` 函数，就直接用上了。

### I.2.

第二题的初版是女朋友做的。题目要求是找出是否至少两位不同，这一判断的否定就是三位比特全部相同，所以同样用 `ControlledOnBitString` 函数，然后判断一次全 `true` 一次全 `false`，再把最终结果取反就可以了。但是在做第三题的时候，因为两个题目长得太像了，中间不小心把一个能通过第二题测试但是通不过第三题测试的答案直接覆盖在了第二题上面，懒的改回去了，于是就成了最后提交的版本。

### I.3.

第三题和第二题非常不同。第二题的解决思路中，判断全 `true` 和全 `false`有3个控制位1个输出位，这里用了两次 4-量子比特门，所以第三问需要全新的思路。另外我曾经试过在一个 `operation` 里申请一个新的 `Qubit()` 结果测试报错，因为误解了报错信息，所以误认为除了程序的主 operation 之外不能创建新的 qubit，于是被卡住了。这时候已经来到了下午，实在想不出来又很困，于是去床上躺了一会。半睡半醒之间想到，题目虽然要求输入的量子比特不变，但是我们仍然可以直接改动输入，只要在函数结束之前把对输入的改动全部复原就可以了。于是用 CNOT 门分别作用在 1-2, 1-3 对输入的量子比特上，两个门分别以第2、3号比特为输出。然后用一个 3-bit 门判断2、3号比特是否相同，并输出到结果位上。为了复原第2、3号比特，只需要把 CNOT 在两对比特上分别再用一次就行了。

但是这个结果还是无法通过测试（后来成为了第二题的提交版本），报错的提示信息是使用了超过一次 3-量子比特门——这不是开玩笑吗？于是打开了官方提供的测试文件，发现测试代码计算 3-量子比特门的使用次数的时候，会把用户定义的 3-量子比特门的数量，和 `CCNOT` 门的数量做加法，于是看文档，我们定义的那个 “用一个 3-bit 门判断2、3号比特是否相同，并输出到结果位上” 的操作和 `CCNOT` 门是等价的，于是直接换用 `CCNOT` 门，问题解决。

### I.4.

第四题看起来复杂，但是可以分成三个部分：

1. 找出图中所有的三角形，确定每个三角形的三条边，这一步完全可以用经典算法完成；
2. 创建一个和三角形相同数量的量子比特数列，对每个三角形，把三条边直接带入第二/三题的操作里，结果输入创建的量子比特列中；
3. 判断量子比特列是否全为 `true`，结果输出到整个程序的结果位上。

第一步由女朋友来想我来写（毕竟只有一台电脑有开发环境），难点在于：

1. Q# 语法改变数列值的语法十分难受
    <br>`mutable points = [-1,-1,-1,-1,-1,-1];`
    <br>`set points w/=0..1 <- [0,1];`；
2. 作为一种强类型语言对元组和数列的区分让我这个 python 选手十分蛋疼
    <br>`(Int,Int)`/`Int[]`；
3. 求数列中不重复的值居然不排序不能给出正确结果。
    <br>`let uniquePoints = Arrays.Unique(EqualI,Arrays.Sorted(LessThanI,points));`

这也是唯一一段用上了 `Message()` 函数来 debug 的部分。

第三步就重新回到了第三题暂时敷衍掉的问题：对于在操作中创建的 `Qubit()`/`Qubit[]`，`Reset()`/`ResetAll()` 函数相当于测量，会破坏操作的 adjoint 性质，不测量则（当时的我）没有办法将这个量子比特列复原。

此时已经午夜，我来解决这个问题，女朋友去看第二部分，后来她看完 Grover‘s 算法的教程去睡了，我还在想这个问题。直接把报错信息复制到 Google，找到了一个[论坛里的问答]()，好像是去年微软在其他地方举办的类似活动的。里面只是提到要“uncompute the qubits”，给出的例子用的是旧版本 Q# 的语法，~~没法直接抄~~ 。最终不抱希望地把之前对那个 `Qubit[]` 做过的循环顺序倒过来重做了一遍，诶，您猜怎么着，还是没通过！绝望了！正序重做一边，诶，通过了！为什么为什么为什么？到现在也没弄清楚。

### II.

然后把女朋友叫醒，让她来讲一讲 Grover's 算法。听完之后我的理解是，对于一个 $$f:(0,1)^N \rarr (0,1)$$ 的函数，这个算法可以大概率地找到一个解 $$S\in(0,1)^N$$ 满足 $$f(S)=1$$. 

至于这个函数 $$f$$，之前每一道题都是这样一个函数，当时已经夜里两三点了，实在是没时间再想一个新函数了，于是我们直接就拿复杂度最高的第4题来换个皮。换个什么皮呢？为了这个活动翘掉了这周的[《文明6》联机游戏](barrier-forward-keyboard-mouse-to-another-computer)，然后之前看 YouTuber ["PotatoMcWhiskey"](https://www.youtube.com/user/PotatoMcWhiskey)介绍过[一个 Mod](https://steamcommunity.com/sharedfiles/filedetails/?id=1753346735&searchtext=diplomacy)，里面可以将文明之间的外交关系可视化为无向图，所以，诶嘿嘿嘿……

女朋友写完文稿就睡了，我把文稿改了改，然后和官方对 Grover's 算法的实现缝合了一下。提交的时候，距离截止时间大约还有一个小时。


## 四

之后的周五的时候收到了消息，我们得奖了。优胜者一共6支队伍。从活动结束之后公布的结果看，要想成为优胜，第一部分的4道题必须全部正确，然后第二部分得分在 8-20 分之间。

这个成绩是个什么水平？截止到写这篇文章的此刻，官方题目的 Github 仓库有 80 份 fork，有少数几份 fork 是针对已有的 fork，有可能来自同一队伍，再考虑到可能有些队伍的不同成员分别 fork 了主项目，所以估测 60 支队伍应该是有的，官方给出 6 组优胜者这么一个不零不整的数字，个人猜测是取了前 10%？据主办方在 discord 提供的消息，有一支队伍的第二题成绩高于8分，但是前面没有全对，所以没有得奖；其余队伍的第二题都不超过6分；并不清楚有多少队伍第一题全对，主办方也不打算公布各队的详细成绩。

这大约说明活动的参与者，其成绩基本上符合二八原理——少数人得到的分数，占据了所有参赛者全部得分的大多数。

参加过这个活动之后，我们一下子就从量子计算小白摇身一变，成了优秀人才了？实际上，直到现在，我还是搞不太清楚 oracle 到底是个什么东西，女朋友对量子计算的理解估计比我还差（逃）。美国哲学教授约翰·希尔勒提出过一个叫做[“中文房间”](https://zh.wikipedia.org/wiki/%E4%B8%AD%E6%96%87%E6%88%BF%E9%97%B4)的思想实验，说一个只会说英语的人被关在一间满是汉字字块的房间里，不断从房间外收到写着中文问题的纸条。房间里有一本英文写成的手册，指示如何对输入的汉字进行回复。凭借这个手册，房中人可以在完全不会中文的情况下，与外界进行交流。希尔勒类比外人、房中人、手册，与程序员、计算机、计算机程序，认为房中人不会中文，进而论证计算机不可能通过程序来获得理解力。

希尔勒教授想论证啥是他的事，我倒是对这个类比的本体很感兴趣——如果一个人已经能够熟练运用那个英文写成的汉字使用手册了，我们还能不能，能在多大程度上说他不懂中文呢？就说一般的程序员，工作时间能保证不看 stack overflow 的有几个，所以他们都不会编程？反对中文房间思想实验结论的人，很多都支持用图灵测试超过某一阈值来作为有智能的标志，但是我觉得，智能本身就不是一个非有即无的性质，而是一个连续分布，没有上限的谱。

另一方面，得分名列前茅，和能力名列前茅，又是两回事。本科的时候做建模美赛，我们学校数理金融的一个学神前一年成绩“略有不佳”，没拿到 M 奖，于是我们那年找到了我和风神俩学物理的，准备再次冲击荣誉。巧了这一年的题目正好有一道浴缸放热水的问题，这不就是物理中的扩散方程嘛，那得奖还不是手拿把掐的？结果呢，H 奖，丢人丢到姥姥家去了。合着我们两个成绩还都不错的物理专业学生，在自己的专业里，打不过那么多同龄的非物理专业本科生？

两相对照之下，我想起了很久之前看过的一篇博客文章，文章以一个问题开头——“熟练”的反义词是什么？当然说“生疏”这文章就写不下去了，作者给出的答案是——“应变”。熟练意味着，你对于问题、选项、最优解已经有了充分且完备的了解，只需要重复自己的经验就可以了，但是在自己不了解的战场上，经验至少不能直接派上用场，这时候，脱离具体环境的应变能力就成了生存和取胜的关键，我们当时的专业水平高不成低不就，反而成了掣肘我们的桎梏。

读到这篇文章的时候，我被这种剑走偏锋的观点击中了，从那以后，一直都在注意培养自己的应变能力——如果明天我所研究的这个领域消失了，我还有没有谋生的能力？如果自己正在解决的问题被上帝或者 Matrix 作弊修改成一个新问题，我能不能看到连作弊都改动不了的题眼，然后一击命中？在凌晨两三点的时候，我也没有放弃解决第一题第 4 问的 Qubit 复位问题，虽然当时我并不知道评分标准，但是内心非常确定，这个问题必须解决。

以上两次活动的成绩差别，也可以从得奖难度来看。建模美赛的 M 奖，得奖率应该远小于 10%，即便考虑到二八原理中绝大多数参赛者都只是凑数，而且样本越大凑数者越多，这个差距也还是无法忽略。我们能够得奖，和量子计算领域才刚刚萌芽，连“方兴未艾”都算不上，因此竞争并不激烈也有很大关系，应变能力是切入这些蓝海领域的必要条件，是躲避内卷的利器。我们现在对“内卷”人人喊打，但是培养应变能力是需要牺牲相当多本可以精进专业的时间和精力的。当社会中的大多数人向往着逃离内卷的时候，真的不需要有人咬定一个领域不断深耕？我现在的选择真的正确吗？我不知道。我是打算留在当前的领域继续熟练，还是换个领域应变，抑或是虚掷 PhD 光阴换一张工作签证？我也不知道。

## 五

哦对了，我有女朋友了，而且在 hackathon 的过程中把女朋友惹哭了……问题是我现在已经不记得具体是怎么把人家惹哭的了，连道歉都显得很不诚恳……我确实是一个不擅长合作的人，或者说跟别人说话的我，和想问题的我并不是同一个人，之前本科 CUPT 和建模的时候也一样，需要和人打交道的时候就几乎干不了活儿，严重的时候自己就退化成了鼓励师……总之一切错误在我，希望她不要记仇…… <br>（。・＿・。）ﾉ


.qs | QC Hack 量子编程马拉松

## 为啥要用 `Barrier`

圣诞节前的周五，我们系在线上办了一个聚会。和学姐闲聊的时候，听说他们高年级的几个朋友每周一起联机玩《文明6》，于是一番理(卑)直(躬)气(屈)壮(膝)的要(恳)求之后，成功加入了组织，等到了 steam 的圣诞特惠（没错我一直没买 new frontier pass，我是云玩家），准备以物理学工作者的严谨态度，研究《文明6》诱导的基于回合的反常时间平移对称现象。

![](/photos/2020-12-22-livingroom.png)

我现在公寓房间的结构如图所示，前任房客走的急，把她的几乎全部家具低价甩卖给我了，四舍五入相当于白捡了一台大电视。电视用 HDMI 线连接电脑，当作第二显示器使用。躺在沙发上，看着大屏幕，玩着文明6，[运用自如](https://www.bilibili.com/video/BV1g441187zq)的话说——“那岂不是非！常！爽！”

所以说，我的要求是：

- 在笔记本和台式机处于同一 Wifi 的情况下——
- 笔记本电脑和台式机之间不需要任何数据线连接
- 使用 Linux 笔记本上的触控板、鼠标和键盘
- 控制 Windows 台式机
- 正常运行和操作《文明6》，不会因为延迟卡顿被人喷（卡顿是不存在的，只可能掉线lol）

一番搜索之后，锁定了 `Barrier` 这款软件。它可以设定一个 server 和多个 client，用 server 的输入设备控制各个 client。切换方法也很方便，只要提前约定好各个设备的“相对位置”，当 server 的鼠标光标跨过 server 屏幕的边角处，就开始控制对应方向上的设备。（具体可以查看下一节。）

之所以选择它，主要原因如下：

- [开源软件](https://github.com/debauchee/barrier)，堂堂正正地不用花钱。（我知道开源软件≠免费软件，但是……）
- 目前依然有人维护，GutHub 上还有上百个 open issues，当然 closed issues 更多，有问题可以查，提问也有人回答。
- 跨平台，Windows 和 Linux 都能用。主流 Linux 发行版都可以在仓库里找到，也可以通过 snap 安装。

## 如何配置 `Barrier`

### 下载和安装：

因为我的发行版是 Fedora，在笔记本的 terminal 上任选一句运行：

```shell

sudo dnf install barrier
sudo snap install barrier
```

台式机是 Windows 10，在GitHub 项目（[链接在此](https://github.com/debauchee/barrier/releases)）里找到最新一期的发布版本，找到 `.exe` 结尾的文件（可以用浏览器的页内搜索），下载，双击下载后的文件安装。

### 配置 server （笔记本电脑）：

首先要确定 linux 的桌面环境是基于 xorg 的，当前版本的 GNOME 默认使用的是 Wayland，所以需要 log out 之后重新选择带有 xorg 字样的环境，如下图：

![](/photos/2020-12-22-gnome-environments-new.png)

安装完成之后，在 app 界面（`Win`+`A`）应该可以找到 barrier 的图标，单击即运行。一般来说之后会有相当长一段时间电脑没有反应，这个时候 **千万不要重复点击图标**，会导致无法连接。

![](/photos/2020-12-22-barrier_linux_desktop.png)

之后会看到软件的主界面，选中图中所示的选项：

![](/photos/2020-12-22-barrier_linux_start.png)

然后单击 `configure server` 按钮，进入下图的界面，拖动右上角的电脑屏幕图标，拖到中间屏幕周围的任意一格。我选了右边一格，因为这样在笔记本上向右滑鼠标会进入台式机的显示器，从显示器右边框向右会进入电视，一路反过来就回到了笔记本屏幕，操作比较自然。

![](/photos/2020-12-22-barrier_linux_config.png)

双击图标后会弹出一个新窗口，在最上面的 "screen name" 栏填入 client 上显示的本机名称，现在我们还没有配置 client，所以需要等到配置完之后回来填写。

![](/photos/2020-12-22-barrier_linux_naming.png)

注意主窗口的左下角，如果不是 “barrier is running” 的话，需要点击右下方的 reload，还是不行的话就要准备 debug 了。

### 配置 client （台式机）：

安装完成之后，应该能在开始菜单里找到 barrier 的图标，点击运行，应该会看到和笔记本上面差不多的界面。

![](/photos/2020-12-22-barrier_windows_main.png)

选择图中的选项，填入笔记本窗口中显示的本机 IP 地址，选中 `auto config` 选项，然后点击右下方的 `start`，然后窗口左下角同样应该有 "barrier is running" 字样。点击菜单栏里的  -> `show log` 打开日志，应该可以看到下图里的 "connected to server" 字样。

![](/photos/2020-12-22-barrier_windows_log.png)

### 几个雷点：

- Fedora 的显示管理器默认并不使用 xorg，需要专门切换。
- Linux 上启动较慢，如果不耐烦多点了几次，可能会重复打开多个实例，造成端口被占用，无法使用。
    + 诊断方法：打开 log 界面，会发现 "ERROR: cannot listen for clients: cannot bind address: Address already in use"  字样。
    + 解决方法：杀掉多余的进程，不会杀的话就重启电脑吧。
- server 和各个 client 对是否使用 SSL 的选择必须是一致的。
- 官方没有按步骤来的配置说明，这么多雷点，我居然看到好几篇博客都在夸 barrier 的界面多么通俗易懂，简直了。 

## `Barrier` 之外的其他方案

- `synergy`：成熟的商业软件，好像要花钱。
- `Microsoft Garage Mouse without Borders`：要求所有设备都使用 Windows 系统，不适用于我的笔记本电脑
- `usbip`：来自 farseerfc 大神的[这篇博文](https://farseerfc.me/zhs/usbip-forward-raspberrypi.html)，原文说“设置好的话，就像是一台 PC 多了几个位于树莓派上的 USB 端口，插上树莓派的 USB 设备统统作为 PC 的设备”。
    + 和 `Barrier` 相比，配置的步骤更繁琐；
    + 好像一次只能控制一台设备（不太懂，如果转发给多个设备的话可能会一起执行相同的操作？）；
    + 好像也不适用于非 USB 接口的设备，比如笔记本的原生键盘和触屏笔；
    + 一旦运行起来，server 的鼠标就不再能够控制自己，所以原文使用了几乎注定吃灰的树莓派，相当于给键盘加了个广播天线。

.md | 扫盲Barrier，用笔记本键鼠无线控制台式机


前两天看果壳，推送的头条是《古代雕塑的丁丁真的都（像大卫）那么小吗？》，为了立论，作者根据图片测量了大卫像的丁丁长度，虽不十分精确，但是好歹有个定量的结果——“4厘米不到”，还给出了使用的工具——ImageJ。

![](/photos/2020-04-25_guokr-quote.png)

怎么做到的，咱也来试试？

## `ImageJ` 是啥？

上一篇文章（[《“你这是不是原图直出啊？”》](raw-image-or-not)）我们提到了，专业相机可以记录 RAW 格式的图片，这类图片包含的信息比平时常见的图片更多，也需要专门的软件进行处理。不只是消费者水平的相机，实验室里的显微镜、CT机都可以看作是特殊的照相机，它们产生的图像自然也需要专业的软件来读取和处理。

ImageJ 就是这样一款软件。相比于直接使用编程语言（比如 MATLAB，python 的 scikit-image 模块），它提供的方框、多边形、椭圆选区工具，直接用编程语言来替代的话要麻烦许多；而且各种操作的结果都可以几乎实时地反馈在画面上，不需要一遍又一遍地 `imshow()`。

ImageJ 用 Java 写成，所以跨平台的表现一致，~~用户界面有一股浓郁的 Windows 95 风味，而且在 MacOS 上也一样，Windows 用户幸灾乐祸中~~。代码开源在 GitHub，免费，能让用户知道自己的每个操作究竟在干啥，而且可以自己开发拓展功能，打包成第三方的发行版。我们今天要用的 Fiji，就是一个集成了很多常见拓展功能的 ImageJ 发行版。

## 具体怎么量？

先简单列举一下步骤，详细介绍在后面：

- 下载大卫像的正面照。
- 运行 `ImageJ`，打开图片。
- 复制图片，防止我们的操作改变原始数据。
- 用矩形选择框选定大卫像从头到脚的区域，记录选择框的高度。
- 用 `Analyze -> Set Scale` 工具确定像素和厘米的换算关系。
- 用直线工具画出要测量的距离，从主面板读取长度。
- 用 `Analyze -> Tools -> Scale Bar...` 绘制比例尺。

如果你看到这么简略的介绍就能脑补出如何操作，那么就可以 ~~（关掉这篇文章）~~ 跳过下面的详细介绍了。

我们使用的照片来自维基百科的“大卫像”汉语词条，图片作者是 Jörg Bittner Unna，根据 CC-BY-3.0 协议共享。我们下载的是中等尺寸（480×720）的图片：

![](/photos/2020-04-25-david.jpg)

鼠标右键单击画中的任意一点，在弹出的菜单中选择 `Duplicate`，在对话框中选确定，这样我们就得到一张原图的副本。之后的所有操作都在这个副本上进行，这样即便有任何操作失误，对副本做出了不可逆转的伤害，都不会影响到我们的原始数据。如果数据的安全和完整得不到保证，无意之失叫做学术错误，有意为之叫做学术造假。

选择工具栏中的矩形选择框（图中主面板左一的阴影按钮），在图中画出一个矩形，上下边分别是大卫像的头顶和脚底，**画完后鼠标不要乱动**，然后在主面板的底部读出高度 `h=595`，此处的单位是像素：

![](/photos/2020-04-25_find-height.png)

点击主面板的 `Analyze` 按钮，在下拉菜单中找到 `Set Scale`，在弹出的对话框中，`Distance in pixels` 填入我们读出的 595 像素，`Known distance` 和 `Unit of length` 填入作者假设的 150 cm：

![](/photos/2020-04-25_set-scale.png)

然后就可以开始正式的测量了。再次使用矩形选择工具，**画完后鼠标不要乱动**，主面板底端的 `length=20.93` 就是以 cm 为单位的距离了：

![](/photos/2020-04-25_measure-head.png)

丁丁可以选中直线工具（左起第五个），用鼠标拖拽的方法画线，主面版的底端也会显示结果。

量完之后，要想方便他人，可以在图上画出比例尺。再次点击主面板的 `Analyze` 按钮，在下拉菜单中找到 `Tools`，然后找到 `Set Scale`，在弹出的对话框里选择合适的选项，然后点击确定，就可以在画面中添加一个比例尺：

![](/photos/2020-04-25_menu-scale-bar.png)

如果对操作满意的话，就可以保存图片了。~~（我对这个结果不满意，所以直接没有保存就退出了。）~~ 原图没有改动，可以直接关闭，软件应该也不会发表反对 ~~（通知书）~~ 对话框。

## 量出来个几？

我们的截图显示，按照 150 厘米的身高，大卫的头颅对应的长度是 20.92 厘米。

对于丁丁，由于图片中的阴影部分对起止点的认定有很大的干扰作用，几次测量的结果都不相同，最小值是 3.91 厘米，最大值是 4.45 厘米。

## 这么量对吗？

我们的结果和原文有一定不同，但处于同一数量级 ~~（废话）~~。由于原文并没有介绍自己使用的数据来源，原文中的图片本身并不适合测量这个数据（下面会讨论），而且还给关键区域加了遮挡，所以我们无从比较两个结果的差异。

对于我们自己的测量，我们可以对如下几个误差来源进行讨论：

- 相机视差
- 深度误差
- 关于大卫身高的假设

### 相机视差

我们在几何光学里学的相机成的是倒立的实像，物高和像高之间的关系按照牛顿公式取决于物距、像距、透镜的焦距等等知识，都用到了“傍轴条件”这一假设。换句话说，考虑的都是理想状态，要想满足这种理想状态，基本相当于要求镜片的直径无限大，厚度无限小，焦距还可以是任意值。

我们的相机显然不满足这种理想状态（简单证明，理想状态下大卫像和后面的墙壁显然不可能同时被同一个透镜组严格地在同一个平面上成像）。景深范围内，不同深度的物体都可以在图中成像，但是存在着透视关系。同样长度的物体，在不同的深度下，在图片上的成像的长度不同；在画面中央的长度，和在画面边缘时的成像长度也不同。B 站里的摄影师们拍小姐姐的时候，脸尽量靠近画面中间，腿一般出现在画面边缘，就是利用广角镜头的透视效应。

我们的照片目测是用中长焦镜头拍摄的，透视变形不是很明显，但是在测量雕像身高的时候还是遇到了困难，我们用的是脚尖到头顶的距离，如果取脚的中间的话结果就会短一些。

### 深度误差

我们的照片是二维的，所以之前的测量，相当于假设被测距离的起点和终点在同一深度上。如果两点之间有一个深度差，那么测量线、深度差、实际距离三条线会构成一个直角三角形，实际距离需要按照勾股定理进行计算。我们这里得不到深度差，所以这一误差就成了一个系统误差，而且是有偏 (biased) 的，真实结果不小于测量值。

我们选取的照片几乎平视着整座雕像，尤其是我们比较关注的部位，所以深度差几乎可以忽略；果壳提供的图片是仰视的，所以如果这就是测量所用的照片的话，误差应该比我们更大。当然了，还是由于作者没有公布数据和方法，以及原文中图片有马赛克，这种比较没有意义。

### 关于大卫身高的假设

开头的文章截图已经给出了将大卫像对应的身高定为 150 cm 的理由，我们来看一下，这个理由成立吗？

文中说“这相当于现代12岁男童的平均身高”，但是米开朗基罗真的是以 12 岁的人体为原型来创作的吗？我们为什么量了一下大卫的头高呢？是为了算头身比。大卫像头身比是 1:7.5，这已经几乎是一个成年人的比例了。艺术作品为了凸显对象的某些特点和气质，某些特点不符合原型的设定，这在艺术上是完全可能而且可以接受的。《红楼梦》书中的绣像，后来的电视剧中演员的服化道，几乎都比原书的年龄设定更成熟。

像是某一器官的大小，其衡量标准应该是相对于某个基准的（比如体长）的比值，也就是一个无量纲的量。像是4厘米这种带有长度量纲的量，虽然的确是能比一个比例更容易让人有直观的感受，但是结论很容易因为对身高的质疑而动摇。

最后，我觉得最致命的一个问题是，大卫像其实是文艺复兴时期的作品，和罗马仿希腊的艺术品一样，是一个其他文明模仿希腊的产物，而且模仿的过程中融入了很多近代人文主义的精神。这一题材也并非来自于希腊文化，大卫击杀歌利亚是犹太教-基督教文化中的故事。在这种情况下，作者应该额外论证文艺复兴对丁丁的描写照搬了希腊文化的习俗。既然如此，为什么不直接找一个古希腊时期的古希腊作品呢？

而且原文中有“你也许会说大卫像也许只是一个个例，万一只是米开朗基罗的恶趣味呢？一个例子不能说明古希腊雕塑里的小丁丁都很小”字样，不好意思，米开朗琪罗的作品不是古希腊雕塑的“一个例子”。

## 课后作业

![](/photos/2020-04-25_horseman.jpg)

上图是法国画家雅克-路易·大卫的作品《跨越阿尔卑斯山圣伯纳隘道的拿破仑》，请根据该作品完成下列题目：

1. 请寻找资料估测马的体长，并据此估测拿破仑的身高。
2. 请寻找拿破仑身高相关的史料，并据此估测马的体长。
3. 比较前两题的结果。

啥？你说拿破仑当时骑的是一头驴？哦，那没事了，下课！


.ijm | 用 ImageJ 给大卫量尺寸


> 这是一篇速记，相当于实验的原始记录。日后有可能根据这些记录，整理出一些心得体会，或者全流程的教程。

第四代树莓派（[Raspberry Pi 4](https://www.raspberrypi.org/products/raspberry-pi-4-model-b/)）刚刚推出的时候，脑子一热买了一台。作为一台计算机，只用原装的操作系统有点咸鱼了，所以打算安装 Linux 的一款发行版。既然要追求刺激，那就贯彻到底咯，于是就决定挑战一下 Arch Linux。 ~~（反正早晚也要吃灰）~~

既然要挑战一个很有挑战性的操作系统，那么先在虚拟机里试试水就很有必要了。（后来才发现用这个虚拟机往树莓派里写操作系统，也是官方比较推荐的一种安装方式。）于是就开始了这篇速记中的一系列折腾。

## 我的硬件和软件配置

* **硬件**：蓝厂 CPU、绿厂显卡、2*8 GiB 内存、小 SSD + 大 HDD 硬盘、iTX 主板，机龄不到两年，日常可以流畅使用。
* **物理机操作系统**：Windows 10 Pro
* **虚拟机控制软件**：VirtualBox 6.10，短暂用过 5.12 版本
* **虚拟机镜像文件**：Arch Linux 2019.08.01, Windows 10, Fedora 30 Workstation

## 虚拟机托管软件 VirtualBox

可以看一下编程随想的博客里的 [系列文章](https://program-think.blogspot.com/2012/10/system-vm-0.html)。

我的手头一直有虚拟机托管软件，但是没有编程随想那样的需求，平时几乎用不到。（用虚拟机学 Linux？你可拉倒吧）不过之前很轻松地装过一些 Linux 的发行版，主要是 Fedora，所以没觉得这部分会有什么问题，直接开始了主线任务：下载 Arch Linux 的安装 ISO 镜像、检查校验和（FCIV，教程可以看 [这里](https://program-think.blogspot.com/2013/02/file-integrity-check.html)）、按照官网 [安装指南](https://wiki.archlinux.org/index.php/Installation_guide)（[中文](https://wiki.archlinux.org/index.php/Installation_guide_(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87))）操作，然后发现虚拟机连不上网 :-(

### 问题：虚拟机无法通过 NAT 或 NAT Network 模式联网

具体表现为 `ping www.google.com` 报错：

``` bash
> ping archlinux.org
# Temporary failure in name resolution
```

此时的网络设置没有修改过，就是几乎没有可选参数的 NAT 模式。

第一反应当然是把报错的信息直接复制粘贴到 Google 里，然后看到了 [这个帖子](https://bbs.archlinux.org/viewtopic.php?id=237461)。

回答用一种很有礼貌的方式表述了 RTFM，并给出了官方的 [Network Configuration 页面](https://wiki.archlinux.org/index.php/Network_configuration)。

按照这个页面的步骤，因为我的 ISP 给的是动态的 IP，需要用DHCP，DHCP 是啥我都不知道，搞得我跪着下载了编程随想书单里的《Richard Stevens TCP-IP 详解》，解压后看着 3 卷一百多个 PDF 文件，默默关上了资源管理器……

继续变换关键词搜索解决方案，在这期间改动过防火墙设置，又重置了一次；重装了两次旧版本 VirtualBox，因为第一次重装忘记删除配置信息（Windows 10 Pro 在 `%userprofile%\.virtualbox`，见[这个帖子](https://superuser.com/a/1429931)）；另外装了 Windows 10 和 Fedora 30 两个虚拟机；找来一个玩过 VirtualBox 而且打包票能解决问题的同学。确定了和虚拟机中的操作系统无关，VirtualBox 的 Bridge 桥接模式是可以联网的，但是总不能放任虚拟机的重要联网功能残废着啊 ~~（何况 NAT 模式在多重代理中不可或缺）~~，还是一筹莫展。

就在折腾了这么几天之后，Windows 推送了一次更新，神奇的一幕发生了！更新之后，不论是 NAT 还是 NAT Network 模式，虚拟机都能正常上网，所以，可能真的是“天下本无事，庸人自扰之”吧……

**解决方法：~~吃饭睡觉打豆豆~~**

## 安装 Arch Linux

继续按照官方指南进行安装，不得不说这份指南写的真的不好，至少对于新手是不友好的。一个典型的例子就是下面这句：

> 你需要安装 Linux 引导程序以在安装后启动系统，你可以使用的的引导程序在 [启动加载器]() 中，请选择一个并且安装并配置它，比如 [GRUB]()。

你该怎么办？公布一下正确答案：点击 `GRUB` 那个链接，在一众分类中找到适用于你的计算机配置的那一节，目力忽略各种介绍，找到那一两行有用的命令。ε=( o｀ω′)ノ

反正单看这一句，以我的理解能力，我是没办法正常通关，于是就有了下面硬盘格式化的问题。

### 问题：硬盘格式化不正确

我是用 fdisk 进行的硬盘分区，在正常模式之下似乎找不到选择分区类型的选项，所以我的 EFI 分区也被当作了 Linux 文件系统，所以在很多个步骤之后报错，具体的报错信息已经不记得了。

还好在编程随想的博客的评论区里见到过萌狼，一个 Arch Linux 用户，顺手去他家的博客逛了逛，知道他写过一系列关于 Arch 的博客。所以找到了《给 GNU/Linux 萌新的 Arch Linux 安装指南》，于是直接重建了一个空白虚拟机，按照新教程的流程走了一遍。

**解决方法：看[萌狼的安装教程](https://blog.yoitsu.moe/arch-linux/installing_arch_linux_for_complete_newbies.html)，用 cgdisk 分区**

### 问题：开机后显示 UEFI interactive shell

本以为万事大吉，结果卸载掉安装 ISO 之后开机，总是会进入 UEFI interactive shell。输入 `exit` 之后重新开始倒计时，然后再次进入这个 shell……

就在写这篇速记的时候，我找到了官方 wiki 的 [这个条目](https://wiki.archlinux.org/index.php/GRUB_(%E7%AE%80%E4%BD%93%E4%B8%AD%E6%96%87)#%E5%90%AF%E5%8A%A8%E6%97%B6%E8%BF%9B%E5%85%A5%E4%BA%86%E6%95%91%E6%80%A5%E6%8E%A7%E5%88%B6%E5%8F%B0)，理论上应该是针对这个问题的，但是看一下就知道，并没有提供可操作的解决方案。

通过 STFW，找到了这篇文章：《[如何在 VirtualBox 内安装 Arch Linux](https://cli.ee/archlinux-virtualbox)》，里面提到这个问题是由 VirtualBox 的 UEFI 引起的，同时提供了解决方法：

```bash

Shell> bcfg boot dump -v              # 查看启动的菜单
Shell> bcfg boot rm 0                 # 删除光驱启动目录
Shell> fs0:                           # 进入 EFI 分区
FS0:\> ls                             # 查看目录，可以看到 EFI 目录
FS0:\> mkdir EFI\boot                 # 在 EFI 目录下创建子目录
FS0:\> ls EFI                         # 查看 EFI 目录，确认是否已创建子目录 boot
FS0:\> cp EFI\grub\grubx64.efi EFI\boot\bootx64.efi # 复制 efi 文件并重命名
FS0:\> exit                           # 退出
```

执行完这一步，开机之后就可以看到 GRUB 的选择操作系统的界面了，因为只安装了 Arch Linux，我们只能看到两个选项，一个 `Arch Linux` 正常启动，一个 `Advanced Options for Arch Linux`。

### 问题：开机后无法进入图形界面

本以为万事大吉，结果开机之后选择 `*Arch Linux` 选项，屏幕上只剩下两行字，然后没有其他反应。

同样是上网搜了一下，发现如果按下 `Ctrl + Atl + F2` 是可以进入命令行模式的，随便执行了几个命令，发现系统工作正常。用 `journalctl` 看一下系统日志，发现在最后一段里经常出现高亮的几行里面，都有 `drm` 这个关键词，再次搜索，发现是和显卡相关的。因为是在虚拟机里，所以就去 VirtualBox 里康康有啥可能会导致问题的选项。

**解决方法：在 VirtualBox 的虚拟机显示设置界面，禁用3D加速**

<hr class="slender">

至此，所有的坑都已经踩完了，开机之后可以看到正常的登录界面，Duang~Duang~~~

![](/photos/arch.png)

2022 年 7 月 8 日.py | python.subprocess执行bash命令mdpy

.py | python.subprocess执行bash命令

.pyPython 学习笔记

.mdIT类业余笔记