# 前言
书接上回，python中官方提供的正则表达式库为`re`，引入项目只需要
```python
import re
```
但是`re`仅仅支持一些基础的正则表达式语法，对于高级的扩展语法并没有支持。但是第三方库`regex`对这些提供了支持。安装`regex`需要
```shell
pip install regex
```
然后在项目中引入即可使用
```python
import regex
```



# 正则表达式扩展语法
## 递归
如果希望匹配嵌套的括号，如
```
aaa{bbb{ccc}}
```
如果仅仅匹配`{}`，匹配将会在第一个`}`停止，得到`{bbb{ccc}`。显然这并不是期望的结果，因而排除中间的括号
```python
r'{[^{}]*}'
```
这样就不会出现括号不完整的情况了，然而如此就仅仅能匹配到一个括号，无法匹配到括号嵌套的文本，如
```
{aaa} {bbb} ...
```
是可以被匹配到的，但是`{aaa{bbb}}`是不能被匹配的

对于这种嵌套的结构，应该采取递归的方法
```python
r'{([^{}]+|(?0))*}'
```
下面做必要的解释说明
- 最外面的`{...}`匹配一对大括号
- 大括号内部的`(...)*`定义了一个捕获组，并允许它重复多次
- 捕获组内部由`|`分为两段分支
  - `[^{}]+`匹配了不含括号的非空字符串
  - `(?0)`递归调用整个正则表达式

思路可以分析如下。首先定义了一个基本的单元
```
{[^{}]+}
```
它匹配一对无嵌套的大括号。若希望令它可以嵌套自身，引入递归
```
{[^{}]+|(?0)}
```
这样它就能匹配`{{aaa}}`这样的嵌套大括号了，但是它并不能匹配`{aaa{bbb}ccc}`这样的字符串，因为这个正则表达式要求大括号内部是不含括号的部分或是另一对大括号，并不允许这两种情况同时出现，因而需要允许内部结果重复
```
{([^{}]+|(?0))*}
```
在匹配`{aaa{bbb}}`这个字符串时，大括号被正则表达式最外层的`{}`匹配上，内部的字符串需要满足的条件为
```
([^{}]+|(?0))*
```
而`aaa`满足`[^{}]+`，`{bbb}`满足`(?0)`，它们都能满足`([^{}]+|(?0))`，那么`aaa{bbb}`就能满足该捕获组的重复

如此就实现了嵌套大括号的匹配

正则表达式在regex中的使用（二）

