作者： chenpaopao

Systemd （守护系统）–linux

官网： https://systemd.io/

Github：https://github.com/systemd/systemd

systemd 是什么？【来自维基百科】

systemd是Linux电脑操作系统之下的一套中央化系统及设置管理程序（init），包括有守护进程、程序库以及应用软件，由Lennart Poettering（英语：Lennart Poettering）带头开发。其开发目标是提供更优秀的框架以表示系统服务（英语：Service (systems architecture)）间的依赖关系，并依此实现系统初始化时服务的并行启动，同时达到降低Shell的系统开销（英语：Computational overhead）的效果，最终代替现在常用的System V与BSD风格init程序。

Systemd 是一系列工具的集合，其作用也远远不仅是启动操作系统，它还接管了后台服务、结束、状态查询，以及日志归档、设备管理、电源管理、定时任务等许多职责，并支持通过特定事件（如插入特定 USB 设备）和特定端口数据触发的 On-demand（按需）任务。

Systemd 的后台服务还有一个特殊的身份——它是系统中 PID 值为 1 的进程。

  1. 更少的进程

Systemd 提供了服务按需启动的能力，使得特定的服务只有在真定被请求时才启动。

  1. 允许更多的进程并行启动

在 SysV-init 时代，将每个服务项目编号依次执行启动脚本。Ubuntu 的 Upstart 解决了没有直接依赖的启动之间的并行启动。而 Systemd 通过 Socket 缓存、DBus 缓存和建立临时挂载点等方法进一步解决了启动进程之间的依赖，做到了所有系统服务并发启动。对于用户自定义的服务，Systemd 允许配置其启动依赖项目，从而确保服务按必要的顺序运行。

  1. 使用 CGroup 跟踪和管理进程的生命周期

在 Systemd 之间的主流应用管理服务都是使用 进程树 来跟踪应用的继承关系的，而进程的父子关系很容易通过 两次 fork 的方法脱离。

而 Systemd 则提供通过 CGroup 跟踪进程关系，引补了这个缺漏。通过 CGroup 不仅能够实现服务之间访问隔离，限制特定应用程序对系统资源的访问配额，还能更精确地管理服务的生命周期。

  1. 统一管理服务日志

Systemd 是一系列工具的集合， 包括了一个专用的系统日志管理服务：Journald。这个服务的设计初衷是克服现有 Syslog 服务的日志内容易伪造和日志格式不统一等缺点，Journald 用 二进制格式 保存所有的日志信息，因而日志内容很难被手工伪造。Journald 还提供了一个 journalctl 命令来查看日志信息，这样就使得不同服务输出的日志具有相同的排版格式， 便于数据的二次处理。

一、由来

历史上，Linux 的启动一直采用init进程。

下面的命令用来启动服务。


$ sudo /etc/init.d/apache2 start
# 或者
$ service apache2 start

这种方法有两个缺点。

一是启动时间长。init进程是串行启动，只有前一个进程启动完，才会启动下一个进程。

二是启动脚本复杂。init进程只是执行启动脚本，不管其他事情。脚本需要自己处理各种情况，这往往使得脚本变得很长。

二、Systemd 概述

Systemd 就是为了解决这些问题而诞生的。它的设计目标是，为系统的启动和管理提供一套完整的解决方案。

根据 Linux 惯例，字母d是守护进程（daemon）的缩写。 Systemd 这个名字的含义，就是它要守护整个系统。使用了 Systemd，就不需要再用init了。Systemd 取代了initd，成为系统的第一个进程（PID 等于 1），其他进程都是它的子进程。

$ systemctl --version

上面的命令查看 Systemd 的版本。

Systemd 的优点是功能强大，使用方便，缺点是体系庞大，非常复杂。事实上，现在还有很多人反对使用 Systemd，理由就是它过于复杂，与操作系统的其他部分强耦合，违反”keep simple, keep stupid”的Unix 哲学。

 Systemd 架构图

三、系统管理

Systemd 并不是一个命令，而是一组命令，涉及到系统管理的方方面面。

3.1 systemctl

systemctl是 Systemd 的主命令，用于管理系统。

# 重启系统
$ sudo systemctl reboot

# 关闭系统，切断电源
$ sudo systemctl poweroff

# CPU停止工作
$ sudo systemctl halt

# 暂停系统
$ sudo systemctl suspend

# 让系统进入冬眠状态
$ sudo systemctl hibernate

# 让系统进入交互式休眠状态
$ sudo systemctl hybrid-sleep

# 启动进入救援状态（单用户状态）
$ sudo systemctl rescue

3.2 systemd-analyze

systemd-analyze命令用于查看启动耗时。

systemd-analyze -h查看具体命令


# 查看启动耗时
$ systemd-analyze                                                                                       

# 查看每个服务的启动耗时
$ systemd-analyze blame

# 显示瀑布状的启动过程流
$ systemd-analyze critical-chain

# 显示指定服务的启动流
$ systemd-analyze critical-chain atd.service

3.3 hostnamectl

hostnamectl命令用于查看当前主机的信息。


# 显示当前主机的信息
$ hostnamectl

# 设置主机名。
$ sudo hostnamectl set-hostname rhel7

3.4 localectl

localectl命令用于查看本地化设置。

localectl -h用来查看具体命令


# 查看本地化设置
$ localectl

# 设置本地化参数。
$ sudo localectl set-locale LANG=en_GB.utf8
$ sudo localectl set-keymap en_GB

3.5 timedatectl

timedatectl命令用于查看当前时区设置。


# 查看当前时区设置
$ timedatectl

# 显示所有可用的时区
$ timedatectl list-timezones                                                                                   

# 设置当前时区
$ sudo timedatectl set-timezone America/New_York
$ sudo timedatectl set-time YYYY-MM-DD
$ sudo timedatectl set-time HH:MM:SS

3.6 loginctl

loginctl命令用于查看当前登录的用户。


# 列出当前session
$ loginctl list-sessions

# 列出当前登录用户
$ loginctl list-users

# 列出显示指定用户的信息
$ loginctl show-user ruanyf

四、Unit

4.1 含义

Systemd 可以管理所有系统资源。不同的资源统称为 Unit（单位）。

Unit 一共分成12种。

  • Service unit：系统服务
  • Target unit：多个 Unit 构成的一个组
  • Device Unit：硬件设备
  • Mount Unit：文件系统的挂载点
  • Automount Unit：自动挂载点
  • Path Unit：文件或路径
  • Scope Unit：不是由 Systemd 启动的外部进程
  • Slice Unit：进程组
  • Snapshot Unit：Systemd 快照，可以切回某个快照
  • Socket Unit：进程间通信的 socket
  • Swap Unit：swap 文件
  • Timer Unit：定时器

systemctl list-units命令可以查看当前系统的所有 Unit 。


# 列出正在运行的 Unit
$ systemctl list-units

# 列出所有Unit，包括没有找到配置文件的或者启动失败的
$ systemctl list-units --all

# 列出所有没有运行的 Unit
$ systemctl list-units --all --state=inactive

# 列出所有加载失败的 Unit
$ systemctl list-units --failed

# 列出所有正在运行的、类型为 service 的 Unit
$ systemctl list-units --type=service

4.2 Unit 的状态

systemctl status命令用于查看系统状态和单个 Unit 的状态。


# 显示系统状态
$ systemctl status

# 显示单个 Unit 的状态
$ sysystemctl status bluetooth.service

# 显示远程主机的某个 Unit 的状态
$ systemctl -H root@rhel7.example.com status httpd.service

除了status命令，systemctl还提供了三个查询状态的简单方法，主要供脚本内部的判断语句使用。


# 显示某个 Unit 是否正在运行
$ systemctl is-active application.service

# 显示某个 Unit 是否处于启动失败状态
$ systemctl is-failed application.service

# 显示某个 Unit 服务是否建立了启动链接
$ systemctl is-enabled application.service

4.3 Unit 管理

对于用户来说，最常用的是下面这些命令，用于启动和停止 Unit（主要是 service）。


# 立即启动一个服务
$ sudo systemctl start apache.service

# 立即停止一个服务
$ sudo systemctl stop apache.service

# 重启一个服务
$ sudo systemctl restart apache.service

# 杀死一个服务的所有子进程
$ sudo systemctl kill apache.service

# 重新加载一个服务的配置文件
$ sudo systemctl reload apache.service

# 重载所有修改过的配置文件
$ sudo systemctl daemon-reload

# 显示某个 Unit 的所有底层参数
$ systemctl show httpd.service

# 显示某个 Unit 的指定属性的值
$ systemctl show -p CPUShares httpd.service

# 设置某个 Unit 的指定属性
$ sudo systemctl set-property httpd.service CPUShares=500

4.4 依赖关系

Unit 之间存在依赖关系：A 依赖于 B，就意味着 Systemd 在启动 A 的时候，同时会去启动 B。

systemctl list-dependencies 命令列出一个 Unit 的所有依赖。


$ systemctl list-dependencies nginx.service

上面命令的输出结果之中，有些依赖是 Target 类型（详见下文），默认不会展开显示。如果要展开 Target，就需要使用--all参数。


$ systemctl list-dependencies --all nginx.service

五、Unit 的配置文件

5.1 概述

每一个 Unit 都有一个配置文件，告诉 Systemd 怎么启动这个 Unit 。

Systemd 默认从目录/etc/systemd/system/读取配置文件。但是，里面存放的大部分文件都是符号链接，指向目录/usr/lib/systemd/system/，真正的配置文件存放在那个目录。可以把自己定义的服务放在 /usr/lib/systemd/system/ 下面。配置文件主要放在 /usr/lib/systemd/system 目录，也可能在 /etc/systemd/system 目录

systemctl enable命令用于在上面两个目录之间，建立符号链接关系。


$ sudo systemctl enable clamd@scan.service
# 等同于
$ sudo ln -s '/usr/lib/systemd/system/clamd@scan.service' '/etc/systemd/system/multi-user.target.wants/clamd@scan.service'

创建软链接

ln  -s  [源文件或目录]  [目标文件或目录]

删除软链接

和删除普通的文件是一样的，删除都是使用rm来进行操作

不论是硬链接或软链接都不会将原本的目标文件完全复制一份，而只会占用非常少量的存储空间。

如果配置文件里面设置了开机启动，systemctl enable命令相当于激活开机启动。

与之对应的，systemctl disable命令用于在两个目录之间，撤销符号链接关系，相当于撤销开机启动。


$ sudo systemctl disable clamd@scan.service

配置文件的后缀名，就是该 Unit 的种类，比如sshd.socket。如果省略，Systemd 默认后缀名为.service，所以sshd会被理解成sshd.service。

5.2 配置文件的状态

systemctl list-unit-files命令用于列出所有配置文件。


# 列出所有配置文件
$ systemctl list-unit-files

# 列出指定类型的配置文件
$ systemctl list-unit-files --type=service

这个命令会输出一个列表。


$ systemctl list-unit-files

UNIT FILE              STATE
chronyd.service        enabled
clamd@.service         static
clamd@scan.service     disabled

这个列表显示每个配置文件的状态，一共有四种。

  • enabled：已建立启动链接
  • disabled：没建立启动链接
  • static：该配置文件没有[Install]部分（无法执行），只能作为其他配置文件的依赖
  • masked：该配置文件被禁止建立启动链接