# 前言
由于 [神里绫华的狗](https://神里绫华的狗.top) 上的内容都是使用`Latex`编写的，无论是发表在本站还是知乎等平台，都需要将`Latex`转为`markdown`语法。由于简单情况下两者语法接近，并且`markdown`也支持使用`latex`的公式，这个转换无非就是做一些字符串的替换，估摸着应该也不是很难的样子。

但是实际写起来并不是那么简单。比如要把`Latex`的公式符号`\[`替换为`$$`，同时也会影响换行标记
```latex
\\[1em]
```
要实现这样的判断，简单的字符串匹配是做不到的，需要使用**正则表达式**。



# 简单的正则表达式语法
在开始之前，首先需要插一嘴，在python中，有一种字符串是这样写的
```python
r'abcd\n'
```
前面加一个`r`意为后面的字符串就是它字面意义上的意思，不进行转义。像这里`\n`就不是换行符的意思，它真的是一个斜杠`\`和一个`n`。由于正则表达式是需要转义的，如果不这样书写字符串就要转义两次，想想都蛋疼。
## 匹配
最简单的匹配当然是之间匹配字符串本身
```python
r'abcd'
```
这就是匹配`abcd`，与普通的字符串匹配没什么两样。
### 通配符
正则表达式中存在通配符`.`，它代表着任意的**单个字符**。注意它只是一个字符，并不像平常用的`*`一样可以代表任意字符串。比如
```
'abcde'
```
正则表达式`r'.'`的匹配结果将会是一个列表
```python
['a','b','c','d','e']
```
### 字符集
字符集用中括号`[]`表示。字符集也只是**代表一个字符**，并不是字符串。字符集的作用是匹配中括号中的任意一个字符，如
```python
‘abc adc aec’
```
用正则表达式`r'a[be]c'`匹配的结果就是
```python
['abc','aec']
```
在字符集的开头加上`^`构成否定字符集`[^]`，即匹配不是括号中的任意一个字符，如
```python
'abc adc aec'
```
用正则表达式`r'a[^be]c'`匹配的结果就是
```python
'adc'
```
字符集还可以指定范围，如
```python
r'[a-f]'
```
等效于`r'[abcdef]'`。数字也适用
```python
r'[1-5]'
```
它等价于`r'[12345]'`。字符集可以组合使用，如
```python
r'[a-f1-5xyz]'
```
它匹配满足以下三种情况的**一个字符**：在`a-f`中，或是在`1-5`中，或是`x,y,z`中的一个
### 字符的重复
前面提到的字符集只能匹配一个字符，将单个字符组成字符串需要用到重复

简单的重复是`*`,`+`,`?`。
- `*`意为前面的字符可以出现0次或更多次
- `+`意为前面的字符串可以出现1次或更多次
- `?`意为前面的字符串可以出现0次或1次

如正则表达式`go*gle`可以匹配`ggle`而`go+gle`不可以

高级一些的方法是用大括号`{}`。当大括号中只有一个数时它代表着前面字符出现的数目，如
```python
r'go{2}gle`
```
就等价于`r'google`

当大括号中有两个数字时，就代表着前面字符出现的数目范围
```python
r'go{2,4}gle`
```
代表着中间的字母`o`出现2次，3次或4次，所能匹配的全部字符串就是
```
google gooogle goooogle
```
如果不填，则代表对次数没有要求，如
```python
r'go{1,}gle`
```
要求中间的`o`最少出现一次，最多出现任意次，中间爱有几个就有几个，这等效于`go+gle`

## 捕获组
捕获组由括号组成`()`，括号中是一个正则表达式，就像这样
```python
r'(abc)`
```
为什么需要捕获组？引入捕获组的一大目的是**引用**！如
```python
r'(.+)-\1`
```
这个正则表达式中，`\1`代表着第一个捕获组匹配上的内容，因而这个正则表达式匹配的结果形为
```
water-water gbwater-gbwater ...
```
引入捕获组的另一个目的是便于表示字符串。正则表达式中的内容都是匹配字符的，如果要匹配字符串需要在正则表达式中嵌套正则表达式，如
```python
r'(.*)(water)'
```
虽然它的作用与`.*water`完全相同，但是如此一来，该正则表达式就从匹配字符变为了匹配两个字符串。这样正则表达式就可以**模块化**设计了。如果仅仅是为了模块化，并不需要捕获，可以像下面这样写，称为**非捕获组**
```python
r'(?:abc)`
```
该捕获组匹配的字符串不可被引用，引用时不计入编号
## 分支
一个正则表达式有多个分支，用竖线`|`表示。如
```python
r'{a-z}+|{0-9}+|{A-Z}+`
```
匹配三种字符串：完全由小写字母`a-z`组成的，或完全由数字`0-9`组成的，或完全由大写字母`A-Z`组成的

结合捕获组的模块化，可以设计复杂的正则表达式，如
```python
r'(神里绫华|流萤酱|芙芙)的狗`
```
将会匹配
```python
['神里绫华的狗','流萤酱的狗','芙芙的狗']
```
## 位置匹配
利用`^`可以匹配行首，如下面的正则表达式
```python
r'^(神里绫华|芙芙)的狗'
```
对于字符串
```
神里绫华的狗也是芙芙的狗
```
将只会匹配到`神里绫华的狗`

同样利用`$`可以匹配行尾。如果上面的正则表达式这样写
```python
r'(神里绫华|芙芙)的狗$'
```
对于同样的字符串，就只能匹配到`芙芙的狗`

## 转义
### 符号转义
对于如`+`，`*`，`|`等被正则表达式占用的符号，需要使用时用反斜杠`\`进行转义。特别地，想要打出`\`也需要转义
```python
r'\\'
```
### 特殊转义
一些特殊转义可以被列举如下
- `\w`代表一个可以组成单词的字符，包括大写字母`A-Z`，小写字母`a-z`和下划线`_`
- `\W`代表一个不能组成单词的字符，就是`\w`字符集的补集
- `\d`代表一个数字字符
- `\D`代表一个不是数字的字符
- `\s`代表一个空白字符，包括空格` `，制表符`\t`和换行符`\n`
- `\S`代表一个非空白字符，就是补集

## 断言
有时我们会想让字符串前面或是后面具有一些字符串，但是又不想这些字符串被匹配进去。如
```
我是神里绫华的狗
```
我希望提取出这是谁的狗，但是不想一并提取出`我是`和`的狗`，就需要使用**断言**

断言分为正向断言和负向断言，先行断言和后行断言
### 正向先行断言
正向先行断言为`(?=)`，一个例子为
```python
r'(?=我是)(.+)'
```
它将匹配以`我是`**开头**的字符串，如`我是神里绫华的狗`就会匹配到`神里绫华的狗`
### 正向后行断言
正向后行断言为`(?<=)`，一个例子为
```python
r'(.+)(?<=的狗`
```
它将匹配以`的狗`**结尾**的字符串，如`我是神里绫华的狗`就会匹配到`我是神里绫华`

### 反向先行断言
反向先行断言为`(?!)`，一个例子为
```python
r'(?!我不是)神里绫华(.+)'
```
它将匹配不以`我不是`**开头**的字符串，如`我不是神里绫华的狗`将不会被匹配到

### 反向后行断言
反向先后断言为`(?<!)`，一个例子为
```python
r'(.+)芙芙(?<!嘿嘿嘿)'
```
它将匹配不以`嘿嘿嘿`**结尾**的字符串，如`嘿嘿芙芙嘿嘿嘿`将不会被匹配到
## 贪婪匹配与懒惰匹配
正则表达式默认为贪婪匹配，即尽可能匹配最多的内容。若需要切换为懒惰匹配，可以在字符前加上`?`，这样前面的匹配内容就会在该字符第一次被匹配到是停止扩展。如
```
芙芙嘿嘿嘿嘿嘿
```
在使用正则表达式
```python
r'(.*)嘿
```
将会匹配到整个字符串；而使用下面这个正则表达式
```python
r'(.*)?嘿
```
就只会匹配到`芙芙`

正则表达式在regex中的使用（一）

# 前言
在写代码自动化生成 [神里绫华的狗](https://神里绫华的狗.top) 的页面内容时，忽然发现网页返回了`403`，也就是权限不够，特此记录重新复习一下Linux的权限系统




# 文件权限的查看
权限的查看使用`ls`命令即可
```shell
ls -l
```
该命令会列出当前目录下所有文件的权限信息，就比如我在home下执行是这个样子（为了保密盖住了服务器信息）

![image.png](/static/img/63e73640f280cd65fcc58971f2a130ae.image.webp)

注意到第一列
``` shell
drwxrwxr-x
drwxrwxr-x
-rw-rw-r--
-rw-rw-r--
```
是文件或者文件夹的权限，它一共有十位，第一位指示文件的类型是文件还是文件夹，后面九位是文件的具体权限

若第一位为`d`则为文件夹，若为`-`则为文件。后面的九位可以分为三组，分别代表
```shell
文件所属用户 文件所属组 其他用户
```
的权限。如
```shell
drwxrwxr-x
```
代表这是一个文件夹，并且它的权限是这样的
```shell
文件所属用户rwx 文件所属组rwx 其他用户r-x
```
其中`r`代表可读，`w`代表可写，`x`代表可执行。那么这个的意思是，对于所有者和所属用户组的用户该文件可读可写可执行，对于其他用户，该文件仅可读与执行

# 文件权限的修改
## chmod的简单使用方法
文件权限的修改需要用到`chmod`命令
```shell
chmod <users> <+/-> <permissions> <filename>
```
其中`users`可以有如下组合
- `u` 是文件所属用户
- `g` 是文件所属用户组
- `o` 是其他用户
- `a` 是所有用户

`+`代表添加权限，`-`代表减少权限。权限的写法与上文展示的相同
- `r` 读权限
- `w` 写权限
- `x` 执行权限

具体的例子如
```shell
chmod ug +rw index.html
```
意为`index.html`的所属用户与所属组添加读写的权限

## chmod的高级使用方法
实际上，Linux的权限系统是用二进制表示的，`rwx`合并为一个三位二进制数，`1`代表具有权限，`0`代表没有权限

如一个用户具有读写权限但没有可执行权限，即他的权限是`rw-`，那么用二进制表示为
```shell
110
```
也就是十进制数`6`，三个这样的数组合就得到了一个文件对所有用户的权限，如
```shell
777
```
意为该文件对所有用户的权限都是`rwx`，也就是可读可写可执行，而`700`就是仅有文件所有者可读可写可执行，其他用户不具有任何权限

用这种方式表示权限非常简洁，chmod也支持使用这种方式
```shell
chmod 777 index.html
```
意为给`index.html`赋予权限`777`

:::warning
赋予`777`权限是一种相当危险的行为，这意味着该文件**受到所有人的控制**并可以**被所有人执行**。随意地赋予`777`权限可能会导致系统崩溃
:::

# 修改文件所属用户与所属用户组
进行该操作需要使用`chown`命令
```shell
chown <user>:<group> <filename>
```
如更改所属用户
```shell
chown user index.html
```
可以将`index.html`的所属用户改为`user`，修改用户组也是同样的方式
```
chown :group index.html
```
当然也可以同时修改
```shell
chown user:group index.html
```
# 其他说明
## nginx对文件权限的要求
`nginx`要求可以通过网络请求访问的文件必须具有可执行权限`x`，否则就会出现`403`错误。修正该错误的方式是根据`nginx`的执行用户赋予文件相应的可执行权限，这也是文章开头提到的出现`403`错误的原因

## 应用到所有子文件夹
对于以上的所有命令，都可以加上`-R`参数，使该修改能递归应用到文件夹的所有子文件和子文件夹

完结撒花 *★,°*:.☆(￣▽￣)/$:*.°★* 。

Linux的权限管理

# 前言
由于个人的笔记资料大多是用latex编写的，经过编译得到pdf。但是pdf并不方便在线浏览访问，也不能被搜索引擎识别

为了更方便浏览，考虑将文档转换为html共享。首先找到的`latex2html`这个项目，经过一番折腾，无果，于是考虑退而求其次，能否将pdf转换为html，一番搜索后找到了`pdf2htmlEX`这个项目，它可以近乎无损地将pdf文件转换为html

项目地址：
[pdf2htmlEX](https://github.com/pdf2htmlEX/pdf2htmlEX)


# 安装与简单使用
实际上项目有提供Linux版本的Release，奈何在服务器上跑并没有本地舒服。今天找到了Windows下的Release，就先从Windows讲起吧
## Windows平台
虽然很早就知道了这个项目，但是它没有Windows的Release。由于懒得编译，而且还不会交叉编译，于是只能放弃。今天经过搜索发现已经有人编译好了Windows的版本

[pdf2htmlEX Windows Version-RubyPdf Software Download Center](https://soft.rubypdf.com/software/pdf2htmlex-windows-version)

比较可惜的是它最新的Release只到`0.14.6`，而此时项目已经更新到了`0.18`。不过好在实际用起来没有什么太大差别，估计是因为我的文档比较简单吧

下载解压后得到一个文件夹，里面的的内容重要的是一个可执行文件`pdf2htmlEX.exe`和一个文件夹`data`。简单的方法就是在命令行执行

```cmd
./pdf2htmlEX.exe  xxx.pdf
```
其中`xxx.pdf`是需要转换的pdf，随后就可以在相同文件夹下得到`xxx.html`。`data`文件夹是主题，可以自定义，留待下文再说

## Linux平台
项目提供了`0.18.8`的Release [v0.18.8.rc1](https://github.com/pdf2htmlEX/pdf2htmlEX/releases/tag/v0.18.8.rc1)

由于我用的是Ubuntu，选择下载 [pdf2htmlEX-0.18.8.rc1-master-20200630-Ubuntu-bionic-x86_64.deb
](https://github.com/pdf2htmlEX/pdf2htmlEX/releases/download/v0.18.8.rc1/pdf2htmlEX-0.18.8.rc1-master-20200630-Ubuntu-bionic-x86_64.deb)

```shell
wget https://github.com/pdf2htmlEX/pdf2htmlEX/releases/download/v0.18.8.rc1/pdf2htmlEX-0.18.8.rc1-master-20200630-Ubuntu-bionic-x86_64.deb
```

然后使用apt安装
```shell
sudo apt install ./pdf2htmlEX-0.18.8.rc1-master-20200630-Ubuntu-bionic-x86_64.deb
```
在使用时直接输入命令就可以了
```shell
pdf2htmlEX  xxx.pdf
```
就可以在当前目录下生成`xxx.html`

另外需要说明的是，用该方式安装的主题目录位于
```shell
/usr/local/share/pdf2htmlEX
```
# 命令行参数使用
我用到的命令行参数有两个
```shell
pdf2htmlEX --dest-dir dddd xxx.pdf
```
用于将转换后的`xxx.html`放到`dddd`目录下
```shell
pdf2htmlEX --dpi 300 xxx.pdf
```
可以设置图片的dpi为300，默认的是144，比较模糊
# 个性化配置
总体有一个配置文件`manifest`，它是一个类似于html结构的文件
```html
"""
<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8"/>
<meta name="generator" content="pdf2htmlEX"/>
<meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
"""
@base.min.css

# fancy CSS styles - Optional
@fancy.min.css

# PDF specific CSS styles - Do not modify
$css

@topbar.css

"""
<script>
try{
  pdf2htmlEX.defaultViewer = new pdf2htmlEX.Viewer({});
}catch(e){}
</script>
"""
#TEST_IGNORE_END

"""
<title></title>
</head>
<body>
"""

"""
<div id="sidebar" class="opened">
"""
# container of outlines
"""
<div id="outline">
"""
$outline
"""
</div>
</div>
"""

"""
<div id="page-container">
"""

"""
<div id="topbar">
  <button id="sidebar-toggle" class="top-btn">Outline</button>
  <div id="scale">
    <button id="zoom-in" class="top-btn">+</button>
    <button id="zoom-out" class="top-btn">-</button>
    <button id="auto-zoom" class="top-btn">auto</button>
  </div>
</div>
"""

$pages

"""
</div>
"""

"""
<div class="loading-indicator">
"""

@pdf2htmlEX-64x64.png

"""
</div>
"""

@topbar.js

</body>
</html>
"""
```
猜测大概工作过程是进行字符串替换，其中由三个双引号包裹起来的内容将会被直接插入生成的html中
```
"""
...
"""
```
由`@`开头的是文件，文件的内容将会按照类型加入。若是js脚本，会加上`<script>`标签放入，若是`css`，则会以css的形式加入，若是图片，则会以`Base64`编码后放入。最后生成一个相当大的`html`文件，不依赖于别的文件，可以直接在浏览器打开

这些东西是允许自由发挥的，像我就给他加了一个顶栏，加入了`<div id="topbar">`标签，`topbar.css`样式，和`topbar.js`脚本，与正平常的网站开发没有什么太大区别

而由`$`开头的是pdf2html由pdf文件转换得到的结果。`$pages`是转换出的页面，`$css`是转换出的css样式，这个是无法进行修改的

但是它转换出来依然是html，这就意味着我们可以用js脚本通过`dom`去操作它。生成的html大概是这样的一个结构
```html
<head>
...
</head>
<body>
    <div id="sidebar">
    ...
    </div>
    <div id="page-container">
        <div id="..." class="pf w0 h0" ...>
        ...
        </div>
        ...
    </div>
</body>
```
`sidebar`是它的目录展示，如果加上class`opened`，则会显示，若没有则会关闭，并且打开关闭的动画非常丝滑...（咳）

不过非常离奇的是不管在`page-container`外面写什么东西，甚至给它套层壳，都会导致`sidebar`无法展示，非常见鬼。我也只能就把顶栏写在`page-container`里面

操作`sidebar`和`page-container`可以通过`id`实现
```js
const sidebar = document.getElementById('sidebar');
var container = document.getElementById('page-container');
```
文档的页面（就是pdf的一页一页）有一个共同的类名`pf w0 h0`，`w0`控制的是它的宽度，`h0`控制的是它的高度。理论上应该用`w0`和`h0`控制宽高然而实际测试并不能修改成功非常蛋疼，因而选择获取`pf`操作，不管那俩
```js
var pf=document.getElementsByClassName('pf');
for(var i=0;i<pf.length;i++){
    pf[i] ... ;
}
```
值得欣慰的是`w0`和`h0`的宽高是直接写死在css里的，推测应该是根据pdf的大小确定的

另外我还自己写了一个缩放功能，写的时候需要注意以下几点

- 由于页面内部元素复杂，应该在`pf`类上添加`transform: scale()`属性
- 不可以将`pf`包起来整体添加缩放属性，这会使所有`pf`都不显示内容
- 需要注意同步修改`pf`的`margin`属性，因为没有办法直接修改它的宽高，缩放会引起页面重叠
- 需要在缩放时将`page-container`的`top`属性设为一定的负值，以抵消`pf`的`margin`属性引起的上部空白
- 缩放时需要注意控制滚动条的位置，使其在页面中的比例不变，否则会出现页面一缩放就找不到看的是哪的情况

# 顶栏实现代码
html部分已经在前文的`manifest`展示过，下面是`topbar.css`
```js
#topbar{
    display: flex;
    justify-content: space-between;
    align-items: center;
    background-color: #ffffff;
    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
    height: 60px;
    /* 悬浮置顶 */
    position: fixed;
    top: 0;
    left: 0;
    right: 0;
    z-index: 1000
}

#sidebar{
    margin-top: 60px;
}

#page-container{
    margin-top: 60px;
}

.top-btn{
    display: inline-block;
    padding: 0 20px;
    height: 60px;
    line-height: 60px;
    color: #333;
    font-size: 16px;
    cursor: pointer;
    transition: all .3s;
    border: 0;
    background-color: #ffffff;
    transition: all .3s;
}

.top-btn:hover{
    background-color: #f5f5f5;
}
```
接下来是`topbar.js`
```js
// Get the button element
const sidebar_button = document.getElementById('sidebar-toggle');

// Get the sidebar element
const sidebar = document.getElementById('sidebar');
var container = document.getElementById('page-container');
//检查是否有打开的侧边栏
//获取w0的宽度
//获取h0的高度

var w0=document.getElementsByClassName('w0');
var h0=document.getElementsByClassName('h0');
var w0_width=parseFloat(getComputedStyle(w0[0]).width);
var h0_height=parseFloat(getComputedStyle(h0[0]).height);

var pf=document.getElementsByClassName('pf');
var margin=parseFloat(getComputedStyle(pf[0]).margin);

var stat=false;

if (sidebar.classList.contains('opened')) {
    // Remove the "opened" class from the sidebar
    stat=true;
}

var scale=1;

// Add event listener to the button
sidebar_button.addEventListener('click', function() {
    // Add the "opened" class to the sidebar
    if(stat){
        sidebar.classList.remove('opened');
        stat=false;
    }
    else
    {
        sidebar.classList.add('opened');
        stat=true;
    }
});

zoom_in_button=document.getElementById('zoom-in');
// 按下时给所有'pf'类添加‘transform’属性

zoom_in_button.addEventListener('click',function(){
    ratio=container.scrollTop/container.scrollHeight;
    scale+=0.1;
    var pf=document.getElementsByClassName('pf');
    for(var i=0;i<pf.length;i++){
        pf[i].style.transform='scale('+scale+')';
        pf[i].style.margin=margin+h0_height*(scale-1)+'px auto';
    }
    container.style.top=min(0,-h0_height*(scale-1)/2)+'px';
    container.scrollTo(0,ratio*container.scrollHeight);
});

zoom_out_button=document.getElementById('zoom-out');
// 按下时给所有'pf'类添加‘transform’属性

zoom_out_button.addEventListener('click',function(){
    ratio=container.scrollTop/container.scrollHeight;
    scale-=0.1;
    var pf=document.getElementsByClassName('pf');
    for(var i=0;i<pf.length;i++){
        pf[i].style.transform='scale('+scale+')';
        pf[i].style.margin=margin+h0_height*(scale-1)+'px auto';
    }
    container.style.top=min(0,-h0_height*(scale-1)/2)+'px';
    container.scrollTo(0,ratio*container.scrollHeight);
});

var auto_zoom_button=document.getElementById('auto-zoom');
auto_zoom_button.addEventListener('click',function(){
    ratio=container.scrollTop/container.scrollHeight;
    //获取page-container的宽度
    var page_container=document.getElementById('page-container');
    var page_container_width=parseFloat(getComputedStyle(page_container).width);
    scale=page_container_width/w0_width-0.1;
    var pf=document.getElementsByClassName('pf');
    for(var i=0;i<pf.length;i++){
        pf[i].style.transform='scale('+scale+')';
        pf[i].style.margin=margin+h0_height*(scale-1)+'px auto';
    }
    container.style.top=min(0,-h0_height*(scale-1)/2)+'px';
    container.scrollTo(0,ratio*container.scrollHeight);
});

function min(a,b){
    if(a>b)
        return b;
    else
        return a;
}
```
这一个缩放可真是写死人了(╯‵□′)╯︵┻━┻

# 后记
已经用它将我的所有pdf文档都转换成了html，现在存放在 [https://神里绫华的狗.top](https://神里绫华的狗.top)（不要在意这个名字，咳）

只能感叹pdf2htmlEX是真的强的，肉眼完全看不出来转换前后的差别。更多的信息请参考项目的wiki

[https://github.com/pdf2htmlEX/pdf2htmlEX/wiki](https://github.com/pdf2htmlEX/pdf2htmlEX/wiki)

完结撒花 *★,°*:.☆(￣▽￣)/$:*.°★*

使用pdf2htmlEX转换pdf为html

# 问题描述
现有一个较为复杂的函数接受3个参数返回一个数，希望用神经网络拟合该函数

该复杂函数暂定为
```python
def fun(x1,x2,x3):
    # return x1+x2+x3+random.random()*0.1
    return (np.sin(x1) * np.cos(x2) + np.log1p(x3**2))*10 + np.random.normal(0, 0.1)
```



应该足够复杂了，写入`data.csv`备用
``` csv
x1,x2,x3,y
8.444218515250482,7.579544029403024,4.20571580830845,31.49327078172624
2.5891675029296337,5.112747213686085,4.049341374504143,30.589961578798203
7.837985890347726,3.0331272607892745,4.765969541523559,21.840855541786173
5.833820394550312,9.081128851953352,5.046868558173903,36.719751437665835
2.8183784439970383,7.558042041572239,6.183689966753317,37.651338224836
2.5050634136244057,9.097462559682402,9.827854760376532,40.34142256836198
...
```

# 模型构建
构建一个8层的网络，第一层有三个神经元，分别接受三个输入，最后一层有一个神经元，用于输出。中间6层为隐藏层，每层有128个神经元
``` python
import torch
import torch.nn as nn
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(3, 128)
        self.fc2 = nn.Linear(128, 128)
        self.fc3 = nn.Linear(128, 128)
        self.fc4 = nn.Linear(128, 128)
        self.fc5 = nn.Linear(128, 128)
        self.fc6 = nn.Linear(128, 128)
        self.fc7 = nn.Linear(128, 1)
        
        self.dropout = nn.Dropout(0.5)  # Dropout with 50% probability
        self.leaky_relu = nn.LeakyReLU(0.01)  # Leaky ReLU with negative slope of 0.01

    def forward(self, x):
        x = self.leaky_relu(self.fc1(x))
        x = self.dropout(x)  # Apply dropout
        x = self.leaky_relu(self.fc2(x))
        x = self.dropout(x)  # Apply dropout
        x = self.leaky_relu(self.fc3(x))
        x = self.dropout(x)  # Apply dropout
        x = self.leaky_relu(self.fc4(x))
        x = self.dropout(x)
        x = self.leaky_relu(self.fc5(x))
        x = self.dropout(x)
        x = self.leaky_relu(self.fc6(x))
        x = self.fc7(x)
        return x
```
# 模型训练
## 导入所需要的库
```python
import pandas as pd  # 导入 pandas 库，用于数据处理
import numpy as np  # 导入 numpy 库，用于数值计算
import torch  # 导入 PyTorch 库，用于构建和训练深度学习模型
import torch.nn as nn  # 导入 PyTorch 的神经网络模块
import torch.optim as optim  # 导入 PyTorch 的优化模块
from sklearn.model_selection import train_test_split  # 导入 sklearn 的数据集划分模块
from sklearn.preprocessing import StandardScaler  # 导入 sklearn 的标准化模块
import matplotlib.pyplot as plt  # 导入 matplotlib 库，用于绘图
```
## 设置pytorch使用cuda
```python
# 检查是否有可用的 GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # 如果有 GPU 可用则使用 GPU，否则使用 CPU
print(f'Using device: {device}')  # 打印使用的设备
```
## 加载数据
从前面的`data.csv`中读取数据用于训练，数据应被划分为训练集和测试集
```python
# 1. 加载和准备数据
data = pd.read_csv('data.csv')  # 读取 CSV 文件中的数据

X = data.iloc[:, :-1].values  # 取出数据的前几列作为特征
y = data.iloc[:, -1].values   # 取出数据的最后一列作为标签

# 将数据集划分为训练集和测试集，测试集占总数据的 20%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
```
训练数据应该被标准化，这样训练的效果比较好。标准化的均值和方差应该保存到模型中，便与预测时使用
```python
scaler = StandardScaler()  # 初始化标准化对象
X_train = scaler.fit_transform(X_train)  # 对训练特征数据进行标准化
X_test = scaler.transform(X_test)  # 对测试特征数据进行标准化

scaler_params = {
    'mean': scaler.mean_.tolist(),
    'scale': scaler.scale_.tolist()
}

y_mean = y_train.mean()
y_std = y_train.std()

y_params = {
    'mean': y_mean,
    'std': y_std
}
```
读出的数组应该从内存中转移到显存中，才能使用cuda加速计算
```python
# 将 numpy 数组转换为 PyTorch 的张量，并将其移动到指定的设备（CPU 或 GPU）
X_train = torch.tensor(X_train, dtype=torch.float32).to(device)
X_test = torch.tensor(X_test, dtype=torch.float32).to(device)
y_train = torch.tensor(y_train, dtype=torch.float32).view(-1, 1).to(device)  # 将标签数据转换为二维张量
y_test = torch.tensor(y_test, dtype=torch.float32).view(-1, 1).to(device)  # 将标签数据转换为二维张量
```
## 导入模型
```python
# 2. 定义模型
from model import SimpleNN  # 从 model 模块导入 SimpleNN 类
model = SimpleNN().to(device)  # 实例化模型，并将模型移动到指定的设备
```
## 损失函数和优化器
```python
# 3. 定义损失函数和优化器
criterion = nn.SmoothL1Loss()  # 定义均方误差损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 定义 Adam 优化器，学习率为 0.001
```
## 训练模型
模型的训练分为`轮次`和`批量`，每一轮从总数据中取出一个批次的数据进行训练
```python
# 4. 训练模型
num_epochs = 10000  # 训练轮数
batch_size = 30000  # 批量大小
losses = []  # 用于记录每个 epoch 的损失

for epoch in range(num_epochs):  # 遍历每个 epoch
    permutation = torch.randperm(X_train.size()[0])  # 生成一个随机排列的索引，用于打乱训练数据
    
    epoch_loss = 0  # 初始化当前 epoch 的总损失
    for i in range(0, X_train.size()[0], batch_size):  # 遍历每个批量
        optimizer.zero_grad()  # 清零梯度
        
        indices = permutation[i:i + batch_size]  # 获取当前批量的索引
        batch_x, batch_y = X_train[indices], y_train[indices]  # 根据索引获取当前批量的数据和标签
        
        outputs = model(batch_x)  # 前向传播，计算模型输出
        loss = criterion(outputs, batch_y)  # 计算损失
        
        loss.backward()  # 反向传播，计算梯度
        optimizer.step()  # 更新模型参数
        
        epoch_loss += loss.item()  # 累加当前批量的损失到 epoch 总损失中
    
    losses.append(epoch_loss)  # 记录当前 epoch 的总损失
    
    if (epoch + 1) % 100 == 0:  # 每 100 个 epoch 打印一次损失
        #计算最近100次的平均损失
        recent_losses = losses[-100:]
        recent_loss = sum(recent_losses) / len(recent_losses)
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {recent_loss:.4f}')
```
然后保存模型
```python
torch.save({
    'model_state_dict': model.state_dict(),
    'scaler_params': scaler_params,
    'y_params': y_params
}, 'model_with_scaler.pth')
print('模型已保存')  # 打印模型保存信息
```
## 评估模型
```python
# 5. 评估模型
model.eval()  # 切换到评估模式（禁用 Dropout 和 BatchNorm）
with torch.no_grad():  # 禁用梯度计算
    predictions = model(X_test)  # 使用测试数据进行预测
    test_loss = criterion(predictions, y_test)  # 计算测试损失
    print(f'Test Loss: {test_loss.item():.4f}')  # 打印测试损失

# 6. 可视化训练过程（可选）
plt.plot(range(num_epochs), losses)  # 绘制训练损失曲线
plt.xlabel('Epoch')  # x 轴标签
plt.ylabel('Loss')  # y 轴标签
plt.title('Training Loss')  # 图表标题
plt.show()  # 显示图表
```
# 使用模型进行预测
首先应该加载模型文件，同时读取标准化参数
```python
model = SimpleNN()  # 重新创建模型实例
# model.load_state_dict(torch.load('model.pth'))
# model.eval()  # 切换到评估模式
# print('模型已加载')

# 加载模型和标准化参数
checkpoint = torch.load('model_with_scaler.pth')

model.load_state_dict(checkpoint['model_state_dict'])
scaler_params = checkpoint['scaler_params']
y_params = checkpoint['y_params']

mean = torch.tensor(scaler_params['mean'], dtype=torch.float32)
scale = torch.tensor(scaler_params['scale'], dtype=torch.float32)

y_mean = torch.tensor(y_params['mean'], dtype=torch.float32)
y_std = torch.tensor(y_params['std'], dtype=torch.float32)

print('模型已加载')
print('y_mean:', y_mean)
print('y_std:', y_std)
print('mean:', mean)
print('scale:', scale)
```
可以使用`data.csv`中的数据（即训练数据）评估模型效果
```python
with torch.no_grad():
    #读取data.csv
    import pandas as pd
    data = pd.read_csv('data.csv')
    #最后一列为真实数据
    y_test = data.iloc[:, -1].values
    #前面的列为特征
    X_test = data.iloc[:, :-1].values
    # 将数据转换为张量
    X_test = torch.tensor(X_test, dtype=torch.float32)
    # 使用保存的参数标准化测试数据
    X_test = (X_test - mean) / scale
    predictions = model(X_test)
    # 反标准化预测结果
    # predictions = predictions * y_std + y_mean
    #保存结果到csv
    result = pd.DataFrame(columns=['predictions', 'y_test'])
    result['predictions'] = predictions.view(-1).numpy()
    result['y_test'] = y_test
    result.to_csv('result.csv', index=False)
    #计算平均偏差
    y_test = torch.tensor(y_test, dtype=torch.float32).view(-1, 1)
    diff = predictions - y_test
    diff_mean = torch.mean(diff)
    diff_std = torch.std(diff)
    print('平均偏差:', diff_mean)
    print('偏差标准差:', diff_std)
    #绘制偏差分布图
    import matplotlib.pyplot as plt
    plt.hist(diff.numpy(), bins=20)
    plt.xlabel('Diff')
    plt.ylabel('Frequency')
    plt.title('Diff Distribution')
    plt.savefig('diff_distribution.png')
    plt.show()
    print('结果已保存')
```
这是输出的结果，可见训练效果非常的不错
```csv
predictions,y_test
29.141756,31.49327078172624
27.42849,30.589961578798203
21.874674,21.840855541786173
37.611496,36.71975143766584
34.063713,37.651338224836
43.536583,40.34142256836198
18.55039,14.77899637657035
35.315445,30.780483076989874
21.361193,24.6043033224426
47.960533,47.19596821098634
27.967197,27.695992998712587
9.5465355,7.156074135170297
37.481857,37.21442771729388
38.555557,36.3167101316844
21.846512,19.3475078868978
32.653824,32.948488401020384
35.61287,35.34606849875347
15.098193,17.392378895548934
...
```
可以使用预先的函数评估模型效果
```python
with torch.no_grad():
    #随机生成数据
    random.seed(1)
    test_list = []
    for i in range(100):
        x1 = random.random()
        x2 = random.random()
        x3 = random.random()
        test_list.append([x1, x2, x3])
    X_test = torch.tensor(test_list, dtype=torch.float32)
    # 使用保存的参数标准化测试数据
    X_test = (X_test - mean) / scale
    predictions = model(X_test)
    y=[]
    for i in range(100):
        x1, x2, x3 = test_list[i]
        y.append(fun(x1, x2, x3))
    #保存结果到csv
    result = pd.DataFrame(columns=['predictions', 'y_test'])
    result['predictions'] = predictions.view(-1).numpy()
    result['y_test'] = y
    result.to_csv('result_random.csv', index=False)
    #计算平均偏差
    y=torch.tensor(y, dtype=torch.float32).view(-1, 1)
    diff=predictions-y
    diff_mean=torch.mean(diff)
    diff_std=torch.std(diff)
    print('平均偏差:',diff_mean)
    print('偏差标准差:',diff_std)
    #绘制偏差分布图
    import matplotlib.pyplot as plt
    plt.hist(diff.numpy(), bins=20)
    plt.xlabel('Diff')
    plt.ylabel('Frequency')
    plt.title('Diff Distribution')
    plt.savefig('diff_distribution.png')
    plt.show()

    print('结果已保存')
```
总体而言拟合效果还可以，但是有些数据偏差有些大
```csv
predictions,y_test
5.1833587,5.599647152405113
9.0166445,3.98510360599354
2.0647216,4.268379343665554
3.0109725,1.9694396684840318
12.234534,8.670199066521533
12.691338,12.797512945010594
9.277757,7.755939940065803
2.3095508,4.241482044305519
4.990645,2.0843641577440524
2.058435,4.140842339186644
3.2915149,2.595814142473651
5.1719728,4.403141646741202
9.764646,9.646518740649316
6.6177983,6.488145515130112
...
```
绘制的偏差分布画图如下

![diff_distribution.png](/static/img/93561e6bba4ce86bd667872a75dccfec.diff_distribution.webp)

怀疑出现了过拟合