注意，从配置文件的状态无法看出，该 Unit 是否正在运行。这必须执行前面提到的systemctl status命令。


$ systemctl status bluetooth.service

一旦修改配置文件，就要让 SystemD 重新加载配置文件，然后重新启动，否则修改不会生效。


$ sudo systemctl daemon-reload
$ sudo systemctl restart httpd.service

5.3 配置文件的格式

配置文件就是普通的文本文件，可以用文本编辑器打开。

systemctl cat命令可以查看配置文件的内容。


$ systemctl cat atd.service

[Unit]
Description=ATD daemon

[Service]
Type=forking
ExecStart=/usr/bin/atd

[Install]
WantedBy=multi-user.target

从上面的输出可以看到，配置文件分成几个区块。每个区块的第一行，是用方括号表示的区别名，比如[Unit]。注意，配置文件的区块名和字段名，都是大小写敏感的。

每个区块内部是一些等号连接的键值对。


[Section]
Directive1=value
Directive2=value

. . .

注意，键值对的等号两侧不能有空格。

5.4 配置文件的区块

[Unit]
Description=Protect ARP list
Wants=network-online.target
After=network.target
  • 其中network.target代表有网路，network-online.target代表一个连通着的网络。

[Unit]区块通常是配置文件的第一个区块，用来定义 Unit 的元数据，以及配置与其他 Unit 的关系。它的主要字段如下。

  • Description：简短描述
  • Documentation：文档地址
  • Requires：当前 Unit 依赖的其他 Unit，如果它们没有运行，当前 Unit 会启动失败
  • Wants：与当前 Unit 配合的其他 Unit，如果它们没有运行，当前 Unit 不会启动失败
  • BindsTo：与Requires类似，它指定的 Unit 如果退出，会导致当前 Unit 停止运行
  • Before：如果该字段指定的 Unit 也要启动，那么必须在当前 Unit 之后启动
  • After：如果该字段指定的 Unit 也要启动，那么必须在当前 Unit 之前启动
  • Conflicts：这里指定的 Unit 不能与当前 Unit 同时运行
  • Condition...：当前 Unit 运行必须满足的条件，否则不会运行
  • Assert...：当前 Unit 运行必须满足的条件，否则会报启动失败

[Install]通常是配置文件的最后一个区块，用来定义如何启动，以及是否开机启动。它的主要字段如下。

  • WantedBy：它的值是一个或多个 Target，当前 Unit 激活时（enable）符号链接会放入/etc/systemd/system目录下面以 Target 名 + .wants后缀构成的子目录中
  • RequiredBy：它的值是一个或多个 Target，当前 Unit 激活时，符号链接会放入/etc/systemd/system目录下面以 Target 名 + .required后缀构成的子目录中
  • Alias：当前 Unit 可用于启动的别名
  • Also：当前 Unit 激活（enable）时，会被同时激活的其他 Unit

[Service]区块用来 Service 的配置，只有 Service 类型的 Unit 才有这个区块。它的主要字段如下。

  • Type：定义启动时的进程行为。它有以下几种值。
  • Type=simple：默认值，执行ExecStart指定的命令，启动主进程
  • Type=forking：以 fork 方式从父进程创建子进程，创建后父进程会立即退出
  • Type=oneshot：一次性进程，Systemd 会等当前服务退出，再继续往下执行
  • Type=dbus：当前服务通过D-Bus启动
  • Type=notify：当前服务启动完毕，会通知Systemd，再继续往下执行
  • Type=idle：若有其他任务执行完毕，当前服务才会运行
  • ExecStart：启动当前服务的命令
  • ExecStartPre：启动当前服务之前执行的命令
  • ExecStartPost：启动当前服务之后执行的命令
  • ExecReload：重启当前服务时执行的命令
  • ExecStop：停止当前服务时执行的命令
  • ExecStopPost：停止当其服务之后执行的命令
  • RestartSec：自动重启当前服务间隔的秒数
  • Restart：定义何种情况 Systemd 会自动重启当前服务，可能的值包括always（总是重启）、on-success、on-failure、on-abnormal、on-abort、on-watchdog
  • TimeoutSec：定义 Systemd 停止当前服务之前等待的秒数
  • Environment：指定环境变量

Unit 配置文件的完整字段清单，请参考官方文档。

六、Target

启动计算机的时候，需要启动大量的 Unit。如果每一次启动，都要一一写明本次启动需要哪些 Unit，显然非常不方便。Systemd 的解决方案就是 Target。

简单说，Target 就是一个 Unit 组，包含许多相关的 Unit 。启动某个 Target 的时候，Systemd 就会启动里面所有的 Unit。从这个意义上说，Target 这个概念类似于”状态点”，启动某个 Target 就好比启动到某种状态。

传统的init启动模式里面，有 RunLevel 的概念，跟 Target 的作用很类似。不同的是，RunLevel 是互斥的，不可能多个 RunLevel 同时启动，但是多个 Target 可以同时启动。


# 查看当前系统的所有 Target
$ systemctl list-unit-files --type=target

# 查看一个 Target 包含的所有 Unit
$ systemctl list-dependencies multi-user.target

# 查看启动时的默认 Target
$ systemctl get-default

# 设置启动时的默认 Target
$ sudo systemctl set-default multi-user.target

# 切换 Target 时，默认不关闭前一个 Target 启动的进程，
# systemctl isolate 命令改变这种行为，
# 关闭前一个 Target 里面所有不属于后一个 Target 的进程
$ sudo systemctl isolate multi-user.target

Target 与 传统 RunLevel 的对应关系如下。


Traditional runlevel      New target name     Symbolically linked to...

Runlevel 0           |    runlevel0.target -> poweroff.target
Runlevel 1           |    runlevel1.target -> rescue.target
Runlevel 2           |    runlevel2.target -> multi-user.target
Runlevel 3           |    runlevel3.target -> multi-user.target
Runlevel 4           |    runlevel4.target -> multi-user.target
Runlevel 5           |    runlevel5.target -> graphical.target
Runlevel 6           |    runlevel6.target -> reboot.target

它与init进程的主要差别如下。

（1）默认的 RunLevel（在/etc/inittab文件设置）现在被默认的 Target 取代，位置是/etc/systemd/system/default.target，通常符号链接到graphical.target（图形界面）或者multi-user.target（多用户命令行）。

（2）启动脚本的位置，以前是/etc/init.d目录，符号链接到不同的 RunLevel 目录 （比如/etc/rc3.d、/etc/rc5.d等），现在则存放在/lib/systemd/system和/etc/systemd/system目录。

（3）配置文件的位置，以前init进程的配置文件是/etc/inittab，各种服务的配置文件存放在/etc/sysconfig目录。现在的配置文件主要存放在/lib/systemd目录，在/etc/systemd目录里面的修改可以覆盖原始设置。

七、日志管理

Systemd 统一管理所有 Unit 的启动日志。带来的好处就是，可以只用journalctl一个命令，查看所有日志（内核日志和应用日志）。日志的配置文件是/etc/systemd/journald.conf。

journalctl功能强大，用法非常多。


# 查看所有日志（默认情况下 ，只保存本次启动的日志）
$ sudo journalctl

# 查看内核日志（不显示应用日志）
$ sudo journalctl -k

# 查看系统本次启动的日志
$ sudo journalctl -b
$ sudo journalctl -b -0

# 查看上一次启动的日志（需更改设置）
$ sudo journalctl -b -1

# 查看指定时间的日志
$ sudo journalctl --since="2012-10-30 18:17:16"
$ sudo journalctl --since "20 min ago"
$ sudo journalctl --since yesterday
$ sudo journalctl --since "2015-01-10" --until "2015-01-11 03:00"
$ sudo journalctl --since 09:00 --until "1 hour ago"

# 显示尾部的最新10行日志
$ sudo journalctl -n

# 显示尾部指定行数的日志
$ sudo journalctl -n 20

# 实时滚动显示最新日志
$ sudo journalctl -f

# 查看指定服务的日志
$ sudo journalctl /usr/lib/systemd/systemd

# 查看指定进程的日志
$ sudo journalctl _PID=1

# 查看某个路径的脚本的日志
$ sudo journalctl /usr/bin/bash

# 查看指定用户的日志
$ sudo journalctl _UID=33 --since today

# 查看某个 Unit 的日志
$ sudo journalctl -u nginx.service
$ sudo journalctl -u nginx.service --since today

# 实时滚动显示某个 Unit 的最新日志
$ sudo journalctl -u nginx.service -f

# 合并显示多个 Unit 的日志
$ journalctl -u nginx.service -u php-fpm.service --since today

# 查看指定优先级（及其以上级别）的日志，共有8级
# 0: emerg
# 1: alert
# 2: crit
# 3: err
# 4: warning
# 5: notice
# 6: info
# 7: debug
$ sudo journalctl -p err -b

# 日志默认分页输出，--no-pager 改为正常的标准输出
$ sudo journalctl --no-pager

# 以 JSON 格式（单行）输出
$ sudo journalctl -b -u nginx.service -o json

# 以 JSON 格式（多行）输出，可读性更好
$ sudo journalctl -b -u nginx.serviceqq
 -o json-pretty

# 显示日志占据的硬盘空间
$ sudo journalctl --disk-usage

# 指定日志文件占据的最大空间
$ sudo journalctl --vacuum-size=1G

# 指定日志文件保存多久
$ sudo journalctl --vacuum-time=1years

python 异常处理 try except 和 断言(assert)

最近在写代码的时候，很多时候需要考虑各种情况，如果仅仅使用if，会很麻烦，于是想到了python 异常处理和断言，用于判断函数进程。、

异常处理 try

程序在运行的时候，如果python解释器遇到一个错误，会停止程序的执行，
并且提示一些错误的信息，这就是异常
我们在程序开发的时候，很难将所有的特殊情况都处理，
通过异常捕获可以针对
突发事件做集中处理，从而保证程序的健壮性和稳定性

在程序开发中，如果对某些代码的执行不能确定(程序语法完全正确)
可以增加try来捕获异常

try这个关键字来捕获异常
try:尝试执行的代码
except:出现错误的处理 finally：无论是否发生异常，都会执行final部份

try:
    print('try...')
    r = 10 / int('a')
    print('result:', r)
except ValueError as e:
    print('ValueError:', e)
except ZeroDivisionError as e:
    print('ZeroDivisionError:', e)
finally:
    print('finally...')
print('END')

try 语句的工作原理如下：

  • 首先，执行 try 子句 （try 和 except 关键字之间的（多行）语句）。
  • 如果没有触发异常，则跳过 except 子句，try 语句执行完毕。
  • 如果在执行 try 子句时发生了异常，则跳过该子句中剩下的部分。 如果异常的类型与 except 关键字后指定的异常相匹配，则会执行 except 子句，然后跳到 try/except 代码块之后继续执行。
  • 如果发生的异常与 except 子句 中指定的异常不匹配，则它会被传递到外部的 try 语句中；如果没有找到处理程序，则它是一个 未处理异常 且执行将终止并输出如上所示的消息。

try 语句可以有多个 except 子句 来为不同的异常指定处理程序。 但最多只有一个处理程序会被执行。 处理程序只处理对应的 try 子句 中发生的异常，而不处理同一 try 语句内其他处理程序中的异常。 except 子句 可以用带圆括号的元组来指定多个异常。

常见异常：

try 语句还有一个可选子句，用于定义在所有情况下都必须要执行的清理操作。

如果存在 finally 子句，则 finally 子句是 try 语句结束前执行的最后一项任务。不论 try 语句是否触发异常，都会执行 finally 子句。以下内容介绍了几种比较复杂的触发异常情景：

  • 如果执行 try 子句期间触发了某个异常，则某个 except 子句应处理该异常。如果该异常没有 except 子句处理，在 finally 子句执行后会被重新触发。
  • except 或 else 子句执行期间也会触发异常。 同样，该异常会在 finally 子句执行之后被重新触发。
  • 如果 finally 子句中包含 break、continue 或 return 等语句，异常将不会被重新引发。
  • 如果执行 try 语句时遇到 break,、continue 或 return 语句，则 finally 子句在执行 break、continue 或 return 语句之前执行。
  • 如果 finally 子句中包含 return 语句，则返回值来自 finally 子句的某个 return 语句的返回值，而不是来自 try 子句的 return 语句的返回值。

assert（断言）

Python assert（断言）用于判断一个表达式，在表达式条件为 false 的时候触发异常。

断言可以在条件不满足程序运行的情况下直接返回错误，而不必等待程序运行后出现崩溃的情况，例如我们的代码只能在 Linux 系统下运行，可以先判断当前系统是否符合条件。

语法格式如下：

assert expression

等价于：

if not expression:
    raise AssertionError

assert 后面也可以紧跟参数:

assert expression [, arguments]

等价于：

if not expression:
    raise AssertionError(arguments)

Linux htop 详解

图片来自官网

htop是一款运行于Linux系统监控与进程管理软件，用于取代Unix下传统的top。与top只提供最消耗资源的进程列表不同，htop提供所有进程的列表，并且使用彩色标识出处理器、swap和内存状态。
用户一般可以在top无法提供详尽系统信息的情况下选择安装并使用htop。比如，在查找应用程序的内存泄漏问题时。与top相比，htop提供更方便、光标控制的界面来杀死进程。

安装： sudo apt install htop

官网： https://htop.dev/

github： https://github.com/htop-dev/htop

英文手册：https://www.geeksforgeeks.org/htop-command-in-linux-with-examples/

以上图为例：

Syntax:

htop [-dChusv]

Options:

-d –delay : Used to show the delay between updates, in tenths of seconds.
-C –no-color –no-colour : Start htop in monochrome mode.
-h –help : Used to display the help message and exit.
-u –user=USERNAME : Used to show only the processes of a given use
-p –pid=PID, PID… : Used to show only the given PIDs.
-s –sort-key COLUMN : Sort by this column (use –sort-key help for a column list).
-v –version : Output version information and exit.
-F --filter=FILTER   Show only the commands matching the given filter
-U --no-unicode                 Do not use unicode but plain ASCII
-H --highlight-changes[=DELAY]  Highlight new and old processes
-M --no-mouse                   Disable the mouse
-t --tree                       Show the tree view (can be combined with -s)

htop命令的部分

从前面的输出中，我们可以清楚地看到htop的显示分为3个部分:

头部:

头部分显示系统指标，包括CPU、内存和交换利用率、运行任务、平均负载和正常运行时间。

preview

红色边框：数字 1，2，3，4分别代表CPU处理器/核，上图是一个四核的处理器

灰色边框（progress bar）

每一个CPU的总用量情况，注意这条上面会有不同的颜色：

  1. 蓝色：显示低优先级(low priority)进程使用的CPU百分比。
  2. 绿色：显示用于普通用户(user)拥有的进程的CPU百分比。
  3. 红色：显示系统进程(kernel threads)使用的CPU百分比。
  4. 橙色：显示IRQ时间使用的CPU百分比。
  5. 洋红色(Magenta)：显示Soft IRQ时间消耗的CPU百分比。
  6. 灰色：显示IO等待时间消耗的CPU百分比。
  7. 青色：显示窃取时间(Steal time)消耗的CPU百分比。

黄色边框

提供了内存（Memory）和交换（Swap）使用情况。 类似于CPU中的进度条，内存监视也包含具有多种颜色的进度条：

  1. 绿色：显示内存页面占用的RAM百分比
  2. 蓝色：显示缓冲区页面占用的RAM百分比
  3. 橙色：显示缓存页面占用的RAM百分比

swap行主要显示交换分区使用情况，当你发现你的交换分区(swap)已经派上用场的时候，说明你的物理内存已经不足，需要考虑增加内存了。

蓝色边框

  • 第一行 (Tasks, thr, running)
    • 参考上面的屏幕截图，我们在计算机上运行的106个任务(tasks)被分解为113个线程(thread)，其中只有1个进程处于运行(running)状态。
    • 任务(tasks)是打开的进程总数的代表，但并不是每个打开的进程都在不断消耗CPU。 每个进程都处于几种状态
      • R: Running：表示进程(process)正在使用CPU
      • S: Sleeping: 通常进程在大多数时间都处于睡眠状态，并以固定的时间间隔执行小检查，或者等待用户输入后再返回运行状态。
      • T/S: Traced/Stoped: 表示进程正在处于暂停的状态
      • Z:Zombie or defunct:已完成执行但在进程表中仍具有条目的进程。
  • 第二行 Load Average
    • 三个值是指系统在最后1分钟，最近5分钟和最后15分钟的平均负载 (0.21,0.19,0.15)
  • 第三行 Uptime
    • 表示这个系统一共运行了多长的时间，这里一共运行了78天

主体:

所有正在运行的进程。

  • PID – 描述进程的ID号
  • USER – 描述进程的所有者（谁跑的）
  • PRI – 描述Linux内核查看的进程优先级
  • NI – 描述由用户或root重置的进程优先级
  • VIR – 它描述进程正在使用的虚拟内存 （virtual memory）
  • RES – 描述进程正在消耗的物理内存（physical memory）
  • SHR – 描述进程正在使用的共享内存（shared memory）
  • S – 描述流程的当前状态 (state)
  • CPU％ – 描述每个进程消耗的CPU百分比
  • MEM％ – 描述每个进程消耗的内存百分比
  • TIME+ – 显示自流程开始执行以来的时间
  • Command –它与每个进程并行显示完整的命令执行 (比如/usr/lib/R)

S：进程的运行状况

(1) R 表示正在运行
(2) S 表示休眠
(3) Z 表示僵死状态
(4) N 表示该进程优先值是负数

交互命令:

显示“htop菜单选项”

F1~F10 的功能和对应的字母快捷键：

  • Arrows, Page Up, Page Down, Home, End: Scroll the process list.
  • Space: Tag or untag a process.
  • U – Untag all processes (remove all tags added with the Space key).
  • s – Trace process system calls.
  • F1 – Help
  • F2 – setup
  • F3 – search
  • F4 – filtering: type in part of a process command line and only processes whose names match will be shown.
  • F5 – Tree view
  • F6 – Sorting.
  • F7 – Increase the selected process’s priority. This can only be done by the superuser.
  • F8 – Decrease the selected process’s priority.
  • F9 – Kill process.
  • F10 – Quit.

  • F2进入设置界面
  • F3是搜索进程

不区分大小写,可输入进程名搜索,

  • F4 是类似于过滤的功能

输入的筛选条件会一直保存,可以按ESC键清除!

更细致的解释：man htop

帮助： htop -h

linux web服务– curl

最近实验室服务器总是会断网，打算写一个自动登录校园网的脚本，然后就看到了这个curl命令，当然最终登录校园网还是使用的python request库实现的。顺便复习复习curl的用法。

官网: https://curl.se/

cURL无处不在。它几乎隐藏在所有设备中，例如汽车，蓝光播放器等。它通过互联网协议传输任意类型数据。

在本文中，我们将揭开cURL神秘命令行工具的面纱，解释它是如何成为一种通用代码的，并举例说明其用法。

cURL是什么意思？

cURL（客户端URL）是一个开放源代码的命令行工具，也是一个跨平台的库（libcurl），用于在服务器之间传输数据，并分发给几乎所有新的操作系统。cURL编程用于需要通过Internet协议发送或接收数据的几乎任何地方。

cURL支持几乎所有的互联网协议（DICT，FILE，FTP，FTPS，GOPHER，HTTP，HTTPS，IMAP，IMAPS，LDAP，LDAPS，MQTT，POP3，POP3S，RTMP，RTMPS，RTSP，SCP，SFTP，SMB，SMBS，SMTP ，SMTPS，TELNET和TFTP）。

cURL的历史

回到90年代的黑暗时代，那时每个人仍然使用命令行工具，Daniel Sterberg希望开发一个简单的IRC脚本，该脚本可以为聊天室成员转换货币。在1997年，建立互联网协议数据传递基础的方法不多，因此Httpget（基于HTTP的传输的几百行代码）成为cURL的起源。为了纪念其基础，它率先被称为HTTPGET 1.0。

几个月后，开发出了FTP的支持，就不得不删除该名称了。现在，它被称为urlget 2.0。经过几次更新后，在1998年3月30日，名称再次更改为现在众所周知的cURL 3.0。

cURL之前其实还有相似的 wget。我们不会过多介绍细节，但是wget和cURL之间的主要区别在于它们各自的下载功能，例如前者可以从中断的传输中恢复并继续下载。

cURL的作用是什么？

cURL旨在通过互联网协议传输数据。其他所有内容均不在其范围内。它甚至不处理传输的数据，仅执行传输流程。

cURL可用于调试。例如使用“ curl -v https://oxylabs.io ”可以显示一个连接请求的详细输出，包括用户代理，握手数据，端口等详细信息。

可列出和解释的cURL命令选项太多了。幸运的是，可以使用“ curl –help”这个选项，它列出了所有curl命令行的用法，并附有简短的解释性注释。尽管这些命令行用法里没有有关如何使用cURL的相关背景知识介绍，用户也能通过列表知道一些命令行的用法。

可以替代postman工具！！！

curl 是常用的命令行工具，用来请求 Web 服务器。它的名字就是客户端（client）的 URL 工具的意思。它的功能非常强大，命令行参数多达几十种。如果熟练的话，完全可以取代 Postman 这一类的图形界面工具。

1、不带有任何参数时，curl 就是发出 GET 请求。

$ curl https://www.example.com

上面命令向www.example.com发出 GET 请求，服务器返回的内容会在命令行输出。

2、-A参数指定客户端的用户代理标头，即User-Agent。curl 的默认用户代理字符串是curl/[version]。
$ curl -A 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.100 Safari/537.36' https://google.com

上面命令将User-Agent改成 Chrome 浏览器。


$ curl -A '' https://google.com

上面命令会移除User-Agent标头。

也可以通过-H参数直接指定标头，更改User-Agent。


$ curl -H 'User-Agent: php/1.0' https://google.com
3、-b参数用来向服务器发送 Cookie
$ curl -b 'foo=bar' https://google.com

上面命令会生成一个标头Cookie: foo=bar，向服务器发送一个名为foo、值为bar的 Cookie。


$ curl -b 'foo1=bar;foo2=bar2' https://google.com

上面命令发送两个 Cookie。


$ curl -b cookies.txt https://www.google.com

上面命令读取本地文件cookies.txt，里面是服务器设置的 Cookie（参见-c参数），将其发送到服务器。

4、-c参数将服务器设置的 Cookie 写入一个文件。
$ curl -c cookies.txt https://www.google.com

上面命令将服务器的 HTTP 回应所设置 Cookie 写入文本文件cookies.txt。

5、-d参数用于发送 POST 请求的数据体
$ curl -d'login=emma＆password=123'-X POST https://google.com/login
# 或者
$ curl -d 'login=emma' -d 'password=123' -X POST  https://google.com/login

使用-d参数以后，HTTP 请求会自动加上标头Content-Type : application/x-www-form-urlencoded。并且会自动将请求转为 POST 方法，因此可以省略-X POST。

-d参数可以读取本地文本文件的数据，向服务器发送。


$ curl -d '@data.txt' https://google.com/login

上面命令读取data.txt文件的内容，作为数据体向服务器发送。

6、--data-urlencode

参数等同于-D，发送 POST 请求的数据体，区别在于会自动将发送的数据进行 URL 编码。

$ curl --data-urlencode 'comment=hello world' https://google.com/login

上面代码中，发送的数据hello world之间有一个空格，需要进行 URL 编码。

7、-e参数用来设置 HTTP 的标头Referer，表示请求的来源。
curl -e 'https://google.com?q=example' https://www.example.com

上面命令将Referer标头设为https://google.com?q=example。

-H参数可以通过直接添加标头Referer，达到同样效果。


curl -H 'Referer: https://google.com?q=example' https://www.example.com
8、-F参数用来向服务器上传二进制文件。
$ curl -F 'file=@photo.png' https://google.com/profile

上面命令会给 HTTP 请求加上标头Content-Type: multipart/form-data，然后将文件photo.png作为file字段上传。

-F参数可以指定 MIME 类型。


$ curl -F 'file=@photo.png;type=image/png' https://google.com/profile

上面命令指定 MIME 类型为image/png，否则 curl 会把 MIME 类型设为application/octet-stream。

-F参数也可以指定文件名。


$ curl -F 'file=@photo.png;filename=me.png' https://google.com/profile

上面命令中，原始文件名为photo.png，但是服务器接收到的文件名为me.png。

9、-G参数用来构造 URL 的查询字符串
$ curl -G -d 'q=kitties' -d 'count=20' https://google.com/search

上面命令会发出一个 GET 请求，实际请求的 URL 为https://google.com/search?q=kitties&count=20。如果省略--G，会发出一个 POST 请求。

如果数据需要 URL 编码，可以结合--data--urlencode参数。


$ curl -G --data-urlencode 'comment=hello world' https://www.example.com
10、-H参数添加 HTTP 请求的标头。
$ curl -H 'Accept-Language: en-US' https://google.com

上面命令添加 HTTP 标头Accept-Language: en-US。


$ curl -H 'Accept-Language: en-US' -H 'Secret-Message: xyzzy' https://google.com

上面命令添加两个 HTTP 标头。


$ curl -d '{"login": "emma", "pass": "123"}' -H 'Content-Type: application/json' https://google.com/login

上面命令添加 HTTP 请求的标头是Content-Type: application/json，然后用-d参数发送 JSON 数据。

11、-i参数打印出服务器回应的 HTTP 标头。

$ curl -i https://www.example.com

上面命令收到服务器回应后，先输出服务器回应的标头，然后空一行，再输出网页的源码。

12、-I

-I参数向服务器发出 HEAD 请求，然会将服务器返回的 HTTP 标头打印出来。


$ curl -I https://www.example.com

上面命令输出服务器对 HEAD 请求的回应。

--head参数等同于-I。


$ curl --head https://www.example.com
13、-k

-k参数指定跳过 SSL 检测。


$ curl -k https://www.example.com

上面命令不会检查服务器的 SSL 证书是否正确。

14、-L

-L参数会让 HTTP 请求跟随服务器的重定向。curl 默认不跟随重定向。


$ curl -L -d 'tweet=hi' https://api.twitter.com/tweet
15、–limit-rate

--limit-rate用来限制 HTTP 请求和回应的带宽，模拟慢网速的环境。


$ curl --limit-rate 200k https://google.com

上面命令将带宽限制在每秒 200K 字节。

16、-o

-o参数将服务器的回应保存成文件，等同于wget命令。


$ curl -o example.html https://www.example.com

上面命令将www.example.com保存成example.html。

17、-O

-O参数将服务器回应保存成文件，并将 URL 的最后部分当作文件名。


$ curl -O https://www.example.com/foo/bar.html

上面命令将服务器回应保存成文件，文件名为bar.html。

18、-s

-s参数将不输出错误和进度信息。


$ curl -s https://www.example.com

上面命令一旦发生错误，不会显示错误信息。不发生错误的话，会正常显示运行结果。

如果想让 curl 不产生任何输出，可以使用下面的命令。


$ curl -s -o /dev/null https://google.com
19、-S

-S参数指定只输出错误信息，通常与-s一起使用。


$ curl -s -o /dev/null https://google.com

上面命令没有任何输出，除非发生错误。

20、 -u

-u参数用来设置服务器认证的用户名和密码。


$ curl -u 'bob:12345' https://google.com/login

上面命令设置用户名为bob，密码为12345，然后将其转为 HTTP 标头Authorization: Basic Ym9iOjEyMzQ1。

curl 能够识别 URL 里面的用户名和密码。


$ curl https://bob:12345@google.com/login

上面命令能够识别 URL 里面的用户名和密码，将其转为上个例子里面的 HTTP 标头。


$ curl -u 'bob' https://google.com/login

上面命令只设置了用户名，执行后，curl 会提示用户输入密码。

21、-v

-v参数输出通信的整个过程，用于调试。


$ curl -v https://www.example.com

--trace参数也可以用于调试，还会输出原始的二进制数据。


$ curl --trace - https://www.example.com
22、-x

-x参数指定 HTTP 请求的代理。


$ curl -x socks5://james:cats@myproxy.com:8080 https://www.example.com

上面命令指定 HTTP 请求通过myproxy.com:8080的 socks5 代理发出。

如果没有指定代理协议，默认为 HTTP。


$ curl -x james:cats@myproxy.com:8080 https://www.example.com

上面命令中，请求的代理使用 HTTP 协议。

23、-X

-X参数指定 HTTP 请求的方法。


$ curl -X POST https://www.example.com

上面命令对https://www.example.com发出 POST 请求。

RefineNet

论文地址（2016）：RefineNet: Multi-Path Refinement Networks with Identity Mappings for High-Resolution Semantic Segmentation

对于高分辨率的图像分割问题，基于编解码结构的分割网络虽然有效，但因为卷积和池化下采样的存在，特征图在变小的过程会逐渐损失一些细粒度的信息，非常不利于高分辨率图像的像素稠密预测。针对这个问题，此前的各项研究归纳而言提出了如下三点处理方法：

（1）类似于FCN和UNet，直接使用转置卷积上采样来恢复图像像素，但转置卷积对于下采样过程中丢失的低层信息的恢复能力有限。

（2）使用空洞卷积，通过给常规卷积中插入空洞的方式来增大卷积感受野，并且没有缩小图像尺寸，但这种方式计算开销增大，模型运行效率降低，并且空洞卷积作为一种较为粗糙的子采样（sub-sampling），也会存在图像重要信息损失的问题。

（3）使用跳跃连接。类似于UNet中编解码器间的跳跃连接，直接将编码器每一层的特征图连接到解码器上采样结果上，能够对解码图像进行信息补充。

相关研究认为，对于编解码结构而言，所有层次的特征对语义分割都是有帮助的。高层次的特征用于识别图像中的语义信息，低层次的特征则有助于恢复高分辨率图像的边界细节。但如何有效利用中间层次的信息值得进一步探索，前述充分使用跳跃连接的方法或许会更加有效。基于此，研究人员提出了一种针对高分辨率图像语义分割的多层次特征精细化网络：RefineNet。提出RefineNet的论文为RefineNet: Multi-Path Refinement Networks for High-Resolution Semantic Segmentation，该网络基于ResNet结构和跳跃连接，使用多路径的精细化网络结构来获取最佳的分割结果，是高分辨率图像分割的经典网络。

RefineNet简要结构如图5-9所示。RefineNet总体上仍然是编解码结构，编码器部分根据预训练的ResNet网络划分了4个卷积块，与之对应的是级联了4个RefineNet单元到解码器部分。每个编码器ResNet卷积块的输出特征图都会被连接到对应的RefineNet单元，如图中的ResNet-4连接到RefineNet-4单元，到了RefineNet-3单元，除了接收来自ResNet-3的输出外，还需要接收RefineNet-4单元的输出，对于RefineNet-3单元而言就构成了两路径的输入。这样层层向上级联，就构成了多路径的RefineNet。其中编码器中每个特征图到解码器RefineNet单元的连接也叫长程残差连接（long-range residual connections）。

上图仅给出了包含了编码器在内的RefineNet简要结构，而RefineNet单元的具体结构如下图所示。一个RefineNet单元由残差卷积单元（Residual convolution unit，RCU）、多分辨率融合（Multi-resolution Fusion）和链式残差池化（Chained Residual Pooling，CRP）组成。RCU较为简单，就是常规的ResNet结构，每一个输入路径都会经过两次RCU操作后再输出到下一个单元。RCU的跳跃连接在RefineNet中也被称为短程残差连接（short-range residual connections）。紧接着是一个多分辨率特征图融合层，将上一层RCU输出的多路径特征图经过一个33的卷积和上采样操作后进行加总，得到合并后的特征图。最后是一个CRP单元，这也是RefineNet的特色结构，通过3个链式的池化和卷积残差组合来捕捉大图像区域的背景上下文信息。将CRP之后得到特征图再经过一次RCU即可到最终的分割输出。

作为一种针对高分辨率图像的精细化分割网络，RefineNet的结构设计无疑是成功的，当时在多个公开数据集上均取得了SOTA性能表现。这种多路径的精细化网络能够通过迭代精炼的方式将粗糙的语义特征精炼为细粒度的语义特征。其次，基于长短程的残差连接能够使得模型进行端到端的训练，推理时也非常高效。最后，链式残差池化也使得网络能够更好的捕捉大图像的上下文信息。

RefineNet代码完整实现可参考：

https://github.com/DrSleep/refinenet-pytorch

其中关于RCU和CRP模块的实现如下代码所示。

class RCUBlock(nn.Module):
    
    def __init__(self, in_planes, out_planes, n_blocks, n_stages):
        super(RCUBlock, self).__init__()
        for i in range(n_blocks):
            for j in range(n_stages):
                setattr(self, '{}{}'.format(i + 1, stages_suffixes[j]),
                        conv3x3(in_planes if (i == 0) and (j == 0) else out_planes,
                                out_planes, stride=1,
                                bias=(j == 0)))
        self.stride = 1
        self.n_blocks = n_blocks
        self.n_stages = n_stages
    
    def forward(self, x):
        for i in range(self.n_blocks):
            residual = x
            for j in range(self.n_stages):
                x = F.relu(x)
                x = getattr(self, '{}{}'.format(i + 1, stages_suffixes[j]))(x)
            x += residual
        return 
        
class CRPBlock(nn.Module):

    def __init__(self, in_planes, out_planes, n_stages):
        super(CRPBlock, self).__init__()
        for i in range(n_stages):
            setattr(self, '{}_{}'.format(i + 1, 'outvar_dimred'),
                    conv3x3(in_planes if (i == 0) else out_planes,
                            out_planes, stride=1,
                            bias=False))
        self.stride = 1
        self.n_stages = n_stages
        self.maxpool = nn.MaxPool2d(kernel_size=5, stride=1, padding=2)

    def forward(self, x):
        top = x
        for i in range(self.n_stages):
            top = self.maxpool(top)
            top = getattr(self, '{}_{}'.format(i + 1, 'outvar_dimred'))(top)
            x = top + x
        return x

预测效果：

关于NLP多标签文本分类的一些思路–（待更新）

作为刚入门的小白，有必要去记录一些NLP分类任务的小trick，感觉对于涨点提分十分有用。这个文章后面有新的想法会持续更新

华为有一个NLP关于医学电子病历的疾病多标签分类比赛，因为之前比较少去做NLP方向的东西，仅仅是学习过相关rnn、transformer、bert论文呢，所以，参赛纯粹是为了了解了解NLP方向，好在nlp做文本分类算是比较简单的下游任务，但在参赛过程中，会发现，其实对于文本分类来说，基本的bert-base的效果不是很好，但其实感觉不是出在模型架构方面，对于简单的分类任务，一个12层的bert应该适足以胜任了，因此将注意力不要过多的放在模型结构上。

任务说明

本赛题是利用病人电子病历文本信息推断出其可能患有疾病的疾病诊断任务。电子病历文本信息主要包括病人的性别、年龄、主诉、现病史、既往史、体格检查和辅助检查。标签信息为病人的出院诊断疾病。本赛题任务需要根据病人的电子病历文本信息推断出病人所患有的全部疾病。（注：病人的出院诊断疾病并不是单一的） 

模型输出格式：

{ “ZY000001”: [“高血压”, “肺气肿”, “先天性心脏病”]}

评分标准

本赛题采用macro F1作为评价指标。评价指标计算公式如下：

对于每一个预测的疾病有真阳性（True Positive，TP），假阳性（False Positive，FP），假阴性（False Negative），真阴性（True Negative），n表示n种疾病。

这个得分最高在 0.83左右。我也试了几次，但到0.57就没再动过了…..，后面准备去尝试下下面的方法，看看有啥效果吗。

思路：

在github中找到一个分类会议任务的比赛ppt模型讲解：

https://github.com/TJBioMedNLP/chip2019task3

废话说完，来点或许能提分的干货：

数据方面：

1、数据清洗（很多脏数据）、数据增强

说实话，感觉这个比赛的要点就是数据处理，想提分就看你的数据的好坏，现在是真的意识到数据处理对于一个模型的影响之大了，后面要着重关注下这方面了。

本次提供的训练集中出现了一些不需要诊断的疾病：睾丸鞘膜积液、宫颈炎性疾病、口腔粘膜溃疡、头部外伤、急性阴道炎、女性盆腔炎、急性气管炎，需要自己去将该类数据清洗，另外，通过数据统计分析，可以获得训练集中各个label的数量严重不平衡，如何处理也是一个问题，是否可以通过数据集增强，提高某些类别的测试数据。

另外 性别、年龄、主诉、现病史、既往史、体格检查和辅助检查 等长度会超出模型的最大长度，如何解决、最大化利用上述信息也是一个问题。我做过对这些数据做过分析，对于 性别、年龄、主诉、现病史、既往史、体格检查和辅助检查 等 统计过平均长度、最大最小长度，从几十到几百不等。另外，去看下数据集就可以看到，有大量的标点符号和短语。另外，据说emr_id这个信息也是一个重要的信息？？？我一脸震惊。此外年龄和性别也会影响。

其他：

1、如果训练时使用文本长度为n，测试使用比n长一些的长度，可以涨点分

2、模型预训练会提分（或者找相关领域预训练模型）

这里我找了两个预训练模型：

https://huggingface.co/trueto/medbert-base-chinese

https://huggingface.co/nghuyong/ernie-health-zh

3、增大训练时输入编码长度（文本序列长度），当然，需要显卡的性能支持

all_tokens = self.tokenizer.encode_plus(content, max_length=pad_size, padding=”max_length”, truncation=True)

可以提高max_length的大小，但是比较吃显卡。

4、交叉验证

交叉验证经常用于给定的数据集训练、评估和最终选择机器学习模型，因为它有助于评估模型的结果在实践中如何推广到独立的数据集，最重要的是，交叉验证已经被证明产生比其他方法更低的偏差的模型。重复的k折交叉验证，主要是会重复进行n次的k折交叉验证，这样会产生n次结果，一般通过平均方法或者（投票规则）得到最后的结果

　第一种是简单交叉验证，所谓的简单，是和其他交叉验证方法相对而言的。首先，我们随机的将样本数据分为两部分（比如： 70%的训练集，30%的测试集），然后用训练集来训练模型，在测试集上验证模型及参数。接着，我们再1把样本打乱，重新选择训练集和测试集，继续训练数据和检验模型。最后我们选择损失函数评估最优的模型和参数。

选择分层k-折交叉验证：

分层采样就是在每一份子集中都保持原始数据集的类别比例，保证采样数据跟原始数据的类别分布保持一致，该方法在有效的平衡方差和偏差。当针对不平衡数据时，使用随机的K-fold交叉验证，可能出现在子集中叫少的类别的分布与原始类别分布不一致。因此，针对不平衡数据往往使用stratified k-fold交叉验证。

当训练数据集不能代表整个数据集分布是，这时候使用stratified k折交叉验证可能不是好的方法，而可能比较适合使用简单的重复随机k折交叉验证。

  • 1.把整个数据集随机划分成k份
  • 2.用其中k-1份训练模型，然后用第k份验证模型
  • 3.记录每个预测结果获得的误差
  • 4.重复这个过程，知道每份数据都做过验证集
  • 5.记录下的k个误差的平均值，被称为交叉验证误差。可以被用做衡量模型性能的标准
>>> from sklearn.model_selection import StratifiedKFold
>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4]])
>>> y = np.array([0, 0, 1, 1])
>>> skf = StratifiedKFold(n_splits=2)
>>> skf.get_n_splits(X, y)
2
>>> print(skf)  
StratifiedKFold(n_splits=2, random_state=None, shuffle=False)
>>> for train_index, test_index in skf.split(X, y):
...    print("TRAIN:", train_index, "TEST:", test_index)
...    X_train, X_test = X[train_index], X[test_index]
...    y_train, y_test = y[train_index], y[test_index]
TRAIN: [1 3] TEST: [0 2]
TRAIN: [0 2] TEST: [1 3]

具体来说：

以k-fold CV为例：仍然是把原始数据集分成训练集和测试集，但是训练模型的时候不使用测试集。最常见的一个叫做k_fold CV。

  • 具体来说就是把训练集平分为k个fold，其中每个fold依次作为测试集、余下的作为训练集，进行k次训练，得到共计k组参数。取k组参数的均值作为模型的最终参数。
  1. 优点：充分压榨了数据集的价值。在样本集不够大的情况下尤其珍贵。
  2. 缺点：运算起来花时间。

K折交叉验证训练单个模型：

通过对 k 个不同分组训练的结果进行平均来减少方差，因此模型的性能对数据的划分就不那么敏感，经过多次划分数据集，大大降低了结果的偶然性，从而提高了模型的准确性。具体做法如下：

  • step1:不重复抽样将原始数据随机分为 k 份。
  • step2:每一次挑选其中 1 份作为验证集，剩余 k-1 份作为训练集用于模型训练。一共训练k个模型。
  • step3：在每个训练集上训练后得到一个模型，用这个模型在测试集上测试，计算并保存模型的评估指标，
  • step4：计算 k 组测试结果的平均值作为模型最终在测试集上的预测值，求k 个模型评估指标的平均值，并作为当前 k 折交叉验证下模型的性能指标。

6、模型融合

模型融合：通过融合多个不同的模型，可能提升机器学习的性能。这一方法在各种机器学习比赛中广泛应用， 也是在比赛的攻坚时刻冲刺Top的关键。而融合模型往往又可以从模型结果，模型自身，样本集等不同的角度进行融合。即多个模型的组合可以改善整体的表现。集成模型是一种能在各种的机器学习任务上提高准确率的强有力技术。

模型融合是比赛后期一个重要的环节，大体来说有如下的类型方式：

1. 简单加权融合：

  • 回归（分类概率）：算术平均融合（Arithmetic mean），几何平均融合（Geometric mean）；
  • 分类：投票（Voting）；
  • 综合：排序融合(Rank averaging)，log融合。

2. stacking/blending:

  • 构建多层模型，并利用预测结果再拟合预测。

3. boosting/bagging:

  • 多树的提升方法，在xgboost，Adaboost,GBDT中已经用到。

平均法（Averaging）

基本思想：对于回归问题，一个简单直接的思路是取平均。稍稍改进的方法是进行加权平均。权值可以用排序的方法确定，举个例子，比如A、B、C三种基本模型，模型效果进行排名，假设排名分别是1，2，3，那么给这三个模型赋予的权值分别是3/6、2/6、1/6。

平均法或加权平均法看似简单，其实后面的高级算法也可以说是基于此而产生的，Bagging或者Boosting都是一种把许多弱分类器这样融合成强分类器的思想。

简单算术平均法：Averaging方法就多个模型预测的结果进行平均。这种方法既可以用于回归问题，也可以用于对分类问题的概率进行平均。

加权算术平均法：这种方法是平均法的扩展。考虑不同模型的能力不同，对最终结果的贡献也有差异，需要用权重来表征不同模型的重要性importance。

投票法（voting）

基本思想：假设对于一个二分类问题，有3个基础模型，现在我们可以在这些基学习器的基础上得到一个投票的分类器，把票数最多的类作为我们要预测的类别。

绝对多数投票法：最终结果必须在投票中占一半以上。

相对多数投票法：最终结果在投票中票数最多。

加权投票法：每个弱学习器的分类票数乘以权重，并将各个类别的加权票数求和，最大值对应的类别即最终类别。

硬投票：对多个模型直接进行投票，不区分模型结果的相对重要度，最终投票数最多的类为最终被预测的类。

软投票：增加了设置权重的功能，可以为不同模型设置不同权重，进而区别模型不同的重要度。

堆叠法（Stacking）

基本思想

stacking 就是当用初始训练数据学习出若干个基学习器后，将这几个学习器的预测结果作为新的训练集，来学习一个新的学习器。对不同模型预测的结果再进行建模。

将个体学习器结合在一起的时候使用的方法叫做结合策略。对于分类问题，我们可以使用投票法来选择输出最多的类。对于回归问题，我们可以将分类器输出的结果求平均值。

上面说的投票法和平均法都是很有效的结合策略，还有一种结合策略是使用另外一个机器学习算法来将个体机器学习器的结果结合在一起，这个方法就是Stacking。在stacking方法中，我们把个体学习器叫做初级学习器，用于结合的学习器叫做次级学习器或元学习器（metalearner），次级学习器用于训练的数据叫做次级训练集。次级训练集是在训练集上用初级学习器得到的。

  • step1：训练T个初级学习器，要使用交叉验证的方法在Train Set上面训练（因为第二阶段建立元学习器的数据是初级学习器输出的，如果初级学习器的泛化能力低下，元学习器也会过拟合）
  • step2：T个初级学习器在Train Set上输出的预测值，作为元学习器的训练数据D，有T个初级学习器，D中就有T个特征。D的label和训练初级学习器时的label一致。
  • step3：T个初级学习器在Test Set上输出的预测值，作为训练元学习器时的测试集，同样也是有T个模型就有T个特征。
  • step4：训练元学习器，元学习器训练集D的label和训练初级学习器时的label一致。

混合法（Blending）

基本思想：Blending采用了和stacking同样的方法，不过只从训练集中选择一个fold的结果，再和原始特征进行concat作为元学习器meta learner的特征，测试集上进行同样的操作。

把原始的训练集先分成两部分，比如70%的数据作为新的训练集，剩下30%的数据作为测试集。

  • 第一层，我们在这70%的数据上训练多个模型，然后去预测那30%数据的label，同时也预测test集的label。
  • 在第二层，我们就直接用这30%数据在第一层预测的结果做为新特征继续训练，然后用test集第一层预测的label做特征，用第二层训练的模型做进一步预测。

Blending训练过程：

  1. 整个训练集划分成训练集training sets和验证集validation sets两个部分；
  2. 在training sets上训练模型；
  3. 在validation sets和test sets上得到预测结果；
  4. 将validation sets的原始特征和不同基模型base model预测得到的结果作为新的元学习器meta learner的输入，进行训练 ；
  5. 使用训练好的模型meta learner在test sets以及在base model上的预测结果上进行预测，得到最终结果。

Stacking与Blending的对比：

优点在于：

  • blending比stacking简单，因为不用进行k次的交叉验证来获得stacker feature
  • blending避开了一个信息泄露问题：generlizers和stacker使用了不一样的数据集

缺点在于：

  • blending使用了很少的数据（第二阶段的blender只使用training set10%的量）
  • blender可能会过拟合
  • stacking使用多次的交叉验证会比较稳健

Bagging

基本思想：Bagging基于bootstrap（自采样），也就是有放回的采样。训练子集的大小和原始数据集的大小相同。Bagging的技术使用子集来了解整个样本集的分布，通过bagging采样的子集的大小要小于原始集合。

  • 采用bootstrap的方法基于原始数据集产生大量的子集
  • 基于这些子集训练弱模型base model
  • 模型是并行训练并且相互独立的
  • 最终的预测结果取决于多个模型的预测结果

Bagging是一种并行式的集成学习方法，即基学习器的训练之间没有前后顺序可以同时进行，Bagging使用“有放回”采样的方式选取训练集，对于包含m个样本的训练集，进行m次有放回的随机采样操作，从而得到m个样本的采样集，这样训练集中有接近36.8%的样本没有被采到。按照相同的方式重复进行，我们就可以采集到T个包含m个样本的数据集，从而训练出T个基学习器，最终对这T个基学习器的输出进行结合。

Boosting

基础思想：Boosting是一种串行的工作机制，即个体学习器的训练存在依赖关系，必须一步一步序列化进行。Boosting是一个序列化的过程，后续模型会矫正之前模型的预测结果。也就是说，之后的模型依赖于之前的模型。

其基本思想是：增加前一个基学习器在训练训练过程中预测错误样本的权重，使得后续基学习器更加关注这些打标错误的训练样本，尽可能纠正这些错误，一直向下串行直至产生需要的T个基学习器，Boosting最终对这T个学习器进行加权结合，产生学习器委员会。

Boosting训练过程：

  • 基于原始数据集构造子集
  • 初始的时候，所有的数据点都给相同的权重
  • 基于这个子集创建一个基模型
  • 使用这个模型在整个数据集上进行预测
  • 基于真实值和预测值计算误差
  • 被预测错的观测值会赋予更大的权重
  • 再构造一个模型基于之前预测的误差进行预测，这个模型会尝试矫正之前的模型
  • 类似地，构造多个模型，每一个都会矫正之前的误差
  • 最终的模型（strong learner）是所有弱学习器的加权融合

7、损失函数,注意不同类别的权重（使用F1_loss、Hamming Loss、数据类别分布不均，如何解决长尾分布（加权损失、先验权重））

相关论文: sigmoidF1: A Smooth F1 Score Surrogate Loss for Multilabel Classification

平时我们在做多标签分类，或者是多分类的时候，经常使用的loss函数一般是binary_crossentropy（也就是log_loss)或者是categorical_crossentropy,不过交叉熵其实还是有点问题的,在多标签分类的问题里，交叉熵并非是最合理的损失函数。在多标签分类的问题中，我们最终评价往往会选择F1分数作为评价指标，那么是否能直接将F1-score制作成为一个loss函数呢？当然是可以的。

在多分类/多标签分类中，F1-score有两种衍生格式，分别是micro-F1和macro-F1。是两种不同的计算方式。

micro-F1是先计算先拿总体样本来计算出TP、TN、FP、FN的值，再使用这些值计算出percision和recall，再来计算出F1值。

macro-F1则是先对每一种分类，视作二分类，计算其F1值，最后再对每一个分类进行简单平均。

简单的记的话其实是这样的，micro（微观）与macro(宏观)的含义其实是，micro-F1是在样本的等级上做平均，是最小颗粒度上的平均了，所以是微观。macro-F1是在每一个分类的层面上做平均，每一个分类都包含很多样本，所以相对是宏观。

作为loss函数的F1

F1-score改造成loss函数相对较为简单，F1是范围在0~1之间的指标，越大代表性能越好，在作为loss时只需要取（1-F1）即可。

一下是keras中的实现：

（这里的K就是keras的后端，一般来说就是tensorflow）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16		K = keras.backend
def f1_loss(y_true, y_pred):
#计算tp、tn、fp、fn
tp = K.sum(K.cast(y_true*y_pred, ‘float’), axis=0)
tn = K.sum(K.cast((1-y_true)*(1-y_pred), ‘float’), axis=0)
fp = K.sum(K.cast((1-y_true)*y_pred, ‘float’), axis=0)
fn = K.sum(K.cast(y_true*(1-y_pred), ‘float’), axis=0)

#percision与recall，这里的K.epsilon代表一个小正数，用来避免分母为零
p = tp / (tp + fp + K.epsilon())
r = tp / (tp + fn + K.epsilon())

#计算f1
f1 = 2*p*r / (p+r+K.epsilon())
f1 = tf.where(tf.is_nan(f1), tf.zeros_like(f1), f1)#其实就是把nan换成0
return 1 – K.mean(f1)

这个函数可以直接在keras模型编译时使用，如下：

1
2
3
4		# 类似这样
model.compile(optimizer=tf.train.AdamOptimizer(0.003),
loss=f1_loss,
metrics=[‘acc’,’mae’])
 
def f1_loss(predict, target):
    predict = torch.sigmoid(predict)
    predict = torch.clamp(predict * (1-target), min=0.01) + predict * target
    tp = predict * target
    tp = tp.sum(dim=0)
    precision = tp / (predict.sum(dim=0) + 1e-8)
    recall = tp / (target.sum(dim=0) + 1e-8)
    f1 = 2 * (precision * recall / (precision + recall + 1e-8))
    return 1 - f1.mean()

8、考虑将多分类 变成多个二分类任务

9、除了bert模型，还可以尝试Performer、ernie-health

Performer 是ICLR 2021的新paper，在处理长序列预测方面有非常不错的结果，速度快，内存小，在LRA（long range arena 一个统一的benchmark）上综合得分不错。

论文：https://arxiv.org/pdf/2009.14794.pdf

ernie-health ：Building Chinese Biomedical Language Models via Multi-Level Text Discrimination
中文题目：基于多层次文本辨析构建中文生物医学语言模型
论文地址：https://arxiv.org/pdf/2110.07244.pdf
领域：自然语言处理，生物医学
发表时间：2021
作者：Quan Wang等，百度
模型下载：https://huggingface.co/nghuyong/ernie-health-zh
模型介绍：https://github.com/PaddlePaddle/Research/tree/master/KG/eHealth
模型代码：https://github.com/PaddlePaddle/PaddleNLP/tree/develop/model_zoo/ernie-health

10、NLP中的对抗训练 （添加的扰动是微小）

  1. 提高模型应对恶意对抗样本时的鲁棒性；
  2. 作为一种regularization，减少overfitting，提高泛化能力。

对抗训练其实是“对抗”家族中防御的一种方式，其基本的原理呢，就是通过添加扰动构造一些对抗样本，放给模型去训练，以攻为守，提高模型在遇到对抗样本时的鲁棒性，同时一定程度也能提高模型的表现和泛化能力。

那么，什么样的样本才是好的对抗样本呢？对抗样本一般需要具有两个特点：

  1. 相对于原始输入，所添加的扰动是微小的；
  2. 能使模型犯错。

NLP中的两种对抗训练 + PyTorch实现

a. Fast Gradient Method（FGM）

上面我们提到，Goodfellow在15年的ICLR [7] 中提出了Fast Gradient Sign Method（FGSM），随后，在17年的ICLR [9]中，Goodfellow对FGSM中计算扰动的部分做了一点简单的修改。假设输入的文本序列的embedding vectors [v1,v2,…,vT] 为 x ，embedding的扰动为：

实际上就是取消了符号函数，用二范式做了一个scale，需要注意的是：这里的norm计算的是，每个样本的输入序列中出现过的词组成的矩阵的梯度norm。原作者提供了一个TensorFlow的实现 [10]，在他的实现中，公式里的 x 是embedding后的中间结果（batch_size, timesteps, hidden_dim），对其梯度 g 的后面两维计算norm，得到的是一个(batch_size, 1, 1)的向量 ||g||2 。为了实现插件式的调用，笔者将一个batch抽象成一个样本，一个batch统一用一个norm，由于本来norm也只是一个scale的作用，影响不大。实现如下：

import torch
class FGM():
    def __init__(self, model):
        self.model = model
        self.backup = {}

    def attack(self, epsilon=1., emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                self.backup[name] = param.data.clone()
                norm = torch.norm(param.grad)
                if norm != 0 and not torch.isnan(norm):
                    r_at = epsilon * param.grad / norm
                    param.data.add_(r_at)

    def restore(self, emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name: 
                assert name in self.backup
                param.data = self.backup[name]
        self.backup = {}

需要使用对抗训练的时候，只需要添加五行代码：

# 初始化
fgm = FGM(model)
for batch_input, batch_label in data:
    # 正常训练
    loss = model(batch_input, batch_label)
    loss.backward() # 反向传播，得到正常的grad
    # 对抗训练
    fgm.attack() # 在embedding上添加对抗扰动
    loss_adv = model(batch_input, batch_label)
    loss_adv.backward() # 反向传播，并在正常的grad基础上，累加对抗训练的梯度
    fgm.restore() # 恢复embedding参数
    # 梯度下降，更新参数
    optimizer.step()
    model.zero_grad()

PyTorch为了节约内存，在backward的时候并不保存中间变量的梯度。因此，如果需要完全照搬原作的实现，需要用register_hook接口[11]将embedding后的中间变量的梯度保存成全局变量，norm后面两维，计算出扰动后，在对抗训练forward时传入扰动，累加到embedding后的中间变量上，得到新的loss，再进行梯度下降。

b. Projected Gradient Descent（PGD）

内部max的过程，本质上是一个非凹的约束优化问题，FGM解决的思路其实就是梯度上升，那么FGM简单粗暴的“一步到位”，是不是有可能并不能走到约束内的最优点呢？当然是有可能的。于是，一个很intuitive的改进诞生了：Madry在18年的ICLR中[8]，提出了用Projected Gradient Descent（PGD）的方法，简单的说，就是“小步走，多走几步”，如果走出了扰动半径为 ϵ 的空间，就映射回“球面”上，以保证扰动不要过大：

import torch
class PGD():
    def __init__(self, model):
        self.model = model
        self.emb_backup = {}
        self.grad_backup = {}

    def attack(self, epsilon=1., alpha=0.3, emb_name='emb.', is_first_attack=False):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name:
                if is_first_attack:
                    self.emb_backup[name] = param.data.clone()
                norm = torch.norm(param.grad)
                if norm != 0 and not torch.isnan(norm):
                    r_at = alpha * param.grad / norm
                    param.data.add_(r_at)
                    param.data = self.project(name, param.data, epsilon)

    def restore(self, emb_name='emb.'):
        # emb_name这个参数要换成你模型中embedding的参数名
        for name, param in self.model.named_parameters():
            if param.requires_grad and emb_name in name: 
                assert name in self.emb_backup
                param.data = self.emb_backup[name]
        self.emb_backup = {}

    def project(self, param_name, param_data, epsilon):
        r = param_data - self.emb_backup[param_name]
        if torch.norm(r) > epsilon:
            r = epsilon * r / torch.norm(r)
        return self.emb_backup[param_name] + r

    def backup_grad(self):
        for name, param in self.model.named_parameters():
            if param.requires_grad:
                self.grad_backup[name] = param.grad.clone()

    def restore_grad(self):
        for name, param in self.model.named_parameters():
            if param.requires_grad:
                param.grad = self.grad_backup[name]

使用的时候，要麻烦一点：

pgd = PGD(model)
K = 3
for batch_input, batch_label in data:
    # 正常训练
    loss = model(batch_input, batch_label)
    loss.backward() # 反向传播，得到正常的grad
    pgd.backup_grad()
    # 对抗训练
    for t in range(K):
        pgd.attack(is_first_attack=(t==0)) # 在embedding上添加对抗扰动, first attack时备份param.data
        if t != K-1:
            model.zero_grad()
        else:
            pgd.restore_grad()
        loss_adv = model(batch_input, batch_label)
        loss_adv.backward() # 反向传播，并在正常的grad基础上，累加对抗训练的梯度
    pgd.restore() # 恢复embedding参数
    # 梯度下降，更新参数
    optimizer.step()
    model.zero_grad()

实验对照

为了说明对抗训练的作用，笔者选了四个GLUE中的任务进行了对照试验。实验代码是用的Huggingface的transfomers/examples/run_glue.py [12]，超参都是默认的，对抗训练用的也是相同的超参。

除了监督训练，对抗训练还可以用在半监督任务中，尤其对于NLP任务来说，很多时候输入的无监督文本多的很，但是很难大规模地进行标注，Distributional Smoothing with Virtual Adversarial Training. https://arxiv.org/abs/1507.00677 提到的 Virtual Adversarial Training进行半监督训练。

11、Pseudo Labeling（伪标签）提高模型的分类效果

简而言之，Pseudo Labeling将测试集中判断结果正确的置信度高的样本加入到训练集中，从而模拟一部分人类对新对象进行判断推演的过程。效果比不上人脑那么好，但是在监督学习问题中，Pseudo Labeling几乎是万金油，几乎能够让你模型各个方面的表现都得到提升。

  1. 使用原始训练集训练并建立模型
  2. 使用训练好的模型对测试集进行分类
  3. 将预测正确置信度高的样本加入到训练集中
  4. 使用结合了部分测试集样本的新训练集再次训练模型
  5. 使用新模型再次进行预测

总之：提分点很多，但能否有效以及能否实现又是另一个事情了，毕竟有时候是否有效也取决于数据集，毕竟缘分，妙不可言~，后续我会抽时间将上面的tricks都尝试尝试。

区域卷积神经⽹络（R-CNN）系列

来自：动手学深度学习

视频讲解：Faster R-CNN原理 、源码解析

1、R-CNN

R-CNN ⾸先从输⼊图像中选取若⼲（例如2000个）提议区域（如锚框也是⼀种选取方法），并标注它们的类别和边界框（如偏移量）。[Girshick et al., 2014] 然后，⽤卷积神经⽹络对每个提议区域进⾏前向计算以抽取其特征。接下来，我们⽤每个提议区域的特征来预测类别和边界框。

具体来说，R-CNN包括以下四个步骤：

  1. 对输⼊图像使⽤ 选择性搜索来选取多个⾼质量的提议区域 [Uijlings et al., 2013] 。这些提议区域通常是在多个尺度下选取的，并具有不同的形状和⼤小。每个提议区域都将被标注类别和真实边界框。
  2. 选择⼀个预训练的卷积神经⽹络，并将其在输出层之前截断。将每个提议区域变形为⽹络需要的输⼊尺⼨，并通过前向计算输出抽取的提议区域特征。
  3. 将每个提议区域的特征连同其标注的类别作为⼀个样本。训练多个⽀持向量机对⽬标分类，其中每个⽀持向量机⽤来判断样本是否属于某⼀个类别。
  4. 将每个提议区域的特征连同其标注的边界框作为⼀个样本，训练线性回归模型来预测真实边界框。
  • 尽管 R-CNN 模型通过预训练的卷积神经⽹络有效地抽取了图像特征，但它的速度很慢。想象⼀下，我们可能从⼀张图像中选出上千个提议区域，这需要上千次的卷积神经⽹络的前向计算来执⾏⽬标检测。这种庞⼤的计算量使得 R-CNN 在现实世界中难以被⼴泛应⽤。

2、Fast R-CNN

R-CNN 的主要性能瓶颈在于，对每个提议区域，卷积神经⽹络的前向计算是独⽴的，而没有共享计算。由于这些区域通常有重叠，独⽴的特征抽取会导致重复的计算。Fast R-CNN [Girshick, 2015] 对 R-CNN 的主要改进之⼀，是仅在整张图象上执⾏卷积神经⽹络的前向计算。

它的主要计算如下：

  1. 与 R-CNN 相⽐，Fast R-CNN ⽤来提取特征的卷积神经⽹络的输⼊是整个图像，而不是各个提议区域。此外，这个⽹络通常会参与训练。设输⼊为⼀张图像，将卷积神经⽹络的输出的形状记为 1×c×h1×w1。
  2. 假设选择性搜索⽣成了n个提议区域。这些形状各异的提议区域在卷积神经⽹络的输出上分别标出了形状各异的兴趣区域。然后，这些感兴趣的区域需要进⼀步抽取出形状相同的特征（⽐如指定⾼度h2和宽度w2），以便于连结后输出。为了实现这⼀⽬标，Fast R-CNN 引⼊了 兴趣区域 (RoI) 池化层：将卷积神经⽹络的输出和提议区域作为输⼊，输出连结后的各个提议区域抽取的特征，形状为n × c × h2 × w2。
  3. 通过全连接层将输出形状变换为n × d，其中超参数d取决于模型设计。
  4. 预测n个提议区域中每个区域的类别和边界框。更具体地说，在预测类别和边界框时，将全连接层的输出分别转换为形状为 n × q（q 是类别的数量）的输出和形状为 n × 4 的输出。其中预测类别时使⽤softmax 回归。

在Fast R-CNN 中提出的兴趣区域汇聚层与 6.5节 中介绍的汇聚层有所不同。在汇聚层中，我们通过设置池化窗口、填充和步幅的⼤小来间接控制输出形状。而兴趣区域汇聚层对每个区域的输出形状是可以直接指定的。例如，指定每个区域输出的⾼和宽分别为 h2 和 w2。对于任何形状为 h × w 的兴趣区域窗口，该窗口将被划分为 h2 × w2 ⼦窗口⽹格，其中每个⼦窗口的⼤小约为(h/h2) × (w/w2)。在实践中，任何⼦窗口的⾼度和宽度都应向上取整，其中的最⼤元素作为该⼦窗口的输出。因此，兴趣区域汇聚层可从形状各异的兴趣区域中均抽取出形状相同的特征。

3、Faster R-CNN

为了较精确地检测⽬标结果，Fast R-CNN 模型通常需要在选择性搜索中⽣成⼤量的提议区域。Faster R-CNN [Ren et al., 2015] 提出将选择性搜索替换为 区域提议⽹络（region proposal network），从而减少提议区域的⽣成数量，并保证⽬标检测的精度。

与Fast R-CNN 相⽐，Faster R-CNN 只将⽣成提议区域的⽅法从选择性
搜索改为了区域提议⽹络，模型的其余部分保持不变。具体来说，区域提议⽹络的计算步骤如下：

  1. 使⽤填充为1的 3 × 3 的卷积层变换卷积神经⽹络的输出，并将输出通道数记为 c。这样，卷积神经⽹络为图像抽取的特征图中的每个单元均得到⼀个⻓度为 c 的新特征。
  2. 以特征图的每个像素为中⼼，⽣成多个不同⼤小和宽⾼⽐的锚框并标注它们。
  3. 使⽤锚框中⼼单元⻓度为 c 的特征，分别预测该锚框的⼆元类别（含⽬标还是背景）和边界框。
  4. 使⽤⾮极⼤值抑制，从预测类别为⽬标的预测边界框中移除相似的结果。最终输出的预测边界框即是兴趣区域汇聚层所需的提议区域。

值得⼀提的是，区域提议⽹络作为 Faster R-CNN 模型的⼀部分，是和整个模型⼀起训练得到的。换句话说，Faster R-CNN 的⽬标函数不仅包括⽬标检测中的类别和边界框预测，还包括区域提议⽹络中锚框的⼆元类别和边界框预测。作为端到端训练的结果，区域提议⽹络能够学习到如何⽣成⾼质量的提议区域，从而在减少了从数据中学习的提议区域的数量的情况下，仍保持⽬标检测的精度

4、Mask R-CNN

如果在训练集中还标注了每个⽬标在图像上的像素级位置，那么 Mask R-CNN [He et al., 2017] 能够有效地利⽤这些详尽的标注信息进⼀步提升⽬标检测的精度。

如 图13.8.5 所⽰，Mask R-CNN 是基于 Faster R-CNN 修改而来的。具体来说，Mask R-CNN 将兴趣区域汇聚层替换为了 兴趣区域 (RoI) 对⻬层，使⽤ 双线性插值（bilinear interpolation）来保留特征图上的空间信息，从而更适于像素级预测。兴趣区域对⻬层的输出包含了所有与兴趣区域的形状相同的特征图。它们不仅被⽤于预测每个兴趣区域的类别和边界框，还通过额外的全卷积⽹络预测⽬标的像素级位置。

补充：ROI Align 和 ROI Pooling

这两个都是用在rpn之后的。具体来说，从feature map上经过RPN得到一系列的proposals，大概2k个，这些bbox大小不等，如何将这些bbox的特征进行统一表示就变成了一个问题。即需要找一个办法从大小不等的框中提取特征使输出结果是等长的。最开始目标检测模型Faster RCNN中用了一个简单粗暴的办法，叫ROI Pooling。该方式在语义分割这种精细程度高的任务中，不够精准，由此发展来了ROI Align。

ROI Pooling：

假如现在有一个8×8的feature map，现在希望得到2×2的输出，有一个bbox坐标为[0,3,7,8]。

这个bbox的w=7，h=5，如果要等分成四块是做不到的，因此在ROI Pooling中会进行取整。就有了上图看到的h被分割为2,3，w被分割成3,4。这样之后在每一块(称为bin)中做max pooling，可以得到下图的结果。

这样就可以将任意大小bbox转成2×2表示的feature。

ROI Pooling需要取整，这样的取整操作进行了两次，一次是得到bbox在feature map上的坐标时。

例如：原图上的bbox大小为665×665，经backbone后，spatial scale=1/32。因此bbox也相应应该缩小为665/32=20.78，但是这并不是一个真实的pixel所在的位置，因此这一步会取为20。0.78的差距反馈到原图就是0.78×32=25个像素的差距。如果是大目标这25的差距可能看不出来，但对于小目标而言差距就比较巨大了。

ROI Align

因此有人提出不需要进行取整操作，如果计算得到小数，也就是没有落到真实的pixel上，那么就用最近的pixel对这一点虚拟pixel进行双线性插值，得到这个“pixel”的值。

  1. 将bbox区域按输出要求的size进行等分，很可能等分后各顶点落不到真实的像素点上
  2. 没关系，在每个bin中再取固定的4个点(作者实验后发现取4效果较好)，也就是图二右侧的蓝色点
  3. 针对每一个蓝点，距离它最近的4个真实像素点的值加权(双线性插值)，求得这个蓝点的值
  4. 一个bin内会算出4个新值，在这些新值中取max，作为这个bin的输出值
  5. 最后就能得到2×2的输出

ROI Pooling和ROI Align

这两个都是用在rpn之后的。具体来说，从feature map上经过RPN得到一系列的proposals，大概2k个，这些bbox大小不等，如何将这些bbox的特征进行统一表示就变成了一个问题。即需要找一个办法从大小不等的框中提取特征使输出结果是等长的。

最开始目标检测模型Faster RCNN中用了一个简单粗暴的办法，叫ROI Pooling。

该方式在语义分割这种精细程度高的任务中，不够精准，由此发展来了ROI Align。

今天就总结下两者的思想。

ROI Pooling

假如现在有一个8×8的feature map，现在希望得到2×2的输出，有一个bbox坐标为[0,3,7,8]。

这个bbox的w=7，h=5，如果要等分成四块是做不到的，因此在ROI Pooling中会进行取整。就有了上图看到的h被分割为2,3，w被分割成3,4。这样之后在每一块(称为bin)中做max pooling，可以得到下图的结果。

这样就可以将任意大小bbox转成2×2表示的feature。

ROI Pooling需要取整，这样的取整操作进行了两次，一次是得到bbox在feature map上的坐标时。

例如：原图上的bbox大小为665×665，经backbone后，spatial scale=1/32。因此bbox也相应应该缩小为665/32=20.78，但是这并不是一个真实的pixel所在的位置，因此这一步会取为20。0.78的差距反馈到原图就是0.78×32=25个像素的差距。如果是大目标这25的差距可能看不出来，但对于小目标而言差距就比较巨大了。

图1

ROI Align

因此有人提出不需要进行取整操作，如果计算得到小数，也就是没有落到真实的pixel上，那么就用最近的pixel对这一点虚拟pixel进行双线性插值，得到这个“pixel”的值。

具体做法如下图所示：

  1. 将bbox区域按输出要求的size进行等分，很可能等分后各顶点落不到真实的像素点上
  2. 没关系，在每个bin中再取固定的4个点(作者实验后发现取4效果较好)，也就是图二右侧的蓝色点
  3. 针对每一个蓝点，距离它最近的4个真实像素点的值加权(双线性插值)，求得这个蓝点的值
  4. 一个bin内会算出4个新值，在这些新值中取max，作为这个bin的输出值
  5. 最后就能得到2×2的输出

船长

赵雷

请告诉我寂寞的时长
那里是否铺满花儿的香
在海上漂了很久会觉得岸上很晃
雨打湿了衣裳就适应了海水的凉

海北的路上没有信号
海北的灯光比繁星亮
海北的机车妹匆匆忙
海北的空调像是冬天一样冷得让我
缩成一只小鸟 缩成一只小鸟
可是没有人知道
我是刚刚经过暴风雨回到岸上的船长
会到岸的船长
而我却迷失方向
像是气球一样四处撞

槟榔一定配香烟才够爽
海北的男孩讲话有些娘娘腔
尽管看上去他们更强壮
但是我有胆量去征服海洋

上天没有给我华丽的皮囊
至今学不会打领结穿西装
海北没有适合我的衣裳
我喜欢光着膀子露出胸膛

吃饱的乌鸦在叫
迟到的学生赛跑
妩媚的夜让我想念我的船和那些被雨淋湿的海鸟
哭泣的乌云在飘
沉默的大地在摇
我开始习惯热流里涌来的爆米花味道

我的心总有一些问号
我的心总有一些孤傲
我的心总有一些潦倒
但从来没有任何事能把我困扰

我的心总有一些荒谬
我的心总有一些寂寥
我的心总有一些征兆
所以我停靠海北
来到海北 在海北
这里的人也会因为爱情喝得烂醉
一样拥挤的海北
璀璨的海北
哦 baby
我无法入睡

UNET 3+

论文： https://arxiv.org/abs/2004.08790

github: https://github.com/ZJUGiveLab/UNet-Version

UNet是医学影像分割领域应用最广泛的的网络，其性能和网络中多尺度特征的融合密切相关。此后的UNet++通过嵌套结构和密集的跳过连接原始网络进行了改进。本文提出的UNet3+通过全尺度的连接和深度监督来融合深层和浅层特征的同时对各个尺度的特征进行监督。提出的UNet3+网络可以在减少网络参数的同时提高计算效率，在两个数据集上验证了方法有效性。相关代码已经开源。

现有的分割网络如UNET、PSPNET和DeepLab等网络都通常会通过多尺度的方式提取图像的信息。低层次的细节特征图中具有更丰富的例如边界这样空间信息，高层特征图中包含更多的例如物体位置这样的高级语义特征。然而，随着网络的下采样和上采样，这些高低层的信息并没有被充分地利用。因此，文章提出的UNet3+对网络的编码器与解码器连接以及解码器内部之间的连接进行了改进。此外，文章通过提出的混合损失函数对各层进行深度监督和分类分支指导分割的方式，进一步提高了分割的精度。总结来说，文章主要有以下四点贡献：

  1. 设计了一种新的网络结构UNet3+，通过引入全尺度的跳过连接，在全尺度特征映射中融合了低层细节和高层语义，充分利用了多尺度特征的同时具有更少的参数；
  2. 通过深度监督让网络从全尺度特征中学习分割表示，提出了更优的混合损失函数以增强器官的边界；
  3. 提出分类指导模块，通过与图像分类分支联合训练的方式，减少了网络在非器官图像的过度分割（over-segmentation）；
  4. 在肝脏和脾脏数据集上进行了广泛的实验，证明了UNet 3+的有效性。
  5. 从图中可以看到，UNet3+与UNet主体上非常相似，不同之处在于从编码器到解码器的跳过连接以及不同层级的编码器之间的连接。以图中的节点 XDe3 为例，它的信息来自于两方面，一是比其更浅（包括同一层级）的编码器，二十比其更深的解码器。不同层级的特征通过maxpooling和双线性上采样的方式进行尺寸统一。解码层的卷积分两步，第一步是对来及各个节点的信息进行各自的卷积，第二步是对堆叠的特征通过卷积来进行信息的融合和提取。值得注意的一个细节是，进行第一个卷积层时，来自各层的数据被卷积到相同的特征图数（在这里是n/5，n为所在层的特征图数）。

从图中可以看到，UNet3+与UNet主体上非常相似，不同之处在于从编码器到解码器的跳过连接以及不同层级的编码器之间的连接。以图中的节点 XDe3 为例，它的信息来自于两方面，一是比其更浅（包括同一层级）的编码器，二是比其更深的解码器。不同层级的特征通过maxpooling和双线性上采样的方式进行尺寸统一。解码层的卷积分两步，第一步是对来及各个节点的信息进行各自的卷积，第二步是对堆叠的特征通过卷积来进行信息的融合和提取。值得注意的一个细节是，进行第一个卷积层时，来自各层的数据被卷积到相同的特征图数（在这里是n/5，n为所在层的特征图数）。

2.全尺度的深度监督

为了进一步优化网络对图像边界的分割，文章借鉴了图像质量评估中常用的多尺度SSIM（MS-SSIM）提出了MS-SSIM loss。

本文最终采用了混合损失函数（focal loss，ms-ssim loss和iou loss）来对各层进行监督。

ℓseg=ℓfl+ℓms−ssim+ℓiou

3. 分类指导模块（CGM）

在大多数医学图像分割中，非器官图像中出现假阳性不可避免。这通常是保留在较浅层中背景噪声信息导致的过分割现象。为了实现更精确的分割，文章尝试通过添加一个额外的分类任务来解决这个问题，该分类任务被设计用于预测输入图像是否有器官。简单来说，当预测到图像包含待分割器官的概率较小时，对输出图像乘以0使得输出全黑。

文章采用了LITS的肝脏数据集和自己采集的脾脏数据集通过两组实验来进行验证。

第一组对UNet、UNet++、UNet3+（带深度监督和不带）以Vgg和ResNet101作为backbone进行了对比。可以在以Vgg为backbone时，UNet3+比其UNet在两个数据集上分别有2.8％和4.1％的提升。网络相比于UNet++也有较大的提升。另外，可以看到UNet3+使用了更少的参数得到了更好的结果。可视化的结果表明即使在器官较小的情况下网络也能得到更加精细连贯的分割。

文章进一步以ResNet作为backbone，将网络与当前比较先进的分割网络进行对比。在这里，在验证网络有效性的同时，文章对提出的损失函数和分类分支进行了消融实验。

文章对之前在UNet解码器只接收的来自同一层编码器和深一层解码器的连接方式进行了改进，使得解码器都能获得来自每一个更浅的编码器和更深的解码器的信息，使得网络能够更好地提取和融合多尺度的信息。网络的结构设计简洁优雅，是一篇非常不错的UNet改进文章。另外文章提出的MS-SSIM损失和分类指导模块也挺有意思。当然我对文章也有一些思考。第一，网络结构设计中，对于来自不同层级的特征，进行融合时可以考虑通过PSP或者Deeplab的方式（JPU是一种很好选择），也可以考虑通过SE的方式来进行通道的选择。第二，文章提出的MS-SSIM能够更好地分割图像的边界，那么选取豪斯多夫距离这样的指标可以更好地证明方法的有效性。第三，文章通过CGM来对输出进行限制，但是对于器官的顶端和底端这样本身有比较多歧义性图像，容易造成无法分割的情况，可以考虑进行soft的指导。