变量

1
2
3
4
5
6
7

VAL="this is val"

LIST=(
This
is
list
)

使用$VAL或${VAL}获取

流程控制

1
2
3
4
5
6
7
8
9

if [ $VAL == "sz" ]
then
  ...
elif [ condition ]
then
  ...
else
  ...
fi

注意

1. []中的判断语句必须与[]间由空格隔开
2. then必须换行

配置文件

Server.sh

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# Banner
echo "
ShenZhen: sz
V2Ray: v2ray
T40: t40(need vpn-ncepu)
"

# All servers name
SERVER_NAME=(
sz
v2ray
t40
)

# Configuration
SHENZHEN_HOST="119.23.107.61"
SHENZHEN_PORT="22"
V2RAY_HOST="47.240.166.68"
V2RAY_PORT="22"
T40_HOST="127.0.0.1"
T40_PORT="6002"

# SSH Server
if [ $1 == "sz" ]
then
  ssh root@${SHENZHEN_HOST} -p${SHENZHEN_PORT}
elif [ $1 == 'v2ray' ]
then
  ssh root@${V2RAY_HOST} -p${V2RAY_PORT}
elif [ $1 == 't40' ]
then
  ssh t40@${T40_HOST} -p${T40_PORT}
else
  echo "error: no this server!"
fi

Vpn.sh

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

# Banner
echo "
NCEPU VPN
port:6000 4*V100
port:6001 2*2080Ti
port:6002 4*T4
"

# Configueration
FRP_DIR="/Users/edlison/ExecApp/Frp/frpc"
FRP_CFG="/Users/edlison/ExecApp/Frp/cfg/frpc-ncepu.ini"

# Run Frp
${FRP_DIR} -c${FRP_CFG}

Norm Mode

插入

i在光标前插入

I在所在行行首插入

a在光标所在字符后

A在所在行行尾插入

o在光标所在行下一行行首插入

O在光标所在行上一行行首插入

s删除光标所在处的字符然后插入

S删除所在行并在行首插入

快速移动光标

h左移

j下移

k上移

l右移

词上的移动

0移动到行头

$移动到行尾

w移动到下一个单词的开头

e移动到下一个单词的结尾

b移动到上一个单词的开头

ge移动到上一个单词的结尾

行上的移动

nG定位到第n行行首

gg定位到第一行的行首

G定位到最后一行的行首

H定位到当前屏幕的第一行行首

M定位到当前屏幕的中间

L定位到当前屏幕的尾部

页上的移动

ctrl+f下一页

ctrl+b上一页

编辑操作

dw删除一个单词（dnw删除n个单词，ndd删除n行）

dd删除一行

yw复制一个单词

yy复制一行

p在光标后开始复制

P在光标前开始复制

撤销恢复

uundo

ctrl+rreundo

Command Mode

:set nu显示行号

:set nonu取消行号

5-First-Class Functions

Python中所有的函数都是first-class对象（一级对象？）

• 在运行时创建
• 赋值给数据结构中的变量或元素
• 作为参数传递给函数
• 作为函数的结果返回

可调用对象的7中风格

1. 用户定义方程

使用def语句或lambda表达式创建。

2. 内建函数

len

3. 内建方法

Dice.get

4. 方法

定义在类内部的函数

5. 类

可以调用__new__方法去生成实例的类，然后通过__init__方法来初始化它。

6. 类实例

如果一个类定义了一个__call__方法，那这个实例就会当作函数被调用。

7. 生成器函数

函数或方法使用yield关键字，当调用的时候，生成器函数返回一个生成器对象。

User-Defined Callable Types用户定义的可调用类型

Python函数不仅是真正的对象，而且任意的Python对象也可以表现的像函数一样。只要实现__call__实例方法。

6-Design Patterns with First-Class Functions

项目实例

开始Fluent-Python

前言：

Here’s the plan: when someone uses a feature you don’t understand, simply shoot them.

1-The Python Data Model

魔术方法也叫做Dunder方法，一般under-under-getitem-under-under也可以叫做dunder-getitem.

Example 1-1

我们可以通过重写__len__方法与__getitem__方法实现对象的获取书长度，与获取数据。

特殊方法的调用时隐式的，例如for i in x:就隐式的调用了iter(x).

代码中不应该有很多对特殊方法的直接调用，除非你在进行元编程。

Example 1-2

__repr__与__str__方法类似，但是在打印一个实例的信息时会调用__repr方法。如果没有重写该方法console会显示类似<Vector object at 0x10e100070>的信息。

__str__由str()函数调用，强烈建议重写__repr__如果没有__str__则会调用__repr__.

bool()调用__bool__的结果，如果没有实现__bool__那么会调用__len__如果长度为0则返回False.

Abstract

对于多视图的异常检测提出了概率隐变量模型。

Introduction

多视图的异常检测与传统的单视图的异常检测不同。单视图的异常检测发现那些与预期行为不符的实例。图1显示了在一个2个视图的数据上，一个多视图异常与一个单视图异常的不同。M是一个多视图异常，M在不同的视图上属于不同的聚类，且M的视图不连续。S是一个单视图异常，S在任何视图上与其它实例都很远。然而，视图S与其它实例有相同的关系。

S不是一个多视图的异常。单视图的异常检测方法，例如SVM或是基于张量的异常检测，就认为S是异常的。另一方面我们想开发一个多视图的异常检测方法去检测M是否为异常而不是S。尽管单视图的异常不是普遍的实例，如果他们是不连续的跨了多个视图，多视图的异常检测会是主要的成分。

我们针对多视图的异常检测提出了一个概率隐空间变量模型。有一个隐空间跨了所有视图。我们假设正常实例的所有视图都是用一个单一隐向量生成。另一方面，一个异常实例被假设有多个隐向量，它的不同视图使用不同的隐向量生成。

每一个非多视图的两个视图的异常(?)可以由隐向量生成。另一方面，两个视图的多视图异常M不是连续的，由两个视图使用映射向量生成。

对于每个实例的隐向量的数量是未知的，我们根据数据使用Dirichlet priors自动的推测。预测模型是基于EM算法。

在E-step中…

在M-step中…

通过迭代E,M-steps我们推测每一个实例使用的隐向量，并计算它的异常分数通过使用多余一个隐向量的可能性。

Conclusion

先生成隐向量，只要拿到隐向量，就可以通过EM算法，对类别进行判断。

参数的规则

参数的顺序1：

位置参数 - arg - *kwarg

arg会把多出来的位置参数转化为tuple
*kwarg会把关键字参数转化为dict

参数的顺序2：

位置参数 - * - 关键字…

关键字亦看作位置参数，如果不传则会报错。

传参时的技巧

获取参数时：
可以看作是将参数打包成tuple
*可以看作是将参数打包成dict

传参时：
可以将tuple解压包并传入
可以将*dict解压包并传入

Reference: https://www.jianshu.com/p/e0d4705e8293

一切皆对象

函数也可以是对象，如果不加()即视为不调用该函数，只是获取函数的对象。

1
2
3
4
5
6

def hi(name='edlison')
    return 'hello' + name

greet = hi

print(greet())  # 'hi edlison'

函数中定义函数

1
2
3
4
5
6
7
8
9
10

def hi(name='edlison')
    print('in hi()')

    def greet():
        return 'in greet'
    
    def hello():
        return 'in hello'
    
    print('back')

函数内部依次执行，函数内部的函数只能内部调用。

函数中返回函数

1
2
3
4
5
6
7
8
9
10
11

def hi(name='edlison'):
    def greet()
        return 'in greet()'
    
    if name == 'edlison':
        return greet
    else:
        return 'no'

a = hi()
b = a()

此时a指向greet函数，但并没有执行这个函数。
b执行了greet函数，输出’in greet()’。

函数作为参数传给另一个函数

1
2
3
4
5
6
7
8

def hi():
    return 'hi'

def before_hi(f):
    print('before')
    print(f())

before_hi(hi)

将hi函数作为参数传入另一个函数中，并在函数中调用。

装饰器

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

def dec(f):
    def wrap_func():
        # before func
        f()
        # after func
    return wrap_func  # 这里返回里层的函数，但并不会调用。

def need_dec():
    print('need dec')

need_dec = dec(need_dec)
need_dec()

或者可以使用@符号来简化生成一个被装饰的函数。

1
2
3
4
5

@dec
def need_dec():
    print('need dec')

deed_dec()

使用@注解只是简化了need_dec = dec(need_dec)这一步。

1
2
3
4
5
6
7

def dec(f):
    @wrap(f)  # 保留原函数的所有属性
    def wrap_func():
        # before func
        f()
        # after func
    return wrap_func

经过装饰器后，由于返回的里层的wrap_func，所以拿到的函数变为了里层的wrap_func。使用@wrap可以保留原函数的所有属性。

如果想要带参数的装饰类，则需要再创建一个函数，然后在内嵌套装饰器。

装饰类

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

class logit():
    def __init__(self, logfile='out.log'):
        self.logfile = logfile
    
    def __call__(self, func):
        @wrap(func)
        def wrap_func(*args, **kwargs):
            ...
            return func(*args, **kwargs)
        return wrap_func
    
    def notify(self):
        raise NotImplementError

优点：

• 如果想设计带参数的装饰类，不需要使用函数嵌套装饰器。
• 可以创建一个基类，装饰过程中可能会用到一些重写的方法，通过子类继承重写。

多个装饰器的执行顺序

先会执行离需要装饰的函数近的装饰器。但是，内部的wrap_func函数中执行的顺序其实是先执行离函数最远的装饰器中的内容。

相当于先依次调用装饰器内的东西，再从内到外层层封装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

def dec_a(func):
    print('dec_a')
    def inner_a():
        print('inner_a')
        func()
    return inner_a

def dec_b(func):
    print('dec_b')
    def inner_b():
        print('inner_b')
        func()
    return inner_b

@dec_b
@dec_a
def need_dec():
    print('need_dec')

# dec_a
# dec_b
# inner_b
# inner_a
# need_dec

如果装饰器内没东西执行，可以认为从上到下依次执行装饰器。

总结

1. 装饰器可以在每个函数的执行前或执行后进行一些其他操作。
2. 被装饰的函数可以在内部函数内执行，也可以作为内部函数的返回值，但是一定要调用这个函数。
3. 装饰类与装饰函数其实都是使用了对象的思想，个人认为装饰类的实现更优，更简单也更灵活。
4. 装饰器的常见应用：授权，日志。

Reference: https://www.runoob.com/w3cnote/python-func-decorators.html

Flask模块化管理

Bluepoint可以实现Flask的模块化管理，在每个包的__init__文件中可以定义对应的蓝图。蓝图仅是静态的，需要在应用运行时，对其进行装载。

注意

1. __init__文件中定义好蓝图后一定要将包含路由的文件import进来，否则不能识别相应的路由。
2. import文件时不能使用通配符*进行导入。

Flask中的request与respond

request

from flask import request

1. param传参
   使用request.args.get(‘argname’)获取键值对。

2. body传参
   使用request.form.get(‘argname’)获取form格式传参键值对。
   使用request.get_data()获取全部raw格式内容。
   使用request.get_json()获取全部raw格式内容，且必须为json格式。

注意
form-data: 可以传键值对和文件。
x-www-form-urlencodes: 只能传键值对。

respond

from flask import jsoniify
import json

1. 直接返回json

• jsonify()可以直接制作json返回 (返回的格式也定义为application/json)
• json.dumps()可以将dict生成json (返回的格式默认为text)

2. 简易定义make_respond

3. 详细定义Respond

Flask中的session

from flask import session

1. 使用session需要设置config
   app.config[‘SECRET_KEY’]=os.urandom(24)

2. Flask提供的session是储存在cookie中的
   session[‘username’] = data[‘username’]
   此时的cookie中存储了加密过的username。

3. 获取session
   session.get(‘key’)或session[‘key’]
   但是后者如果没有这个key会报错。
   获取到的session自动经过了解密。

4. 删除session
   session.pop(‘key’)或session[‘key’]=False
   session.clear清除session中所有数据。

Flask_SQLAlechemy

注意

1. 如果蓝图中有用到db，则一定要在db创建后import蓝图！！！

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

   db = SQLAlchemy() def create_app(): app = Flask(__name__) app.config['SECRET_KEY'] = os.urandom(24) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://library:library@119.23.107.61:3306/library' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True db.init_app(app) from .user import user_blu app.register_blueprint(user_blu) print(app.url_map) return app

   因为代码是按照顺序执行的，当你从其他模块导入蓝图的时候就需要 db 了，但是这个时候db 还没有生成，所以会报出错误 提示不可以从当中导入相应的模块。

2. 如果db=SQLAlechemy()中没有传app，则后面需要先db.app=app然后再db.init_app(app)???

Flask g

1. g对象

• 专门用来存储用户信息
• g只在一次请求中的所有代码有用

2. g与session的区别

• session只要未失效，不同的request请求都可以获得session，由cookie决定
• 每一次请求都会改变g对象

reset

git reset [--soft | --mixed | --hard] [HEAD]

--soft
修改版本库，保留暂存区，保留工作区。头指针全部重置到指定版本，也会重置暂存区，并且会将工作区代码也回退到这个版本。

--hard
修改版本库，修改暂存区，修改工作区。头指针全部重置到指定版本，且将这次提交之后的所有变更都移动到暂存区。

Tips:
使用git reset --hard HEAD移除当前暂存区及工作区所有的修改。

tag

给当前commit打标签。
git tag v1.0

删除标签
git tag -d v1.0

显示标签修改内容
git show v1.0

log

查看最近提交的文件差异，最近两篇。
git log -p -2

clean

用于删除Untracked file, 常与git reset --hard一起使用，完全回复到指定commit。
git clean -dfd为文件夹，f为文件。

Linux下修改环境变量

查看PATH

echo $PATH
以添加mongodb server为列

修改方法一

export PATH=/usr/local/mongodb/bin:$PATH
//配置完后可以通过echo $PATH查看配置结果。
生效方法：立即生效
有效期限：临时改变，只能在当前的终端窗口中有效，当前窗口关闭后就会恢复原有的path配置
用户局限：仅对当前用户

修改方法二

通过修改.bashrc文件:
vim ~/.bashrc
//在最后一行添上：
export PATH=/usr/local/mongodb/bin:$PATH
生效方法：（有以下两种）
1、关闭当前终端窗口，重新打开一个新终端窗口就能生效
2、输入“source ~/.bashrc”命令，立即生效
有效期限：永久有效
用户局限：仅对当前用户

修改方法三

通过修改profile文件:
vim /etc/profile
/export PATH //找到设置PATH的行，添加
export PATH=/usr/local/mongodb/bin:$PATH
生效方法：系统重启
有效期限：永久有效
用户局限：对所有用户

修改方法四

通过修改environment文件:
vim /etc/environment
在PATH=”/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games”中加入“:/usr/local/mongodb/bin”
生效方法：系统重启
有效期限：永久有效
用户局限：对所有用户

MacOS

MAC OS X环境配置的加载顺序

• 系统级别
  /etc/profile
  /etc/paths

• 用户级别
  ~/.bash_profile
  ~/.bash_login
  ~/.profile
  ~/.bashrc （在打开shell时加载）

/etc/paths 全局建议修改这个文件
/etc/profile 不建议修改这个文件，全局共有配置，用户登录时候都会加载该文件
/etc/bashrc 一般在这个文件中添加系统级别的环境变量，全局共有配置，bash shell执行时候都会加载

Tips

想要立即生效执行source

对Jupyter添加Kernel

对虚拟环境的操作

进入想要添加到Jupyter的Python虚拟环境

conda activate pytorch

安装ipykernel

conda install ipykernel

在虚拟环境中执行以下以添加Kernel到Jupyter

python -m ipykernel install --name kernelname

对Jupyter的操作

查看存在的Kernel

jupyter kernelspec list

删除Kernel

jupyter kernelspec remove kernelname

CluasteringGANSiamese

代码复现

ST-SiameseNet

安装依赖pip install -r requirement

pip指定版本安装pip install xxx==version

conda指定版本安装conda install xx=version

作为Keras后台的Tensorflow有一些版本约束-版本匹配

GAN

报错信息
Error while reading resource variable _AnonymousVar41 from Container: localhost. This could mean that the variable was uninitialized. Not found: Resource localhost/_AnonymousVar41/class tensorflow::Var does not exist.

解决办法
keras改为tensorflow.keras

数据库笔记

以下Mysql为例

数据库完整性

实体完整性

实体完整性即主码，用PRIMARY KEY定义.

• 列级约束：只能应用于一列上。
• 表级约束：可以应用于表的多个列上。

简而言之，如果完整性约束涉及到该表的多个属性列，必须定义在表级上，否则既可以定义在列级也可以定义在表级。

参照完整性

参照完整性即外码，用FOREIGN KEY (列名) REFERENCES <表名>(列名)定义.

用constraint指定约束名，约束不指定名称时，系统会给定一个名称。

注意：外码一定参照主码（可以是其他表的主码，也可以时自己的）,而且外码的列数一定要等于被参照表的主码列数。

违约处理：对被参照表进行update/delete/insert操作时会破坏参照完整性时，参照表需要告诉被参照表听改怎么做。需要对参照表定义外码时添加on delete/on update[<no action>/<cascade>]

• CASCADE:在父表（被参照表）上update/delete记录时，同步子表（参照表）的匹配记录。
• SET NULL:在父表（被参照表）上update/delete记录时，将子表（参照表）上匹配的列设为null（子表的外键列不能为not null）。
• NO ACTION:如果子表中有匹配的记录，不允许对父表进行操作。
• RESTRICT:同NO ACTION，立即检查外键约束。

NULL、RESTRICT、NO ACTION
删除：从表记录不存在时，主表才可以删除。删除从表，主表不变
更新：从表记录不存在时，主表才可以更新。更新从表，主表不变(无法更新从表)

CASCADE
删除：删除主表时自动删除从表。删除从表，主表不变
更新：更新主表时自动更新从表。更新从表，主表不变(无法更新从表)

SET NULL
删除：删除主表时自动更新从表值为NULL。删除从表，主表不变
更新：更新主表时自动更新从表值为NULL。更新从表，主表不变

总结：CASCADE对主表操作 主表影响子表.
RESTRICT对主表操作 子表限制主表.
Mysql中均无法更新子表.

用户定义完整性

列值非空（not null），列值唯一（unique），列值需要满足条件表达式（check）.

• not null:列值不能为空，（列级完整性约束）
• unique:列值唯一，（列级或表级约束）
• check:列值应该满足的条件，（列级或表级约束）

完整性约束命名子句

完整性约束命名子句是用来给完整性约束命名，这样我们就可以通过该名称对完整性约束进行删除、增加操作。

数据定义

索引类型

索引方法

数据查询

连接查询

1. 等值与非等值连接查询

=为等值连接，连接字段必须为可比的。

2. 自身连接

自己对自己相连，比如要查询先修课的先修课，要对自己查询两次。

3. 外连接

LEFT JOIN 保存左侧所有元组，右侧不存在的用NULL补齐.(Mysql中LEFT JOIN与LEFT OUTER JOIN相同)

4. 多表连接

跨多个表进行连接查询。

5. *交叉连接

笛卡尔积。
SELECT * FROM <TABLE1>, <TABLE2>或SELECT * FROM <TABLE1> CROSS JOIN <TABLE2>

6. *内连接

如果没有连接条件，INNER JOIN 和 CROSS JOIN 在语法上是等同的，两者可以互换。

SELECT <字段名> FROM <表1> INNER JOIN <表2> [ON子句]

嵌套查询

1. 不相关子查询

子查询的查询条件不依赖于父查询。
有些嵌套查询可以使用连接运算替代，有些不可以。

2. 相关子查询

子查询的条件依赖于父查询。
SELECT Sno, Cno FROM SC x WHERE Grade >= (SELECT AVG(Grade) FROM SC y WHERE y.Sno = x.Sno)

3. 带有ANY(SOME)或ALL谓词的子查询

子查询返回单值用比较运算符，返回多值时需要用ANY(SOME)或ALL谓词修饰符。且使用ANY或ALL时需要同时使用比较运算符。

4. 带有EXISTS谓词的子查询

子查询不返回任何数据，只产生逻辑真值true或false。

注意：全称量词可以通过否运算转换成存在量词。
注意：蕴含式可以转换为析取式。

5. 集合查询

并操作UNION,交操作INTERSECT,差操作EXCEPT.

6. 派生表查询

子查询出现在FROM子句中时，这是子查询生成临时的派生表。

注意：必须为派生关系指定一个别名。

BERT 概述

BERT的全称是Bidirectional Encoder Representation from Transformers，即双向Transformer的Encoder，因为decoder是不能获要预测的信息的。模型的主要创新点都在pre-train方法上，即用了Masked LM和Next Sentence Prediction两种方法分别捕捉词语和句子级别的representation。

训练方法：

• 它在训练双向语言模型时以减小的概率把少量的词替成了Mask或另一个随机的单词。
• 增加了一个预测下一句的loss。

特点：

• 模型深，12层，中间层只有1024wide。Transformer的中间层有2048。（深而窄 比 浅而宽 的模型更好？）
• MLM(Masked Language Model)，同时利用左侧和右侧的词语。

Reference

BERT | Bidirectional Encoder Representation from Transformers
https://easyai.tech/ai-definition/bert/

Encoder-Decoder 和 Seq2Seq 概述

Encoder-Decoder

将现实问题转化为数学问题 通过求解数学问题 从而解决现实问题

缺点：

Encoder 和 Decoder之间只有一个向量C来传递信息，且C的长度固定。

当输入信息太长时，会丢掉一些信息。

Attention机制就是为了解决信息过长，信息丢失的问题。

Attention模型的特点是Encoder不再将整个输入序列编码为固定长度的中间向量C，而是编码成一个向量的序列。

Seq2Seq

*输入一个序列 输出另一个序列 *

这种结构最重要的地方在于输入序列和输出序列的长度是可变的。

Encoder-Decoder and Seq2Seq

• Seq2Seq属于Encoder-Decoder的大范畴
• Seq2Seq更强调目的，Encoder-Decoder更强调方法

Rreference

Encoder-Decoder 和 Seq2Seq

https://easyai.tech/ai-definition/encoder-decoder-seq2seq/

NLP中处理文本方法

由于文本是一种非架构化的数据，我们要将这种非结构化的数据转化为结构化的信息，这样我们才能对其进行处理。

现在文本表示大致有三种方式。

One-Hot

向量中每一个位置代表一个词

one-hot的缺点：

• 无法表达词语之间的关系
• 这种过于稀疏的向量，导致计算和存储的效率不高

整数编码

整数编码的缺点

• 无法表达词语之间的关系
• 对于模型解释而言，整数编码可能具有挑战性

Word Embedding (词嵌入)

优点：

• 可以将文本通过一个低维向量来表达，不像one-hot长
• 语义相似的词在向量空间上比较相近
• 通用性强，可用在不同的任务中

Word2Vec

基于统计方法来获得词向量的方法。

两种训练模式：

• 通过上下文来预测当前词(CBOW)
• 通过当前词来预测上下文(Skip-gram)

提高速度的优化方法：

• Negtive Sample (负采样)
• Hierarchical Softmax

优点：

• 由于Word2Vec会考虑上下文，跟之前的Embedding方法相比，效果要更好
• 比之前的Embedding方法维度更少，速度更快
• 通用性强，用于各种NLP任务

缺点：

• 由于词和向量是一对一的关系，所以多义词的问题无法解决
• Word2Vec是一种静态的方式，虽然通用性强，但是无法针对特定任务做动态优化

GloVe

实现有三步：

• 根据语料库构建一个共现矩阵，矩阵中的每一个元素代表单词和上下文单词在特定大小的上下文窗口内共同出现的次数。
• 构建词向量和共现矩阵之间的近似关系。
• loss function

Reference

词嵌入 | Word embedding

https://easyai.tech/ai-definition/word-embedding/

Word2vec

https://easyai.tech/ai-definition/word2vec/

GloVe详解

http://www.fanyeong.com/2018/02/19/glove-in-detail/

Transformer

XLNet Generalized Autoregressive Pretraining for Language Understanding

Abstract

Bert基于去噪自编码器的预训练模型，性能优于自回归语言模型的预训练方法。而由于mask一部分输入，bert忽略了被mask位置之间的依赖关系。

XLNet基于此优缺点可以

• 通过最大化所有可能的因式分解顺序的对数似然，学习双向语境信息
• 用自回归本身的特点克服bert的缺点
• 融合了自回归模型Transformer-XT的思路

作者从自回归(autoregressive)和自编码(autoencoding)两大范式分析了当前的预训练语言模型。

1 介绍

1.1 AutoRegression与AutoEncoding两大阵营

XLNet是一个类似BERT的模型，XLNet是一种通用的自回归预训练方法。

自回归(AutoRegression)语言模型

AR语言模型是一种使用上下文词来预测下一个词的模型，但是上下文单词被限制在两个方向，前向和后向。(例如：GPT，GPT-2)

AR语言模型擅长生成式NLP任务，生成上下文时总是前向的。

但是AR只能使用前向上下文或后向上下文，这意味着它不能同时使用前向和后向上下文。

自编码(AutoEncoding)语言模型

BERT被归类为自编码器语言模型。AE旨在从损坏的输入中重建原始数据。

损坏的输入意味着我们在预训练阶段用[MASK]替换原始词，目标是预测得到原始句子。

AE语言模型的优势是，它可以从前向和后向的方向看到上下文。

AE语言模型的缺点是

• [MASK]这种人为的符号在调优时在真实数据中并不存在，会导致预训练-调优的差异(pretrain-finetune discrepancy)
• [MASK]假设mask词在给定未mask词的情况下彼此独立（例：住房危机已经变成银行业危机。 其忽略了 银行业 与 危机 间的关系）。

1.2 两大阵营需要新的XLNet

XLNet提出了一种让AR语言模型从双向上下文中学习的新方法，以避免[MASK]方法在AE语言模型中带来的缺点。

XLNet是一种泛化自回归(AR)方法，既集合了AR和AE方法的优势，又避免了二者的缺陷。

• XLNet不使用传统AR模型中固定的前向或后向因式分解顺序，而是最大化所有可能因式分解顺序的期望对数似然，由于对因式分解顺序的排列操作，每个位置的语境都包含来自左侧和右侧的token。因此，每个位置都能学习来自所有位置的语境信息，即捕获双向语境。
• 作为一个泛化自回归(AR)模型，XLNet不依赖残缺数据。不会有BERT的预训练-微调差异。自回归目标提供一种自然的方式，来利用乘法法则对预测token的联合概率执行因式分解(factorize)，这消除了BERT中的独立性假设。
• XLNet将Transformer-XL的分割循环机制和相对编码范式整合到预训练中。

2 Proposed Solution

2.1 在自回归模型中引入双向语言模型基本思想

XLNet仍然遵循两阶段的过程(pretrain fine-tune)。其主要希望改动第一阶段的过程，即不像BERT那样带[MASK]的Denoising-autoencoder的模式，而是采用AR语言模型的模式。

简单来说就是，输入句子X仍然使自左向右的输入，看到Ti单词的上文Context-before来预测Ti这个单词，又希望Context-before例不仅看到上文单词又能看到后面的Context-after里的下文单词。这样一来BERT预训练阶段引入的[MASK]符号就不需要了。

基本思想：在预训练阶段引入Permutation LM的训练目标。

举例：比如包含单词Ti的当前输入的句子X，由顺序的几个单词构成x1, x2, x3, x4四个单词顺序组成。假设x3为要预测的单词Ti，其所在的位置为Position 3，要想让它能够在上文Context-before中，也就是Pos 1或Pos 2的位置看到Pos 4的单词x4。可以这么做，假设固定住x3的位置，也就是仍在x3，之后随机排列组合句子中的4个单词，在所有可能里训责一部分作为模型的预训练的输入X。比如随机排列组合后x4, x2, x3, x1这样一个排列组合作为模型的输入X。于是x3就能同时看到上文x2以及下文x4的内容了。

看上去仍然是个自回归的从左到右的模型，但是其实通过对句子中单词排列组合，把一部分Ti下文的单词排到Ti上文位置中，于是就看到了上文和下文，但是形式上看上去仍然是从左到右在预测后一个单词。

2.2 具体实现

尽管基本思想里提到把句子X的单词排列组合后，再随机抽取例子作为输入，但实际上不可以，因为Fine-tune阶段不可能去排列组合原始输入。所以必须让预训练阶段的输入部分看上去仍然是x1, x2, x3, x4这个顺序，但是可以在Transformer部分做些工作，来达成目标。

XLNet采取了Attention掩码机制，输入的X没有任何变化，单词Ti还是第i个单词，前面有1到i-1个单词。但是Transformer内部，通过Attention掩码从X的输入单词里，也就是Ti的Context-before和Context-after中随机选择i-1个单词，放到Ti的Context-before上，把其他单词的输入通过Attention掩码隐藏掉。（当然这个所谓放到Ti的上文位置，只是一种形象的说法，其实在内部，就是通过Attention Mask，把其它没有被选到的单词Mask掉，不让它们在预测单词Ti的时候发生作用，如此而已。看着就类似于把这些被选中的单词放到了上文Context_before的位置了）。

XLNet是用双流自注意力模型实现的。一个是内容流自注意力，其实就是标准的Transformer的计算过程，主要引入了Query流自注意力。其实就是用来替代[MASK]标记的，XLNet因为要抛弃[MASK]又不能看到x3的输入，于是Query流就直接忽略掉x3的输入，只保留这个位置信息，用参数w来代表位置的embedding编码。其实XLNet只是抛弃了[MASK]这个占位符号，内部还是引入Query流来忽略掉被MASK的这个单词。和BERT比只是实现方式不同而已。

如图所示，输入序列仍是x1, x2, x3, x4，通过不同的掩码矩阵，让当前单词Xi只能看到被排列组合后的顺序x3->x2->x4->x1中自己前面的单词。

2.3 XLNet与BERT

通过改造BERT预训练的过程，其实可以模拟XLNet的PLM过程。

第一种思路：Bert目前的做法是，给定输入句子X，随机Mask掉15%的单词，然后要求利用剩下的85%的单词去预测任意一个被Mask掉的单词。对于输入句子，随机选择X中的任意i个单词，只用这i个单词去预测被Mask的单词。这个过程理论上可以在Transformer内采用Attention Mask来实现，这样BERT的预训练模型就和XLNet基本等价了。

第二种思路：假设仍使用BERT目前的Mask机制，将Mask 15%改为，每次一个句子只Mask掉一个单词，利用剩下的单词来预测被Mask掉的单词。因为XLNet在实现的时候，为了提升效率，其实是选择每个句子最后末尾的1/K个单词被预测，假设K=7，意味着一个句子X，只有末尾的1/7的单词会被预测。这样两者基本是等价的。

XLNet维持了自回归(AR)语言模型的从左向右的模式，这个BERT做不到。明显的好处是，对于生成类的任务，能够在维持表面从左向右的生成过程前提下，模型里隐含了上下文的信息。XLNet貌似应该对于生成类型的NLP任务，会比BERT又明显优势。此外，XLNet还引入了Transformer XL机制，所以对于长文档输入类型的NLP任务，也会比BERT有明显优势。

3 总结

Permutation Language Model是XLNet的主要理论创新，它开启了自回归(AR)语言模型如何引入下文的一个思路。

XLNet也相当于是BERT, GPT2.0, Transformer XL的综合体。

• 通过Permutation LM 预训练目标，吸收了BERT的双向语言模型；
• 吸收了GPT2.0使用更多更高质量的预训练数据；
• 吸收了Transformer XL的主要思想。

XLNet其实本质上还是ELMO/GPT/BERT这一系列两阶段模型的进一步延伸。在自回归(AR)语言模型方向引入双向语言模型打开了新思路。

未来预期

• Transformer天然对长文档任务处理有弱点，所以XLNet对于长文档NLP任务相比BERT应该有直接且比较明显的性能提升；
• 对于生成类的NLP任务，XLNet的预训练模式符合下游任务序列生成结果。

Rreference

https://zhuanlan.zhihu.com/p/70257427

https://blog.csdn.net/weixin_37947156/article/details/93035607

// AR AE LM 实现步骤？
// TODO Transformer 较于 RNN？
// TODO encoding decoding？
// TODO denoising-autoencoder?

// TODO Transformer-XL 分割循环机制 相对编码范式??
// TODO BERT 预训练-微调两阶段模式(pretrain fine-tune) 抛弃mask使两阶段保持一致？ fine-tune阶段？
// TODO AR模型前向后向因式分解顺序？

Java中继承与实现的思考

继承(extend): 继承传达的意思是is-a, 比如Cat is an Animal.

实现(Implement): 实现传达的意思是able一种能力, 比如Cat is swimmable.

extend

比较灵活可以继承抽象类，也可以继承实体类。
抽象类可以定义非抽象方法与抽象方法，如果有抽象方法则子类必须继承，如果子类没有重写非抽象方法则子类的实例使用的是父类的方法。

多态
如果实例化一个子类赋给一个父类(例: Animal cat = new Cat())， 则只能够使用父类中的field与method，如果method被子类重写则会调用子类的method。

implement

比较严格，若实现则必须实现所有方法。
其中的field都是static final修饰的，且只能被实现的子类获取。method不能有body，但是如果static修饰则可以有body(怎么用？)。

多态
如果实例化一个子类赋给一个接口(例: Swimmable cat = new Cat())，则只能够使用该接口的field并且无法获得field。
如果一个子类继承了一个实现了该接口的父类则可以重写方法，如果没有重写则(Swimmable cat = new Cat())中cat获取的方法则是父类中实现的方法。

Docker 部署 Lineloss

1 拉取redhat镜像

docker pull yjjy0921/redhat7.2

2 进入镜像换yum源

• rpm安装wget(docker cp host.path cotainer:container.path)
• wget下载yum相关包
• rpm安装下载的相关包

报错：
python-urlgrabber >= 3.10-8 is needed by yum-3.4.3-167.el7.centos.noarch
rpm >= 0:4.11.3-22 is needed by yum-3.4.3-167.el7.centos.noarch

查询存在的python-urlgrabber包
rpm -q python-urlgrabber~~

删除python-urlgrabber包
rpm -e python-urlgrabber

更新rpm包
rpm -Uvh rpm-4.11.3-43.el7.x86_64.rpm --nodeps

3 创建aliyun.repo

cd /etc/yum.repo.d/
vim aliyun.repo

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

[base]
name=CentOS-$releasever - Base
baseurl=http://mirrors.aliyun.com/centos/7.8.2003/os/$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos/7.8.2003/os/x86_64/RPM-GPG-KEY-CentOS-7


#released updates
[updates]
name=CentOS-$releasever - Updates
baseurl=http://mirrors.aliyun.com/centos/7.8.2003/updates/$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos/7.8.2003/os/x86_64/RPM-GPG-KEY-CentOS-7


[extras]
name=CentOS-$releasever - Extras
baseurl=http://mirrors.aliyun.com/centos/7.8.2003/extras//$basearch/
gpgcheck=1
gpgkey=http://mirrors.aliyun.com/centos/7.8.2003/os/x86_64/RPM-GPG-KEY-CentOS-7

[centosplus]
name=CentOS-$releasever - Plus
baseurl=http://mirrors.aliyun.com/centos/7.8.2003/centosplus//$basearch/
gpgcheck=1
enabled=0

清除redhat.repo
mv redhat.repo redhat.temp

检验yum配置成功
yum update -y --skip-broken

4 安装mariadb

安装
yum install -y mysql

注意
docker无法使用systemctl指令使mysql后台运行

查看容器配置文件
docker inspect containerID

修改已经运行的容器配置文件
/usr/lib/docker...

运行镜像时需要
docker run --privileged --name=lineloss -d -it edlison/lineloss /usr/sbin/init

--privileged赋予额外权限
/usr/sbin/init将cmd设置为这个 dbus服务就会运行

systemctl start mariadb 启动服务
systemctl enable mariadb 设置开机启动
systemctl restart mariadb 重新启动
systemctl stop mariadb.service 停止MariaDB

初始化数据库
mysql_secure_installation

设置密码
mysqladmin -u root password 'newpassword'

导入数据
create database lineloss;
use lineloss;
source /home/xs_project/sql/lineloss.sql

5 Java环境

安装Java
yum install java

6 Python环境

安装python3
yum install python3

安装依赖
pip3 install Flask
pip3 install flask_sqlalchemy
pip3 install pymysql
pip3 install numpy
pip3 install sklearn
pip3 install jieba
pip3 install pandas
pip3 install statsmodels

7 运行测试

运行镜像
docker run --privileged --name=lineloss -d -p 18084:18084 -it edlison/lineloss /usr/sbin/init

Java
cd /home/xs_project/java
java -jar RuoYi.jar

Python
cd /home/xs_project/python/LineLoss
python3 service.py

8 Dockerfile

只是构建镜像？？？不便于执行镜像内程序？？？

9 其他

复制文件

容器内新建文件夹
mkdir /home/xs_project/java
mkdir /home/xs_project/python
mkdir /home/xs_project/sql

将文件复制到容器内
cp RuoYi.jar containerID:/home/xs_project/java
cp LineLoss.zip containerID:/home/xs_project/python
cp lineloss.sql containerID:/home/xs_project/sql

容器提交成镜像

docker commit -a "userid" -m "comment" containerID imageName:tag

镜像上传仓库

docker push userName/imageName

注意

tag命令修改为规范的镜像名
docker tag lineloss:latest edlison/lineloss

push到用户仓库
docker push edlison/lineloss

镜像导出导入

导出镜像
docker save -o lineloss.tar edlison/lineloss或
docker save edlison/lineloss>/home/lineloss.tar

导入镜像
docker load<lineloss.tar

Attention Is All You Need

Abstract

我们提出一种全新的简洁的网络架构–Transfomer，它完全基于Attention机制，舍弃了循环与卷积。

1 Introduction

Transformer的并行性很好的解决了RNN模型的序列化输入输出。

2 Background

3 Model Architecture

大部分序列神经网络模型都具有encoder-decoder结构。

3.1 Encoder and Decoder Stacks

encoder由6个相同的层构成，每一层有两个子层。第一个是一个多Attention机制，第二个是一个简单的全连接feed-forward网络。两个子层中间部署一个参差网络，后接一个正则化。

decoder也是由6个相同的层构成。除了两个子层外中间还加入了一个第三子层Multi-head Attention.

3.2 Attention

Attention的核心内容是为输入向量的每个单词(512d)学习一个权重。在self-attention中，每个单词有3个不同的向量，Query，Key，Value，长度均是64. 他们通过3个不同的权值矩阵由嵌入向量X乘以三个不同的权值矩阵WQ，WK，WV(512 * 64)得到。

Attention计算步骤：

• 将输入单词转换成词向量
• 根据词向量得到q, k, v三个向量
• 为每个向量计算一个score: score = q * kT
• 为了梯度的稳定，Transformer使用了score归一化，即除以根号dk
• 对score过一遍softmax函数
• softmax点乘value得到每个输入向量的评分v
• 想家之后得到最终的输出结果z=∑v

3.3 Multi-Head Attention

Multi-Head Attention相当于h个不同的self-attention的集成。

Multi-Head输出分三步

• 将X分别输入到8个self-attention中得到8个加权后的特征矩阵Z
• 将8个Z按列拼接成一个大的特征矩阵
• 将特征矩阵经过一层fc后得到输出Z

3.4 损失层

解码器解码后，解码的特征向量通过一层激活函数为softmax的全连接层之后得到反应每个单词概率的输出向量。此时通过CTC等损失函数训练模型。

4 位置编码

Transfomer无法捕捉循序序列的能力。论文在编码词向量时引入了位置编码的特征，位置编码会在词向量中加入单词的位置信息。

在上式中， [公式] 表示单词的位置， [公式] 表示单词的维度。关于位置编码的实现可在Google开源的算法中get_timing_signal_1d()函数找到对应的代码。

作者这么设计的原因是考虑到在NLP任务重，除了单词的绝对位置，单词的相对位置也非常重要。根据公式 [公式] 以及[公式] ，这表明位置 [公式] 的位置向量可以表示为位置 [公式] 的特征向量的线性变化，这为模型捕捉单词之间的相对位置关系提供了非常大的便利。

问题

位置编码对词袋模型等具有普适性？
encoder/decoder通过self-attention层所得到的向量即理解为加密/解密？
得到最后的Z之后怎么用？

Cookie, Session, Token, JWT

Authentication(认证)

认证当前的用户的身份

互联网中的认证

• 用户名密码登陆
• 邮箱发送登陆链接
• 手机号接受验证码

Authorization(授权)

用户权限

实现授权的方式

• Cookie
• Session
• Token
• OAuth

Credentials(凭证)

实现认证和授权的前提是需要一种媒介（证书）来标记访问者的身份。

在互联网应用中，一般网站（如掘金）会有两种模式，游客模式和登录模式。游客模式下，可以正常浏览网站上面的文章，一旦想要点赞/收藏/分享文章，就需要登录或者注册账号。当用户登录成功后，服务器会给该用户使用的浏览器颁发一个令牌（token），这个令牌用来表明你的身份，每次浏览器发送请求时会带上这个令牌，就可以使用游客模式下无法使用的功能。

Cookie

• HTTP 是无状态的协议（对于事务处理没有记忆能力，每次客户端和服务端会话完成时，服务端不会保存任何会话信息）：每个请求都是完全独立的，服务端无法确认当前访问者的身份信息，无法分辨上一次的请求发送者和这一次的发送者是不是同一个人。所以服务器与浏览器为了进行会话跟踪（知道是谁在访问我），就必须主动的去维护一个状态，这个状态用于告知服务端前后两个请求是否来自同一浏览器。而这个状态需要通过 cookie 或者 session 去实现。
• cookie 存储在客户端： cookie 是服务器发送到用户浏览器并保存在本地的一小块数据，它会在浏览器下次向同一服务器再发起请求时被携带并发送到服务器上。
• cookie 是不可跨域的： 每个 cookie 都会绑定单一的域名，无法在别的域名下获取使用，一级域名和二级域名之间是允许共享使用的（靠的是 domain）。

Session

• Session是另一种记录服务器和客户端会话状态的机制。
• Session是基于Cookie实现的，Session存储在服务器端，SessionId会被存储到客户端的Cookie中。
• Session认证流程
  • 用户第一次请求服务器的时候，服务器根据用户提交的相关信息，创建对应的Session。
  • 请求返回时将此Session对应的唯一标识信息SessionId返回给浏览器。
  • 浏览器接受到服务器返回的SessionId信息后，会将此信息存入到Cookie中，同时Cookie记录此SessionId属于哪个域名。
  • 当用户第二次访问服务器的时候，请求会自动判断此域名下是否存在Cookie信息，如果存在自动将Cookie信息信息也发送到服务端，服务端会从Cookie中获取SessionId，再根据SessionId查找到对应的Session信息，如果没有找到说明用户没有登陆或登陆失效，如果找到Session证明用户已经登陆可执行后面操作。

根据以上流程可知，SessionID 是连接 Cookie 和 Session 的一道桥梁，大部分系统也是根据此原理来验证用户登录状态。

Cookie和Session的区别

• 安全性：Session比Cookie安全，Session是存储在服务端的，Cookie是存储在客户端的。
• 存取值的类型不同：Cookie只支持存字符串数据，想要设置其他类型的数据，需要将其转换成字符串，Session可以存任意数据类型。
• 有效期不同：Cookie可设置为长时间按保持，比如我们经常使用的默认登陆功能，Session一半失效时间较短，客户端关闭或Session超时都会失效。
• 存储大小不同：单个Cookie保存的数据不能超过4K，Session可存储数据远高于Cookie，但是当访问量过多，会占用过多的服务器资源。

Token(令牌)

Access Token

• 访问资源接口（API）时所需要的资源凭证

• 简单Token的组成：uid(用户唯一的身份标识)、time(当前时间的时间戳)、sign（签名，token 的前几位以哈希算法压缩成的一定长度的十六进制字符串）

• 特点

  • 服务端无状态化、可扩展性好。
  • 支持移动端设备
  • 安全
  • 支持跨程序调用

• Token的身份验证流程
  

  1. 客户端使用用户名跟密码请求登陆
  2. 服务端收到请求，去验证用户名与密码
  3. 验证成功后，服务端会签发一个Token并把这个Token发送到客户端
  4. 客户端收到Token后，会把它存储起来（Cookie, LocalStorage）
  5. 客户端每次向服务端请求资源的时候需要带着服务端签发的Token
  6. 服务端收到请求，然后去验证客户端请求里面带着的Token，如果验证成功，就向客户端返回请求的数据

• 每一次请求都需要携带Token，需要把Token放到HTTP的Header里

• 基于Token的用户认证是一种服务端无状态的认证方法，服务端不用存放Token数据。用解析Token的实践换取Session的存储空间，从而减轻服务器的压力，减少频繁的查询数据库

• Token完全由应用管理，所以可以避开同源策略

Refresh Token

• Refresh Token是专用于刷新Access Token的Token。如果没有Refresh Token，也可以刷新Access Token，但每次刷新都要用户输入登陆用户名和和密码。有了Refresh Token，客户端直接用Refresh Token去更新Access Token。

• Access Token 的有效期比较短，当 Acesss Token 由于过期而失效时，使用 Refresh Token 就可以获取到新的 Token，如果 Refresh Token 也失效了，用户就只能重新登录了。
• Refresh Token 及过期时间是存储在服务器的数据库中，只有在申请新的 Acesss Token 时才会验证，不会对业务接口响应时间造成影响，也不需要向 Session 一样一直保持在内存中以应对大量的请求。

Token和Session的区别

• Session 是一种记录服务器和客户端会话状态的机制，使服务端有状态化，可以记录会话信息。而 Token 是令牌，访问资源接口（API）时所需要的资源凭证。Token 使服务端无状态化，不会存储会话信息。
• Session 和 Token 并不矛盾，作为身份认证 Token 安全性比 Session 好，因为每一个请求都有签名还能防止监听以及重放攻击，而 Session 就必须依赖链路层来保障通讯安全了。如果你需要实现有状态的会话，仍然可以增加 Session 来在服务器端保存一些状态。
• 所谓 Session 认证只是简单的把 User 信息存储到 Session 里，因为 SessionID 的不可预测性，暂且认为是安全的。而 Token ，如果指的是 OAuth Token 或类似的机制的话，提供的是 认证 和 授权 ，认证是针对用户，授权是针对 App 。其目的是让某 App 有权利访问某用户的信息。这里的 Token 是唯一的。不可以转移到其它 App上，也不可以转到其它用户上。Session 只提供一种简单的认证，即只要有此 SessionID ，即认为有此 User 的全部权利。是需要严格保密的，这个数据应该只保存在站方，不应该共享给其它网站或者第三方 App。所以简单来说：如果你的用户数据可能需要和第三方共享，或者允许第三方调用 API 接口，用 Token 。如果永远只是自己的网站，自己的 App，用什么就无所谓了。

JWT

• JSON Web Token（简称 JWT）是目前最流行的跨域认证解决方案。
• 是一种认证授权机制
• JWT 是为了在网络应用环境间传递声明而执行的一种基于 JSON 的开放标准（RFC 7519）。JWT 的声明一般被用来在身份提供者和服务提供者间传递被认证的用户身份信息，以便于从资源服务器获取资源。比如用在用户登录上。
• 可以使用 HMAC 算法或者是 RSA 的公/私秘钥对 JWT 进行签名。因为数字签名的存在，这些传递的信息是可信的。

原理

• JWT认证流程
  • 用户输入用户名/密码登录，服务端认证成功后，会返回给客户端一个 JWT
  • 客户端将 token 保存到本地（通常使用 localstorage，也可以使用 cookie）
  • 当用户希望访问一个受保护的路由或者资源的时候，需要请求头的 Authorization 字段中使用Bearer 模式添加 JWT，其内容看起来是下面这样Authorization: Bearer <token>
• 服务端的保护路由将会检查请求头 Authorization 中的 JWT 信息，如果合法，则允许用户的行为
• 因为 JWT 是自包含的（内部包含了一些会话信息），因此减少了需要查询数据库的需要
• 因为 JWT 并不使用 Cookie 的，所以你可以使用任何域名提供你的 API 服务而不需要担心跨域资源共享问题（CORS）
• 因为用户的状态不再存储在服务端的内存中，所以这是一种无状态的认证机制

使用方式

客户端收到服务器返回的 JWT，可以储存在 Cookie 里面，也可以储存在 localStorage。

方法一

• 当用户希望访问一个受保护的路由或者资源的时候，可以把它放在 Cookie 里面自动发送，但是这样不能跨域，所以更好的做法是放在 HTTP 请求头信息的 Authorization 字段里，使用 Bearer 模式添加 JWT。

  1 2 3

  GET /calendar/v1/events Host: api.example.com Authorization: Bearer <token>

  • 用户的状态不会存储在服务端的内存中，这是一种 无状态的认证机制
  • 服务端的保护路由将会检查请求头 Authorization 中的 JWT 信息，如果合法，则允许用户的行为。
  • 由于 JWT 是自包含的，因此减少了需要查询数据库的需要
  • JWT 的这些特性使得我们可以完全依赖其无状态的特性提供数据 API 服务，甚至是创建一个下载流服务。
  • 因为 JWT 并不使用 Cookie ，所以你可以使用任何域名提供你的 API 服务而不需要担心跨域资源共享问题（CORS）

方法二

• 跨域的时候，可以把 JWT 放在 POST 请求的数据体里。

方法三

• 通过URL传输。
  http://www.example.com/user?token=xxx

Token和JWT的区别

相同：

• 都是访问资源的令牌
• 都可以记录用户的信息
• 都是使服务端无状态化
• 都是只有验证成功后，客户端才能访问服务端上手保护的资源

区别：

• Token: 服务端验证客户端发送过来的 Token 时，还需要查询数据库获取用户信息，然后验证 Token 是否有效。
• JWT: 将 Token 和 Payload 加密后存储于客户端，服务端只需要使用密钥解密进行校验（校验也是 JWT 自己实现的）即可，不需要查询或者减少查询数据库，因为 JWT 自包含了用户信息和加密的数据。

常见的前后端鉴权方式

• Session-Cookie
• Token(JWT, SSO)
• OAuth2.0

问题

使用Cookie时需要考虑的问题

• 因为存储在客户端，容易被客户端篡改，使用前需要验证合法性
• 不要存储敏感数据，比如用户密码，账户余额
• 使用 httpOnly 在一定程度上提高安全性
• 尽量减少 cookie 的体积，能存储的数据量不能超过 4kb
• 设置正确的 domain 和 path，减少数据传输
• cookie 无法跨域
• 一个浏览器针对一个网站最多存 20 个Cookie，浏览器一般只允许存放 300 个Cookie
• 移动端对 cookie 的支持不是很好，而 session 需要基于 cookie 实现，所以移动端常用的是 token

使用Session时需要考虑的问题

• 将 session 存储在服务器里面，当用户同时在线量比较多时，这些 session 会占据较多的内存，需要在服务端定期的去清理过期的 session
• 当网站采用集群部署的时候，会遇到多台 web 服务器之间如何做 session 共享的问题。因为 session 是由单个服务器创建的，但是处理用户请求的服务器不一定是那个创建 session 的服务器，那么该服务器就无法拿到之前已经放入到 session 中的登录凭证之类的信息了。
• 当多个应用要共享 session 时，除了以上问题，还会遇到跨域问题，因为不同的应用可能部署的主机不一样，需要在各个应用做好 cookie 跨域的处理。
• sessionId 是存储在 cookie 中的，假如浏览器禁止 cookie 或不支持 cookie 怎么办？ 一般会把 sessionId 跟在 url 参数后面即重写 url，所以 session 不一定非得需要靠 cookie 实现
• 移动端对 cookie 的支持不是很好，而 session 需要基于 cookie 实现，所以移动端常用的是 token

使用Token时需要考虑的问题

• 如果你认为用数据库来存储 token 会导致查询时间太长，可以选择放在内存当中。比如 redis 很适合你对 token 查询的需求。
• token 完全由应用管理，所以它可以避开同源策略
• token 可以避免 CSRF 攻击(因为不需要 cookie 了)
• 移动端对 cookie 的支持不是很好，而 session 需要基于 cookie 实现，所以移动端常用的是 token

使用JWT时需要考虑的问题

• 因为 JWT 并不依赖 Cookie 的，所以你可以使用任何域名提供你的 API 服务而不需要担心跨域资源共享问题（CORS）
• JWT 默认是不加密，但也是可以加密的。生成原始 Token 以后，可以用密钥再加密一次。
• JWT 不加密的情况下，不能将秘密数据写入 JWT。
• JWT 不仅可以用于认证，也可以用于交换信息。有效使用 JWT，可以降低服务器查询数据库的次数。
• JWT 最大的优势是服务器不再需要存储 Session，使得服务器认证鉴权业务可以方便扩展。但这也是 JWT 最大的缺点：由于服务器不需要存储 Session 状态，因此使用过程中无法废弃某个 Token 或者更改 Token 的权限。也就是说一旦 JWT 签发了，到期之前就会始终有效，除非服务器部署额外的逻辑。
• JWT 本身包含了认证信息，一旦泄露，任何人都可以获得该令牌的所有权限。为了减少盗用，JWT的有效期应该设置得比较短。对于一些比较重要的权限，使用时应该再次对用户进行认证。
• JWT 适合一次性的命令认证，颁发一个有效期极短的 JWT，即使暴露了危险也很小，由于每次操作都会生成新的 JWT，因此也没必要保存 JWT，真正实现无状态。
• 为了减少盗用，JWT 不应该使用 HTTP 协议明码传输，要使用 HTTPS 协议传输。

使用加密算法时需要考虑的问题

• 绝不要以明文存储密码
• 永远使用 哈希算法 来处理密码，绝不要使用 Base64 或其他编码方式来存储密码，这和以明文存储密码是一样的，使用哈希，而不要使用编码。编码以及加密，都是双向的过程，而密码是保密的，应该只被它的所有者知道， 这个过程必须是单向的。哈希正是用于做这个的，从来没有解哈希这种说法， 但是编码就存在解码，加密就存在解密。
• 绝不要使用弱哈希或已被破解的哈希算法，像 MD5 或 SHA1 ，只使用强密码哈希算法。
• 绝不要以明文形式显示或发送密码，即使是对密码的所有者也应该这样。如果你需要 “忘记密码” 的功能，可以随机生成一个新的 一次性的（这点很重要）密码，然后把这个密码发送给用户。

只要关闭浏览器，Session就消失了
不对。对 session 来说，除非程序通知服务器删除一个 session，否则服务器会一直保留，程序一般都是在用户做 log off 的时候发个指令去删除 session。
然而浏览器从来不会主动在关闭之前通知服务器它将要关闭，因此服务器根本不会有机会知道浏览器已经关闭，之所以会有这种错觉，是大部分 session 机制都使用会话 cookie 来保存 session id，而关闭浏览器后这个 session id 就消失了，再次连接服务器时也就无法找到原来的 session。如果服务器设置的 cookie 被保存在硬盘上，或者使用某种手段改写浏览器发出的 HTTP 请求头，把原来的 session id 发送给服务器，则再次打开浏览器仍然能够打开原来的 session。
恰恰是由于关闭浏览器不会导致 session 被删除，迫使服务器为 session 设置了一个失效时间，当距离客户端上一次使用 session 的时间超过这个失效时间时，服务器就认为客户端已经停止了活动，才会把 session 删除以节省存储空间。

分布式下Session共享方案

1. Session复制

任何一个服务器上的 session 发生改变（增删改），该节点会把这个 session 的所有内容序列化，然后广播给所有其它节点，不管其他服务器需不需要 session ，以此来保证 session 同步

优点：可容错，各个服务器间Session能够实时响应。

缺点：会对网络负荷造成一定压力，如果 session 量大的话可能会造成网络堵塞，拖慢服务器性能。

1. 粘性Session/IP绑定策略

采用 Ngnix 中的 ip_hash 机制，将某个 ip的所有请求都定向到同一台服务器上，即将用户与服务器绑定。 用户第一次请求时，负载均衡器将用户的请求转发到了 A 服务器上，如果负载均衡器设置了粘性 session 的话，那么用户以后的每次请求都会转发到 A 服务器上，相当于把用户和 A 服务器粘到了一块，这就是粘性 session 机制。

优点：简单，不需要对Session做任何个处理。

缺点：缺乏容错性，如果当前访问的服务器发生故障，用户被转移到第二个服务器上时，他的 session 信息都将失效。

3. Session共享（常用）

• 使用分布式缓存方案比如 Memcached 、Redis 来缓存 session，但是要求 Memcached 或 Redis 必须是集群
• 把 session 放到 Redis 中存储，虽然架构上变得复杂，并且需要多访问一次 Redis ，但是这种方案带来的好处也是很大的：
  • 实现了 session 共享；
  • 可以水平扩展（增加 Redis 服务器）；
  • 服务器重启 session 不丢失（不过也要注意 session 在 Redis 中的刷新/失效机制）；
  • 不仅可以跨服务器 session 共享，甚至可以跨平台（例如网页端和 APP 端）

4. Session持久化

将 session 存储到数据库中，保证 session 的持久化

优点：服务器出现问题，session 不会丢失

缺点：如果网站的访问量很大，把 session 存储到数据库中，会对数据库造成很大压力，还需要增加额外的开销维护数据库。

Word2Vec note

引入

Word2Vec是从大量文本语料中以无监督的方式学习语义知识的一种模型，它被大量的用在自然语言处理中。Word2Vec其实就是通过学习文本来用词向量的方式表征词的语义信息，即通过一个嵌入空间使得语义上相似的单词在该空间内距离很近。Embedding其实就是一个映射，将单词从原先所属的空间映射到新的多维空间中，也就是把原先词所在的空间嵌入到一个新的空间中去。

Week 2

深度学习与神经网络基础，pytorch基础。

神经网络训练过程

• 将DataSet生成iter(train_iter, test_iter), 每个iter由X,y构成 (X:Sample的所有特征[samples * features], y:真实标签).
• 计算y_hat (y_hat:通过构造的神经网络模型得到的预测值).
• 计算损失函数 (均方差, 交叉熵).
• 对所有params梯度清零.
• loss.backward反向传播, 对损失函数求梯度, 也就是得所有的到权重和偏置的梯度param.grad.
• params带入梯度下降算法, 更新params.
• 每个epoch后, 将测试数据带入训练后的网络模型中计算准确率.

注意

1. W初始化
首先介绍一下我们不应该做的事情（即初始化为0）。需要注意的是我们并不知道在训练神经网络中每一个权重最后的值，但是如果进行了恰当的数据归一化后，我们可以有理由认为有一半的权重是正的，另一半是负的。令所有权重都初始化为0这个一个听起来还蛮合理的想法也许是一个我们假设中最好的一个假设了。但结果正确是一个错误(的想法)，因为如果神经网络计算出来的输出值都一个样，那么反向传播算法计算出来的梯度值一样，并且参数更新值也一样(w=w−α∗dw)。更一般地说，如果权重初始化为同一个值，网络就不可能不对称(即是对称的)。

2. 梯度清零
每次反向传播前需要将params的梯度清零，否则每次计算的梯度为上一个梯度的累加。

3. 反向传播
计算的是给定图的叶子结点的梯度，对Loss函数进行反向传播计算所得即为所有的W与b。

4. python方法
method()代表执行完该函数
method仅函数对象

5. 二分类问题不小心将最后一层设为10维
最后训练出来的权重使得结果在0, 1上的概率更大，不排除最后的结果为2 ~ 9。

6. 网络的层次
每一层为激活函数

层数-1 为连接层 连接层对应[W, b]

X = [batch_size * features]

• 第一层输入为([-1, features])

• 矩阵计算: [-1, features] * [W1(input_num, hidden_num)] + b1

• 隐藏层输入为(input_num, hidden_num)

• 矩阵计算: [-1, hidden_num] * [W2(hidden_num, output_num)] + b2

• 输出层为(hidden_num, output_num)

• 最终矩阵格式: [-1, output_num]

7. 特殊第一层input输入层
输入的特征可能type为Long, 一定要转为float.
batch_size与input_num无关, 但features一定与input_num相等.

8. X.permute
model的forward必须要X.permute(1, 0)
LSTM(batch_first=True)没用？？？

9. python路径问题
相对路径取决于调用该函数的python文件位置，不是子函数所在python文件相对于文件的位置。

10. pytorch使用GPU计算

• 训练及评价集需要X.cuda()将数据移至GPU
• model与loss函数需要model.cuda(), loss.cuda()移至GPU

11. 导出数据
TestLoader导出预测结果时，一定不能将导入的数据Shuffle!!!

12. pad
<pad>对应一个随机生成的向量

13. torch.no_grad()

• requires_grad=True 要求计算梯度
• requires_grad=False 不要求计算梯度
• with torch.no_grad()或者@torch.no_grad()中的数据不需要计算梯度，也不会进行反向传播

即使一个tensor（命名为x）的requires_grad = True，由x得到的新tensor（命名为w-标量）requires_grad也为False，且grad_fn也为None,即不会对w求导。

1
2
3
4
5
6
7
8
9
10
11

x = torch.randn(10, 5, requires_grad = True)
y = torch.randn(10, 5, requires_grad = True)
z = torch.randn(10, 5, requires_grad = True)
with torch.no_grad():
    w = x + y + z
    print(w.requires_grad)
    print(w.grad_fn)
    print(w.requires_grad)
False
None
False

14. train()/eval()

• 在训练模型时，前面加上model.train()
  启用 BatchNormalization 和 Dropout

• 在测试模型时，前面加上model.eval()
  不启用 BatchNormalization 和 Dropout
  即使不训练，它也会改变权值。这是model中含有batch normalization层所带来的的性质。

问题

最后一层输出不加激活函数 含义(最后预测值是数值最大的 因此没有影响)？？？

隐藏层没有激活函数 含义？？？

LSTM(batch_first=True)没用？？？

embedding_layer(X)中X.shape为(batch,seq)或(seq,batch)没影响？？？
若batch_first了embedding后要(batch,seq)后传入rnn？？？

lstm门使用sigmoid代表门开程度，而不是四舍五入为0或1？？？

词向量框架

• 拿到每个样本
• 每个样本分词
• 构建词典{word: index}
• 对每个Sample标准化处理， 长度不足补<pad>
• 将每个Sample中的word对应index，没有的对应<pad>的index
• 获取预训练的词向量

Docker-NextCloud

docker-compose.yml

1
2
3
4
5
6
7
8
9
10

version: '3'

services:
  nextcloud:
    image: nextcloud
    restart: "no"
    volumes:
      - ~/docker_nextcloud/data/:/var/www/html
    ports:
      - "25000:80"

gRPC入门

下载依赖

pip install grpc
pip install proto
pip install grpc-tools

设置接口

在.proto文件中定义接口

生成文件

python -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. api.proto

proto示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

syntax = "proto3";

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  // Sends another greeting
  rpc SayHelloAgain (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

server示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class Greeter(api_pb2_grpc.GreeterServicer):

    def SayHello(self, request, context):
        return api_pb2.HelloReply(message='Hello, %s!' % request.name)

    def SayHelloAgain(self, request, context):
        return api_pb2.HelloReply(message='Hello again, %s!' % request.name)


def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=4))
    api_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('localhost:50051')
    server.start()
    try:
        while True:
            time.sleep(60 * 60 * 24)
    except KeyboardInterrupt:
        server.stop(0)


if __name__ == '__main__':
    serve()

client示例

1
2
3
4
5
6
7
8
9
10
11

def run():
  channel = grpc.insecure_channel('localhost:50051')
  stub = api_pb2_grpc.GreeterStub(channel)
  response = stub.SayHello(api_pb2.HelloRequest(name='you'))
  print("Greeter client received: " + response.message)
  response = stub.SayHelloAgain(api_pb2.HelloRequest(name='you'))
  print("Greeter client received: " + response.message)


if __name__ == '__main__':
    run()

Nginx

检测配置文件
nginx -t

重启服务
nginx -s reload

若重启报错 先运行
nginx -c /etc/nginx/nginx.conf

SSL config

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

  server {
      listen       80 default_server;
      listen       [::]:80 default_server;
      server_name  api.gfgf.tech;
      root         /usr/share/nginx/html;

   return 301 https://$server_name$request_uri;

      # Load configuration files for the default server block.
      include /etc/nginx/default.d/*.conf;

      location / {
              proxy_pass http://127.0.0.1:21000;
      }

      error_page 404 /404.html;
          location = /40x.html {
      }

      error_page 500 502 503 504 /50x.html;
          location = /50x.html {
      }
  }

  server {
      listen       443 ssl http2 default_server;
      listen       [::]:443 ssl http2 default_server;
      server_name  api.gfgf.tech;
      root         /usr/share/nginx/html;

      ssl_certificate "/root/.acme.sh/api.gfgf.tech/api.gfgf.tech.cer";
      ssl_certificate_key "/root/.acme.sh/api.gfgf.tech/api.gfgf.tech.key";
      ssl_session_cache shared:SSL:1m;
      ssl_session_timeout  10m;
      ssl_ciphers HIGH:!aNULL:!MD5;
      ssl_prefer_server_ciphers on;

      # Load configuration files for the default server block.
      include /etc/nginx/default.d/*.conf;

      location / {
proxy_pass http://localhost:21000;
      }

      error_page 404 /404.html;
          location = /40x.html {
      }

      error_page 500 502 503 504 /50x.html;
          location = /50x.html {
      }
  }

Docker-Compose

运行指令

docker-compose指令执行当前文件夹下docker-compose.yml文件

项目运行
docker-compose up -d

项目停止
docker-compose down

挂载

volumes声明过的名称才能用在镜像的volumes挂载
镜像中volumes挂载地址也可以使用相对路径

Docker-GitLab

注意

若容器端口号设置为80，如果你这时修改external_url地址为http://ip:8080.
那GitLab肯定访问不了，因为已经将内部的端口号修改为8080端口了，而映射的是容器的80端口。

故一定要将容器内部端口号与宿主机端口号映射一致！！！

external_utl ‘http://119.23.107.61:13000'
ports:
- “13000:13000”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

version: '3'

services:
  gitlab:
    image: gitlab/gitlab-ce
    restart: always
    environment:
      TZ: "Asia/Shanghai"
      GITLAB_OMNIBUS_CONFIG: |
        external_url 'http://119.23.107.61:13000' // 好像需要手动改
    volumes:
      - ~/docker_gitlab/config:/etc/gitlab 
      - ~/docker_gitlab/logs:/var/log/gitlab 
      - ~/docker_gitlab/data:/var/opt/gitlab
    ports:
      - "13000:13000"
      - "13443:443"
      - "13022:22"

Docker & Docker-Compose

运行docker

$ service docker start

运行容器

docker run -i -t -p 11000:8888 continuumio/anaconda3 /bin/bash
-ddetach直接后台运行

1
2
3

-i: 是  以交互模式运行容器，通常与 -t 同时使用；
-t: 为容器重新分配一个伪输入终端，通常与 -i 同时使用；
-p: 指定端口映射，格式为：主机(宿主)端口:容器端口

退出容器并保存在后台
Control + P + Q

进入容器
docker exec -it name /bin/bash
此时exit不会关闭容器

查看运行的容器
docker ps -a

映射或挂载(重要)

宿主机:镜像

默认挂载路径
/var/lib/docker/volumes

镜像相关

生成镜像
docker commit -a "username" -m "msg" container_name new_image_name

上传镜像
将打包好的新镜像上传到 Docker Hub：

首先我们需要将这个新镜像打上 tag，方便在公共服务器进行上传：

docker tag new_anaconda_xgboost:latest nimendavid/machine_learning:v0.1

其中:

new_anaconda_xgboost:latest
(本地镜像名称:tag)

可以通过 docker image ls 查看
nimendavid/machine_learning:v0.1

格式是(dockerhub用户名/仓库名:tag) ，需要自己有一个dockerhub账号，v0.1就是自定义的版本号码

然后记得登录在服务器上dockerhub，否则推送会报错：

docker login

使用Docker配置Anaconda环境运行Jupyter

配置Anaconda环境

挂载

• 文件夹挂载
  -v /root/notebook:/notebook
  (宿主机目录:镜像内挂载目录)

• 配置文件挂载(生成的文件夹)
  -v /root/docker/config/anaconda3/jupyter_notebook_config.json:/root/.jupyter/jupyter_notebook_config.json

Example
docker run -i -t -p 11000:8888 -v ~/notebook:/notebook -v ~/docker/config/jupyter:/root/.jupyter continuumio/anaconda3 /bin/bash
挂载参数要在容器前

配置Jupyter Notebook

jupyter notebook --allow-root

启动Notebook
jupyter notebook --port 8888 --ip 0.0.0.0 --allow-root

后台运行Notebook
nohup jupyter notebook --port 8888 --ip 0.0.0.0 --allow-root &

相关配置

配置文件

1
2
3
4
5
6
7
8

c = get_config()
c.IPKernelApp.pylab = "inline"
c.NotebookApp.ip = "*"
c.NotebookAPp.open_browser = False
c.NotebookApp.password = 'sha1:5295d47ebd06:cdca9499f90b4b4616c935fdff61dda71e1e4393'
# c.NotebookApp.certfile = u'/root/.jupyter/mycert.pem'
c.NotebookApp.port= 8888
c.NotebookApp.notebook_dir = "/"

docker-compose配置出问题？

1
2
3
4
5
6
7
8
9
10
11

version: '3'

services:
  notebook:
    image: continuumio/anaconda3
    restart: "no"
    volumes:
      - ~/notebook:/notebook
      - ~/docker/config/jupyter:/root/.jupyter
    ports:
      - "11000:80"

使用Docker搭建图床

安装容器编排工具Compose
pip3 install docker-compose

pull镜像
docker pull mariadb:latest
docker pull nmtan/chevereto:latest

使用Docker-Compose启动
mkdir cheverto/
cd cheverto
touch docker-compose.yaml

docker-compose.yaml配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

version: '3'

services:
  db:
    image: mariadb
    volumes:
      - database:/var/lib/mysql:rw
    restart: always
    networks:
      - private
    environment:
      MYSQL_ROOT_PASSWORD: chevereto_root
      MYSQL_DATABASE: chevereto
      MYSQL_USER: chevereto
      MYSQL_PASSWORD: chevereto

  chevereto:
    depends_on:
      - db
    image: nmtan/chevereto
    restart: always
    networks:
      - private
    environment:
      CHEVERETO_DB_HOST: db
      CHEVERETO_DB_USERNAME: chevereto
      CHEVERETO_DB_PASSWORD: chevereto
      CHEVERETO_DB_NAME: chevereto
      CHEVERETO_DB_PREFIX: chv_
    volumes:
      - chevereto_images:/var/www/html/images:rw
      - chevereto_php_config:/usr/local/etc/php:rw
    ports:
      - 12000:80

networks:
  private:
volumes:
  database:
  chevereto_images:
  chevereto_php_config:

对应挂载到当前文件夹中的php.ini文件(注意 php.ini文件需要先创建 否则docker会自动创建同名文件夹)
- ./php.ini:/usr/local/etc/php/php.ini:rw

php.ini

1
2
3

memory_limit = 256M;
upload_max_filesize = 100M;
post_max_size = 100M;

运行Docker-Compose
docker-compose up -d

KNN-手写体数字数据集

1
2
3
4

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.neighbors import KNeighborsClassifier

1
2
3

digits = datasets.load_digits()
X = digits.data
X.shape

(1797, 64)

1
2

y = digits.target
y.shape

(1797,)

1
2
3

one = X[100]
one = one.reshape(8, 8)
one

array([[ 0.,  0.,  0.,  2., 13.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  8., 15.,  0.,  0.,  0.],
       [ 0.,  0.,  5., 16.,  5.,  2.,  0.,  0.],
       [ 0.,  0., 15., 12.,  1., 16.,  4.,  0.],
       [ 0.,  4., 16.,  2.,  9., 16.,  8.,  0.],
       [ 0.,  0., 10., 14., 16., 16.,  4.,  0.],
       [ 0.,  0.,  0.,  0., 13.,  8.,  0.,  0.],
       [ 0.,  0.,  0.,  0., 13.,  6.,  0.,  0.]])

1

plt.imshow(one)

<matplotlib.image.AxesImage at 0x1a203a9ad0>

分离训练测试集

1
2

from sklearn.model_selection import train_test_split
train_test_split?

Signature: train_test_split(*arrays, **options)
Docstring:
Split arrays or matrices into random train and test subsets

Quick utility that wraps input validation and
``next(ShuffleSplit().split(X, y))`` and application to input data
into a single call for splitting (and optionally subsampling) data in a
oneliner.

Read more in the :ref:`User Guide <cross_validation>`.

Parameters
----------
*arrays : sequence of indexables with same length / shape[0]
    Allowed inputs are lists, numpy arrays, scipy-sparse
    matrices or pandas dataframes.

test_size : float, int or None, optional (default=None)
    If float, should be between 0.0 and 1.0 and represent the proportion
    of the dataset to include in the test split. If int, represents the
    absolute number of test samples. If None, the value is set to the
    complement of the train size. If ``train_size`` is also None, it will
    be set to 0.25.

train_size : float, int, or None, (default=None)
    If float, should be between 0.0 and 1.0 and represent the
    proportion of the dataset to include in the train split. If
    int, represents the absolute number of train samples. If None,
    the value is automatically set to the complement of the test size.

random_state : int, RandomState instance or None, optional (default=None)
    If int, random_state is the seed used by the random number generator;
    If RandomState instance, random_state is the random number generator;
    If None, the random number generator is the RandomState instance used
    by `np.random`.

shuffle : boolean, optional (default=True)
    Whether or not to shuffle the data before splitting. If shuffle=False
    then stratify must be None.

stratify : array-like or None (default=None)
    If not None, data is split in a stratified fashion, using this as
    the class labels.

Returns
-------
splitting : list, length=2 * len(arrays)
    List containing train-test split of inputs.

    .. versionadded:: 0.16
        If the input is sparse, the output will be a
        ``scipy.sparse.csr_matrix``. Else, output type is the same as the
        input type.

Examples
--------
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> X, y = np.arange(10).reshape((5, 2)), range(5)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])
>>> list(y)
[0, 1, 2, 3, 4]

>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, test_size=0.33, random_state=42)
...
>>> X_train
array([[4, 5],
       [0, 1],
       [6, 7]])
>>> y_train
[2, 0, 3]
>>> X_test
array([[2, 3],
       [8, 9]])
>>> y_test
[1, 4]

>>> train_test_split(y, shuffle=False)
[[0, 1, 2], [3, 4]]
File:      /Applications/anaconda3/lib/python3.7/site-packages/sklearn/model_selection/_split.py
Type:      function

1
2
3
4
5

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
print(X_train.shape)
print(y_train.shape)
print(X_test.shape)
print(y_test.shape)

(1437, 64)
(1437,)
(360, 64)
(360,)

测试

1

KNNClf = KNeighborsClassifier(n_neighbors=3)

1

KNNClf.fit(X_train, y_train)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=None, n_neighbors=3, p=2,
                     weights='uniform')

1
2

res = KNNClf.predict(X_test)
res

array([3, 4, 8, 5, 5, 7, 0, 3, 1, 4, 7, 5, 5, 8, 0, 7, 4, 7, 1, 7, 9, 4,
       4, 7, 6, 1, 2, 9, 1, 3, 3, 3, 7, 0, 7, 0, 2, 8, 9, 1, 1, 5, 4, 8,
       9, 0, 4, 9, 4, 9, 7, 2, 7, 3, 3, 4, 1, 9, 9, 9, 0, 4, 0, 6, 1, 0,
       0, 3, 6, 2, 3, 2, 8, 5, 9, 3, 1, 1, 6, 9, 8, 1, 2, 3, 2, 6, 8, 8,
       4, 6, 8, 6, 3, 9, 2, 8, 3, 6, 5, 7, 1, 7, 3, 8, 8, 8, 0, 0, 9, 1,
       9, 8, 5, 1, 1, 0, 1, 6, 5, 1, 7, 6, 5, 7, 7, 2, 2, 7, 3, 1, 9, 5,
       9, 5, 5, 3, 8, 4, 9, 5, 4, 6, 0, 5, 4, 8, 6, 1, 2, 8, 0, 9, 0, 9,
       7, 9, 7, 0, 2, 8, 2, 4, 0, 6, 2, 6, 7, 5, 6, 3, 8, 8, 0, 3, 2, 0,
       6, 1, 0, 6, 0, 5, 9, 3, 3, 0, 4, 0, 4, 2, 4, 9, 0, 6, 7, 4, 6, 5,
       9, 7, 2, 2, 3, 3, 0, 3, 9, 4, 9, 8, 5, 6, 9, 0, 1, 3, 5, 0, 5, 1,
       6, 4, 6, 6, 6, 7, 9, 1, 0, 7, 6, 6, 7, 8, 0, 3, 8, 5, 6, 8, 1, 3,
       0, 3, 6, 0, 3, 5, 6, 7, 0, 6, 9, 7, 0, 0, 2, 1, 6, 6, 9, 1, 6, 9,
       8, 7, 0, 2, 5, 1, 8, 6, 4, 3, 8, 2, 9, 2, 8, 4, 6, 4, 8, 9, 3, 1,
       1, 5, 0, 7, 8, 2, 3, 8, 4, 7, 7, 7, 7, 9, 4, 1, 7, 0, 2, 9, 1, 8,
       2, 4, 1, 0, 7, 5, 6, 0, 7, 1, 1, 5, 7, 1, 1, 6, 5, 6, 2, 2, 3, 9,
       7, 5, 3, 1, 5, 9, 9, 2, 5, 1, 6, 8, 2, 2, 4, 2, 1, 0, 6, 1, 2, 9,
       7, 5, 3, 5, 6, 1, 8, 1])

1

y_test

array([3, 4, 8, 5, 5, 7, 0, 3, 1, 4, 7, 5, 5, 8, 0, 7, 4, 7, 1, 7, 9, 4,
       4, 7, 6, 1, 2, 9, 1, 3, 3, 3, 7, 0, 7, 0, 2, 8, 9, 1, 1, 5, 4, 8,
       9, 0, 4, 9, 4, 9, 7, 2, 7, 8, 3, 4, 1, 9, 9, 9, 0, 4, 0, 6, 1, 0,
       0, 3, 6, 2, 3, 2, 8, 5, 9, 3, 1, 1, 6, 9, 8, 1, 2, 3, 2, 6, 8, 8,
       4, 6, 8, 6, 3, 9, 2, 8, 3, 6, 5, 7, 1, 7, 9, 8, 8, 8, 0, 0, 9, 1,
       4, 8, 5, 1, 1, 0, 1, 6, 5, 1, 7, 6, 5, 7, 7, 2, 2, 7, 3, 1, 9, 5,
       9, 5, 5, 3, 8, 4, 9, 5, 4, 6, 0, 5, 4, 8, 6, 1, 2, 8, 0, 9, 0, 9,
       7, 9, 7, 0, 2, 8, 2, 4, 0, 6, 2, 6, 7, 5, 6, 3, 8, 8, 0, 3, 2, 0,
       6, 1, 0, 6, 0, 5, 9, 3, 3, 0, 4, 0, 4, 2, 4, 9, 0, 6, 7, 4, 6, 5,
       9, 7, 2, 2, 3, 3, 0, 3, 9, 4, 9, 8, 5, 6, 9, 0, 1, 3, 5, 0, 5, 1,
       6, 4, 6, 6, 6, 7, 9, 1, 0, 7, 6, 6, 7, 8, 0, 3, 8, 5, 6, 8, 1, 3,
       0, 3, 6, 0, 3, 5, 6, 7, 0, 6, 9, 7, 0, 0, 2, 1, 6, 6, 9, 1, 6, 9,
       8, 7, 0, 2, 5, 1, 8, 6, 4, 3, 8, 2, 9, 2, 8, 4, 6, 4, 8, 9, 3, 1,
       1, 5, 0, 7, 8, 2, 3, 8, 4, 7, 7, 7, 7, 7, 4, 1, 3, 0, 2, 9, 1, 8,
       2, 4, 1, 0, 7, 5, 6, 0, 7, 1, 1, 5, 7, 1, 1, 6, 5, 6, 2, 2, 3, 9,
       7, 5, 3, 1, 5, 9, 9, 2, 5, 1, 6, 8, 2, 2, 4, 2, 1, 0, 6, 1, 2, 9,
       7, 5, 3, 5, 6, 1, 8, 8])

1
2

num = sum(res == y_test)
num

354

1

print('accuracy ', num / len(y_test))

accuracy  0.9833333333333333

使用sklearn中封装的计算精确度的方法

1

from sklearn.metrics import accuracy_score as accuracy

1

accuracy(res, y_test)

0.9833333333333333

1
2

KNN-鸢尾花数据集

1
2
3

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

使用sklearn本地数据集中的鸢尾花数据集

1
2

iris = datasets.load_iris()
iris.keys()

dict_keys(['data', 'target', 'target_names', 'DESCR', 'feature_names', 'filename'])

1

X = iris.data

1

Y = iris.target

1

X.shape

(150, 4)

1

Y.shape

(150,)

手动分离测试数据

1
2

shuffled_indexes = np.random.permutation(len(X))
shuffled_indexes

array([ 47,  10, 144,  57, 135,  58,  36, 136,  73, 109,  64,  15, 104,
       143, 108,  83,  23, 126, 125, 131, 137,  22,  16,  29, 118,  31,
        33,  52,  32, 132,  45,  38,  78, 139,  30,  37,  61,  97, 122,
        56, 107,  66, 114,  87,  43,  76,  84,  79, 142,  70,  77,  42,
         7, 138, 141, 120, 129,  44,  24,  53, 116,  13,  91, 119,  93,
         6,  60,  50,  67,  20,  54,  71,  89,  68,  21, 133, 148,  81,
        25,  48, 130, 127,  28,  90,  82, 146, 100, 105,  80,  94,  14,
        55, 111, 106, 101, 103,  35,  99,   3,  26,  69, 124,  95,  96,
       140,  46,  19,  34,  75,  59,   1, 117, 121,  49, 110,   0, 115,
        72,   9,  18, 149,  40, 145,  92, 123,  51,   4,  11,  39,  85,
        62, 147, 102,  74,   2,  86,   8,  17,   5,  27, 112, 128,  12,
        65,  41, 134,  63,  88, 113,  98])

1
2

test_ratio = 0.2
test_size = int(len(X) * test_ratio)

1
2

test_indexes = shuffled_indexes[:test_size]
train_indexes = shuffled_indexes[test_size:]

1
2
3
4
5

X_train = X[train_indexes]
Y_train = Y[train_indexes]

X_test = X[test_indexes]
Y_test = Y[test_indexes]

1

print(X_train.shape);print(Y_train.shape);print(X_test.shape);print(Y_test.shape)

(120, 4)
(120,)
(30, 4)
(30,)

使用sklearn分离

1
2

from sklearn.model_selection import train_test_split
train_test_split?

Signature: train_test_split(*arrays, **options)
Docstring:
Split arrays or matrices into random train and test subsets

Quick utility that wraps input validation and
``next(ShuffleSplit().split(X, y))`` and application to input data
into a single call for splitting (and optionally subsampling) data in a
oneliner.

Read more in the :ref:`User Guide <cross_validation>`.

Parameters
----------
*arrays : sequence of indexables with same length / shape[0]
    Allowed inputs are lists, numpy arrays, scipy-sparse
    matrices or pandas dataframes.

test_size : float, int or None, optional (default=None)
    If float, should be between 0.0 and 1.0 and represent the proportion
    of the dataset to include in the test split. If int, represents the
    absolute number of test samples. If None, the value is set to the
    complement of the train size. If ``train_size`` is also None, it will
    be set to 0.25.

train_size : float, int, or None, (default=None)
    If float, should be between 0.0 and 1.0 and represent the
    proportion of the dataset to include in the train split. If
    int, represents the absolute number of train samples. If None,
    the value is automatically set to the complement of the test size.

random_state : int, RandomState instance or None, optional (default=None)
    If int, random_state is the seed used by the random number generator;
    If RandomState instance, random_state is the random number generator;
    If None, the random number generator is the RandomState instance used
    by `np.random`.

shuffle : boolean, optional (default=True)
    Whether or not to shuffle the data before splitting. If shuffle=False
    then stratify must be None.

stratify : array-like or None (default=None)
    If not None, data is split in a stratified fashion, using this as
    the class labels.

Returns
-------
splitting : list, length=2 * len(arrays)
    List containing train-test split of inputs.

    .. versionadded:: 0.16
        If the input is sparse, the output will be a
        ``scipy.sparse.csr_matrix``. Else, output type is the same as the
        input type.

Examples
--------
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> X, y = np.arange(10).reshape((5, 2)), range(5)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])
>>> list(y)
[0, 1, 2, 3, 4]

>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, test_size=0.33, random_state=42)
...
>>> X_train
array([[4, 5],
       [0, 1],
       [6, 7]])
>>> y_train
[2, 0, 3]
>>> X_test
array([[2, 3],
       [8, 9]])
>>> y_test
[1, 4]

>>> train_test_split(y, shuffle=False)
[[0, 1, 2], [3, 4]]
File:      /Applications/anaconda3/lib/python3.7/site-packages/sklearn/model_selection/_split.py
Type:      function

1

X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=1)

1
2
3
4

print(X_train.shape)
print(Y_train.shape)
print(X_test.shape)
print(Y_test.shape)

(120, 4)
(120,)
(30, 4)
(30,)

使用sklearn中的KNN分离器测试

1
2

from sklearn.neighbors import KNeighborsClassifier
KNeighborsClassifier?

Init signature:
KNeighborsClassifier(
    n_neighbors=5,
    weights='uniform',
    algorithm='auto',
    leaf_size=30,
    p=2,
    metric='minkowski',
    metric_params=None,
    n_jobs=None,
    **kwargs,
)
Docstring:     
Classifier implementing the k-nearest neighbors vote.

Read more in the :ref:`User Guide <classification>`.

Parameters
----------
n_neighbors : int, optional (default = 5)
    Number of neighbors to use by default for :meth:`kneighbors` queries.

weights : str or callable, optional (default = 'uniform')
    weight function used in prediction.  Possible values:

    - 'uniform' : uniform weights.  All points in each neighborhood
      are weighted equally.
    - 'distance' : weight points by the inverse of their distance.
      in this case, closer neighbors of a query point will have a
      greater influence than neighbors which are further away.
    - [callable] : a user-defined function which accepts an
      array of distances, and returns an array of the same shape
      containing the weights.

algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, optional
    Algorithm used to compute the nearest neighbors:

    - 'ball_tree' will use :class:`BallTree`
    - 'kd_tree' will use :class:`KDTree`
    - 'brute' will use a brute-force search.
    - 'auto' will attempt to decide the most appropriate algorithm
      based on the values passed to :meth:`fit` method.

    Note: fitting on sparse input will override the setting of
    this parameter, using brute force.

leaf_size : int, optional (default = 30)
    Leaf size passed to BallTree or KDTree.  This can affect the
    speed of the construction and query, as well as the memory
    required to store the tree.  The optimal value depends on the
    nature of the problem.

p : integer, optional (default = 2)
    Power parameter for the Minkowski metric. When p = 1, this is
    equivalent to using manhattan_distance (l1), and euclidean_distance
    (l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.

metric : string or callable, default 'minkowski'
    the distance metric to use for the tree.  The default metric is
    minkowski, and with p=2 is equivalent to the standard Euclidean
    metric. See the documentation of the DistanceMetric class for a
    list of available metrics.
    If metric is "precomputed", X is assumed to be a distance matrix and
    must be square during fit. X may be a :term:`Glossary <sparse graph>`,
    in which case only "nonzero" elements may be considered neighbors.

metric_params : dict, optional (default = None)
    Additional keyword arguments for the metric function.

n_jobs : int or None, optional (default=None)
    The number of parallel jobs to run for neighbors search.
    ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
    ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
    for more details.
    Doesn't affect :meth:`fit` method.

Attributes
----------
classes_ : array of shape (n_classes,)
    Class labels known to the classifier

effective_metric_ : string or callble
    The distance metric used. It will be same as the `metric` parameter
    or a synonym of it, e.g. 'euclidean' if the `metric` parameter set to
    'minkowski' and `p` parameter set to 2.

effective_metric_params_ : dict
    Additional keyword arguments for the metric function. For most metrics
    will be same with `metric_params` parameter, but may also contain the
    `p` parameter value if the `effective_metric_` attribute is set to
    'minkowski'.

outputs_2d_ : bool
    False when `y`'s shape is (n_samples, ) or (n_samples, 1) during fit
    otherwise True.

Examples
--------
>>> X = [[0], [1], [2], [3]]
>>> y = [0, 0, 1, 1]
>>> from sklearn.neighbors import KNeighborsClassifier
>>> neigh = KNeighborsClassifier(n_neighbors=3)
>>> neigh.fit(X, y)
KNeighborsClassifier(...)
>>> print(neigh.predict([[1.1]]))
[0]
>>> print(neigh.predict_proba([[0.9]]))
[[0.66666667 0.33333333]]

See also
--------
RadiusNeighborsClassifier
KNeighborsRegressor
RadiusNeighborsRegressor
NearestNeighbors

Notes
-----
See :ref:`Nearest Neighbors <neighbors>` in the online documentation
for a discussion of the choice of ``algorithm`` and ``leaf_size``.

.. warning::

   Regarding the Nearest Neighbors algorithms, if it is found that two
   neighbors, neighbor `k+1` and `k`, have identical distances
   but different labels, the results will depend on the ordering of the
   training data.

https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm
File:           /Applications/anaconda3/lib/python3.7/site-packages/sklearn/neighbors/_classification.py
Type:           ABCMeta
Subclasses:     

1
2

KNNClf = KNeighborsClassifier(n_neighbors=3)
KNNClf.fit(X_train, Y_train)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=None, n_neighbors=3, p=2,
                     weights='uniform')

1
2

res = KNNClf.predict(X_test)
res

array([0, 1, 1, 0, 2, 1, 2, 0, 0, 2, 1, 0, 2, 1, 1, 0, 1, 1, 0, 0, 1, 1,
       1, 0, 2, 1, 0, 0, 1, 2])

1

Y_test

array([0, 1, 1, 0, 2, 1, 2, 0, 0, 2, 1, 0, 2, 1, 1, 0, 1, 1, 0, 0, 1, 1,
       1, 0, 2, 1, 0, 0, 1, 2])

1

acc = sum(res == Y_test)

1

print('accuracy ', acc / len(Y_test))

accuracy  1.0

1
2

手动实现KNN

1
2

import numpy as np
import matplotlib.pyplot as plt

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

raw_data_x = [[3.393533211, 2.331273381],
              [3.110073483, 1.781539638],
              [1.343808831, 3.368360954],
              [3.582294042, 4.679179110],
              [2.280362439, 2.866990263],
              [7.423436942, 4.696522875],
              [5.745051997, 3.533989803],
              [9.172168622, 2.511101045],
              [7.792783481, 3.424088941],
              [7.939820817, 0.791637231]
             ]
raw_data_y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

1
2

x_train = np.array(raw_data_x)
y_train = np.array(raw_data_y)

1

x_train

array([[3.39353321, 2.33127338],
       [3.11007348, 1.78153964],
       [1.34380883, 3.36836095],
       [3.58229404, 4.67917911],
       [2.28036244, 2.86699026],
       [7.42343694, 4.69652288],
       [5.745052  , 3.5339898 ],
       [9.17216862, 2.51110105],
       [7.79278348, 3.42408894],
       [7.93982082, 0.79163723]])

1

y_train==1

array([False, False, False, False, False,  True,  True,  True,  True,
        True])

1
2
3

plt.scatter(x_train[y_train==1, 0], x_train[y_train==1, 1], color='r', label='1')
plt.scatter(x_train[y_train==0, 0], x_train[y_train==0, 1], color='g', label='0')
plt.legend()

<matplotlib.legend.Legend at 0x122311ad0>

1
2
3
4
5
6
7

x = np.array([8.093607318, 3.365731514])

plt.scatter(x_train[y_train==1, 0], x_train[y_train==1, 1], color='r', label='1')
plt.scatter(x_train[y_train==0, 0], x_train[y_train==0, 1], color='g', label='0')
plt.scatter(x[0], x[1], color='b')
plt.legend()
plt.show()

1
2

import math
distance = []

1
2
3

for each in x_train:
    d = math.sqrt(np.sum((each - x) ** 2))
    distance.append(d)

1

distance

[4.812566907609877,
 5.229270827235305,
 6.749798999160064,
 4.6986266144110695,
 5.83460014556857,
 1.4900114024329525,
 2.354574897431513,
 1.3761132675144652,
 0.3064319992975,
 2.5786840957478887]

1
2

distances = [math.sqrt(np.sum((each - x) ** 2)) for each in x_train]
distances

[4.812566907609877,
 5.229270827235305,
 6.749798999160064,
 4.6986266144110695,
 5.83460014556857,
 1.4900114024329525,
 2.354574897431513,
 1.3761132675144652,
 0.3064319992975,
 2.5786840957478887]

1
2

nearest = np.argsort(distances)
nearest

array([8, 7, 5, 6, 9, 3, 0, 1, 4, 2])

1
2
3

k = 6
topK_y = [y_train[i] for i in nearest[:k]]
topK_y

[1, 1, 1, 1, 1, 0]

1
2
3

import collections
votes = collections.Counter(topK_y)
votes

Counter({1: 5, 0: 1})

1

votes.most_common(1)

[(1, 5)]

1
2

predict_y = votes.most_common(1)[0][0]
predict_y

1

scikit-learn实现KNN

1
2

import numpy as np
from sklearn.neighbors import KNeighborsClassifier

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

raw_data_x = [[3.393533211, 2.331273381],
              [3.110073483, 1.781539638],
              [1.343808831, 3.368360954],
              [3.582294042, 4.679179110],
              [2.280362439, 2.866990263],
              [7.423436942, 4.696522875],
              [5.745051997, 3.533989803],
              [9.172168622, 2.511101045],
              [7.792783481, 3.424088941],
              [7.939820817, 0.791637231]
             ]
raw_data_y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]

x_train = np.array(raw_data_x)
y_train = np.array(raw_data_y)

target = np.array([8.093607318, 3.365731514])

1

KNN_classifier = KNeighborsClassifier(n_neighbors=6)

1

KNN_classifier.fit(x_train, y_train)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=None, n_neighbors=6, p=2,
                     weights='uniform')

1
2

target = x.reshape(1, -1)
print(target)

[[8.09360732 3.36573151]]

1

KNN_classifier.predict(target)

array([1])

1
2

res = KNN_classifier.predict(target)
res[0]

1

Python 数据可视化分析

介绍

在机器学习领域中，可视化是十分重要的。在开始一项新任务时，通过可视化手段探索数据能更好地帮助人们把握数据的要点。在分析模型表现和模型报告的结果时，可视化能使分析显得更加生动鲜明。有时候，为了理解复杂的模型，我们还可以将高维空间映射为视觉上更直观的二维或三维图形。

总而言之，可视化是一个相对快捷的从数据中挖掘信息的手段。本文将使用 Pandas、Matplotlib、seaborn 等流行的库，带你上手可视化。

知识点

• 单变量可视化的常用方法
• 多变量可视化的常用方法
• t-SNE

数据集

首先使用 import 载入相关依赖。

1
2
3
4

import numpy as np
import pandas as pd
import seaborn as sns
sns.set()

在第一篇文章中，我们使用的是某电信运营商的客户离网数据集，本次实验仍旧使用这个数据集。

1

df = pd.read_csv('./data/telecom_churn.csv')

1

df.head()

最后一个数据列 Churn 离网率 是我们的目标特征，它是布尔变量，其中 True 表示公司最终丢失了此客户，False 表示客户被保留。稍后，将构建基于其他特征预测 Churn 特征的模型。

单变量可视化

单变量（univariate）分析一次只关注一个变量。当我们独立地分析一个特征时，通常最关心的是该特征值的分布情况。下面考虑不同统计类型的变量，以及相应的可视化工具。

数量特征

数量特征（quantitative feature）的值为有序数值。这些值可能是离散的，例如整数，也可能是连续的，例如实数。

直方图和密度图

直方图依照相等的间隔将值分组为柱，它的形状可能包含了数据分布的一些信息，如高斯分布、指数分布等。当分布总体呈现规律性，但有个别异常值时，你可以通过直方图辨认出来。当你使用的机器学习方法预设了某一特定分布类型（通常是高斯分布）时，知道特征值的分布是非常重要的。

最简单的查看数值变量分布的方法是使用 DataFrame 的 hist() 方法绘制直方图。

1
2

features = ['Total day minutes', 'Total intl calls']
df[features].hist(figsize = (10, 4))

array([[<matplotlib.axes._subplots.AxesSubplot object at 0x12e3076d0>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x12f4cbe90>]],
      dtype=object)

上图表明，变量 Total day minutes 每日通话时长 呈高斯分布，而 Total intl calls 总国际呼叫数 显著右倾（它右侧的尾巴更长）。

密度图（density plots），也叫核密度图（ kernel density estimate，KDE）是理解数值变量分布的另一个方法。它可以看成是直方图平滑（ smoothed ）的版本。相比直方图，它的主要优势是不依赖于柱的尺寸，更加清晰。

让我们为上面两个变量创建密度图。

1
2

df[features].plot(kind='density', subplots=True, layout=(1,2),
                 sharex=False, figsize=(10, 4), legend=False, title=features)

array([[<matplotlib.axes._subplots.AxesSubplot object at 0x133bcc050>,
        <matplotlib.axes._subplots.AxesSubplot object at 0x1343f1ad0>]],
      dtype=object)

1

sns.distplot(df['Total day calls'])

<matplotlib.axes._subplots.AxesSubplot at 0x12e4f8810>

当然，还可以使用 seaborn 的 distplot() 方法观测数值变量的分布。例如，Total day minutes 每日通话时长 的分布。默认情况下，该方法将同时显示直方图和密度图。

1

sns.distplot(df['Total intl calls'])

<matplotlib.axes._subplots.AxesSubplot at 0x12e5134d0>

上图中直方图的柱形高度已进行归一化处理，表示的是密度而不是样本数。

箱型图

箱形图的主要组成部分是箱子（box），须（whisker）和一些单独的数据点（离群值），分别简单介绍如下：

• 箱子显示了分布的四分位距，它的长度由 $25th , （\text{Q1，下四分位数}）$ 和 $75th , （\text{Q3，上四分位数}）$ 决定，箱中的水平线表示中位数 （$50%$）。
• 须是从箱子处延伸出来的线，它们表示数据点的总体散布，具体而言，是位于区间 $（\text{Q1} - 1.5 \cdot \text{IQR}, \text{Q3} + 1.5 \cdot \text{IQR}）$的数据点，其中 $\text{IQR} = \text{Q3} - \text{Q1}$，也就是四分位距。
• 离群值是须之外的数据点，它们作为单独的数据点，沿着中轴绘制。

使用 seaborn 的 boxplot() 方法绘制箱形图。

1

sns.boxplot(df['Total intl calls'])

<matplotlib.axes._subplots.AxesSubplot at 0x12e6e1750>

上图表明，在该数据集中，大量的国际呼叫是相当少见的。

提琴形图

我们最后考虑的分布图形是提琴形图（violin plot）。提琴形图和箱形图的区别是，提琴形图聚焦于平滑后的整体分布，而箱形图显示了单独样本的特定统计数据。

使用 violinplot() 方法绘制提琴形图。下图左侧是箱形图，右侧是提琴形图。

1
2
3
4
5
6

import matplotlib.pyplot as plt

_, ax = plt.subplots(1, 2, sharey=True, figsize=(10, 4))

sns.boxplot(df['Total intl calls'], ax=ax[0])
sns.violinplot(df['Total intl calls'], ax=ax[1])

<matplotlib.axes._subplots.AxesSubplot at 0x1380219d0>

数据描述

除图形工具外，还可以使用 DataFrame 的 describe() 方法来获取分布的精确数值统计。

1

df[features].describe()

describe() 的输出基本上是自解释性的，25%，50% 和 75% 是相应的百分数 percentiles。

类别特征和二元特征

类别特征（categorical features take）反映了样本的某个定性属性，它具有固定数目的值，每个值将一个观测数据分配到相应的组，这些组称为类别（category）。如果类别变量的值具有顺序，称为有序（ordinal）类别变量。

二元（binary）特征是类别特征的特例，其可能值有 2 个。

频率表

让我们查看一下目标变量 Churn 离网率 的分布情况。首先，使用 value_counts() 方法得到一张频率表。

1

df['Churn'].value_counts()

False    2850
True      483
Name: Churn, dtype: int64

上表显示，该数据集的 Churn 有 2850 个属于 False（Churn==0），有 483 个属于 True（Churn==1），数据集中忠实客户（Churn==0）和不忠实客户（Churn==1）的比例并不相等。我们将在以后的文章中看到，这种数据不平衡的情况会导致建立的分类模型存在一定的问题。在这种情况下，构建分类模型可能需要加重对「少数数据（在这里是 Churn==1）分类错误」这一情况的惩罚。

条形图

频率表的图形化表示是条形图。创建条形图最简单的方法是使用 seaborn 的 countplot() 函数。让我们来画出两个分类变量的分布。

1
2
3
4

fig, ax = plt.subplots(1, 2, figsize=[10, 4])

sns.countplot(df['Churn'], ax=ax[0])
sns.countplot(df['Customer service calls'], ax=ax[1])

<matplotlib.axes._subplots.AxesSubplot at 0x1382242d0>

条形图和直方图的区别如下：

• 直方图适合查看数值变量的分布，而条形图用于查看类别特征。
• 直方图的 X 轴是数值；条形图的 X 轴可能是任何类型，如数字、字符串、布尔值。
• 直方图的 X 轴是一个笛卡尔坐标轴；条形图的顺序则没有事先定义。

上左图清晰地表明了目标变量的失衡性。上右图则表明大部分客户最多打了 2-3 个客服电话就解决了他们的问题。不过，既然想要预测少数数据的分类（Churn==1），我们可能对少数不满意的客户的表现更感兴趣。所以让我们尝试一下更有趣的可视化方法：多变量可视化，看能否对预测有所帮助。

多变量可视化

多变量（multivariate）图形可以在单张图像中查看两个以上变量的联系，和单变量图形一样，可视化的类型取决于将要分析的变量的类型。

先来看看数量变量之间的相互作用。

相关矩阵

相关矩阵可揭示数据集中的数值变量的相关性。这一信息很重要，因为有一些机器学习算法（比如，线性回归和逻辑回归）不能很好地处理高度相关的输入变量。

首先，我们使用 DataFrame 的 corr() 方法计算出每对特征间的相关性。接着，我们将所得的相关矩阵（correlation matrix）传给 seaborn 的 heatmap()方法，该方法根据提供的数值，渲染出一个基于色彩编码的矩阵。

1
2
3
4

numerical = list(set(df.columns) - set(['State', 'International plan', 'Voice mail plan', 'Area code', 'Churn', 'Customer service calls']))

corr = df[numerical].corr()
sns.heatmap(corr)

<matplotlib.axes._subplots.AxesSubplot at 0x1388bad50>

上图中，Total day charge 日话费总额 是直接基于 Total day minutes 电话的分钟数 计算得到，它被称为因变量。除了 Total day charege 外，还有 3 个因变量：Total eve charge，Total night charge，Total intl charge。这 4 个因变量并不贡献任何额外信息，我们直接去除。

1
2
3
4

numerical = list(set(numerical) - set(['Total day charge', 'Total eve charge', 'Total night charge', 'Total intl charge']))

corr = df[numerical].corr()
sns.heatmap(corr)

<matplotlib.axes._subplots.AxesSubplot at 0x1396822d0>

散点图

散点图（scatter plot）将两个数值变量的值显示为二维空间中的笛卡尔坐标（Cartesian coordinate）。通过 matplotlib 库的 scatter() 方法可以绘制散点图。

1

plt.scatter(df['Total day minutes'], df['Total night minutes'])

<matplotlib.collections.PathCollection at 0x139a17c10>

我们得到了两个正态分布变量的散点图，看起来这两个变量并不相关，因为上图的形状和轴是对齐的。

seaborn 库的 jointplot() 方法在绘制散点图的同时会绘制两张直方图，某些情形下它们可能会更有用。

1

sns.jointplot(df['Total day minutes'], df['Total night minutes'])

<seaborn.axisgrid.JointGrid at 0x139888cd0>

jointplot() 方法还可以绘制平滑过的散点直方图。

1

sns.jointplot(df['Total day minutes'], df['Total night minutes'], kind='kde', color='g')

<seaborn.axisgrid.JointGrid at 0x139dc1890>

上图基本上就是之前讨论过的核密度图的双变量版本。

散点图矩阵

在某些情形下，我们可能想要绘制如下所示的散点图矩阵（scatterplot matrix）。它的对角线包含变量的分布，并且每对变量的散点图填充了矩阵的其余部分。

1
2

# %config InlineBackend.figure_format = 'png'
sns.pairplot(df[numerical])

<seaborn.axisgrid.PairGrid at 0x139cb5810>

数量和类别

为了让图形更有趣一点，可以尝试从数值和类别特征的相互作用中得到预测 Churn 的新信息，更具体地，让我们看看输入变量和目标变量 Churn 的关系。使用 lmplot() 方法的 hue 参数来指定感兴趣的类别特征。

1

sns.lmplot('Total day minutes', 'Total night minutes', data=df, hue='Churn', fit_reg=False)

<seaborn.axisgrid.FacetGrid at 0x13e7df950>

看起来不忠实客户偏向右上角，也就是倾向于在白天和夜间打更多电话的客户。当然，这不是非常明显，我们也不会基于这一图形下任何确定性的结论。

现在，创建箱形图，以可视化忠实客户（Churn=0）和离网客户（Churn=1）这两个互斥分组中数值变量分布的统计数据。

1
2
3
4
5
6
7
8
9

numerical.append('Customer service calls')
print(numerical)
fig, axes = plt.subplots(3, 4, figsize=[10, 7])
for index, feat in enumerate(numerical):
    ax = axes[int(index / 4), index % 4]
    sns.boxplot(df['Churn'], df[feat], ax=ax)
    ax.set_xlabel('')
    ax.set_ylabel(feat)
fig.tight_layout()

['Total day minutes', 'Total night minutes', 'Number vmail messages', 'Total eve calls', 'Account length', 'Total intl calls', 'Total eve minutes', 'Total night calls', 'Total day calls', 'Total intl minutes', 'Customer service calls', 'Customer service calls', 'Customer service calls', 'Customer service calls', 'Customer service calls', 'Customer service calls', 'Customer service calls', 'Customer service calls']



---------------------------------------------------------------------------

IndexError                                Traceback (most recent call last)

<ipython-input-47-539701aff8ff> in <module>
      3 fig, axes = plt.subplots(3, 4, figsize=[10, 7])
      4 for index, feat in enumerate(numerical):
----> 5     ax = axes[int(index / 4), index % 4]
      6     sns.boxplot(df['Churn'], df[feat], ax=ax)
      7     ax.set_xlabel('')


IndexError: index 3 is out of bounds for axis 0 with size 3

上面的图表表明，两组之间分歧最大的分布是这三个变量：Total day minutes 日通话分钟数、Customer service calls 客服呼叫数、Number vmail messages 语音邮件数。在后续的课程中，我们将学习如何使用随机森林（Random Forest）或梯度提升（Gradient Boosting）来判定特征对分类的重要性，届时可以清晰地看到，前两个特征对于离网预测模型而言确实非常重要。

创建箱型图和提琴形图，查看忠实客户和不忠实客户的日通话分钟数。

1
2
3
4
5

_, axes = plt.subplots(2, 2, sharex=True, sharey=True, figsize=[10, 8])
sns.boxplot(x='Churn', y='Total day minutes', data=df, ax=axes[0][0])
sns.violinplot(x='Churn', y="Total day minutes", data=df, ax=axes[0][1])
sns.boxplot(x='Churn', y='Total night minutes', data=df, ax=axes[1][0])
sns.violinplot(x='Churn', y="Total night minutes", data=df, ax=axes[1][1])

<matplotlib.axes._subplots.AxesSubplot at 0x140f70290>

上图表明，不忠实客户倾向于打更多的电话。

我们还可以发现一个有趣的信息：平均而言，离网客户是通讯服务更活跃的用户。或许是他们对话费不满意，所以预防离网的一个可能措施是降低通话费。当然，公司需要进行额外的经济分析，以查明这样做是否真的有利。

当想要一次性分析两个类别维度下的数量变量时，可以用 seaborn 库的 catplot() 函数。例如，在同一图形中可视化 Total day minutes 日通话分钟数 和两个类别变量（Churn 和 Customer service calls）的相互作用。

1
2

sns.catplot(x='Churn', y='Total day minutes', col='Customer service calls',
          data=df[df['Customer service calls'] < 8], kind='box', col_wrap=4, height=3, aspect=.8)

<seaborn.axisgrid.FacetGrid at 0x140728250>

上图表明，从第 4 次客服呼叫开始，Total day minutes 日通话分钟数 可能不再是客户离网（Churn==1）的主要因素。也许，除了我们之前猜测的话费原因，还有其他问题导致客户对服务不满意，这可能会导致日通话分钟数更少。

类别与类别

正如之前提到的，变量 Customer service calls 客服呼叫数 的重复值很多，因此，既可以看成数值变量，也可以看成有序类别变量。之前已通过计数图（count plot）查看过它的分布了，现在我们感兴趣的是这一有序特征和目标变量 Churn 离网率 之间的关系。

使用 countplot() 方法查看客服呼叫数的分布，这次传入 hue=Churn 参数，以便在图形中加入类别维度。

1

sns.countplot(x='Customer service calls', hue='Churn', data=df[df["Customer service calls"] < 10])

<matplotlib.axes._subplots.AxesSubplot at 0x140cb7990>

上图表明，呼叫客服达到 4 次以上后，离网率显著增加了。

使用 countplot() 方法查看 Churn 离网率 和二元特征 International plan 国际套餐、Voice mail plan 语音邮件套餐 的关系。

1
2
3
4

_, axes = plt.subplots(1, 2, sharey=True, figsize=(10, 4))

sns.countplot(x='International plan', hue='Churn', data=df, ax=axes[0])
sns.countplot(x='Voice mail plan', hue='Churn', data=df, ax=axes[1])

<matplotlib.axes._subplots.AxesSubplot at 0x142344290>

上图表明，开通国际套餐后，离网率会高很多，即 International plan 是否开通国际套餐 是一个重要的特征。我们在 Vocie mail plan 语音邮件套餐 特征上没有观察到类似的效果。

交叉表

除了使用图形进行类别分析之外，还可以使用统计学的传统工具：交叉表（cross tabulation），即使用表格形式表示多个类别变量的频率分布。通过它可以查看某一列或某一行以了解某个变量在另一变量的作用下的分布情况。

通过交叉表查看 Churn 离网率 和类别变量 State 州 的关系。

1

pd.crosstab(df['State'], df['Churn']).T

上表显示，State 州 有 51 个不同的值，并且每个州只有 3 到 17 个客户抛弃了运营商。通过 groupby() 方法计算每个州的离网率，由高到低排列。

1

df.groupby(['State'])['Churn'].agg([np.mean]).sort_values(by='mean', ascending=False).T

上表显示，新泽西和加利福尼亚的离网率超过了 25%，夏威夷和阿拉斯加的离网率则不到 6%。然而，这些结论是基于极少的样本得出的，可能仅适用于这一特定数据集，不太具有泛用性。

全局数据集可视化

上面我们一直在研究数据集的不同方面（facet），通过猜测有趣的特征并一次选择少量特征进行可视化。如果我们想一次性显示所有特征并仍然能够解释生成的可视化，该怎么办？

降维

大多数现实世界的数据集有很多特征，每一个特征都可以被看成数据空间的一个维度。因此，我们经常需要处理高维数据集，然而可视化整个高维数据集相当难。为了从整体上查看一个数据集，需要在不损失很多数据信息的前提下，降低用于可视化的维度。这一任务被称为降维（dimensionality reduction）。降维是一个无监督学习（unsupervised learning）问题，因为它需要在不借助任何监督输入（如标签）的前提下，从数据自身得到新的低维特征。

主成分分析（Principal Component Analysis, PCA）是一个著名的降维方法，我们会在之后的课程中讨论它。但主成分分析的局限性在于，它是线性（linear）算法，这意味着对数据有某些特定的限制。

与线性方法相对的，有许多非线性方法，统称流形学习（Manifold Learning）。著名的流形学习方法之一是 t-SNE。

实验总结

本章节首先介绍了 Pandas、Matplotlib 和 seaborn 库的一些常用可视化方法，并对客户离网数据集进行了可视化分析和 t-SNE 降维。可视化是一个相对快捷的从数据中挖掘信息的手段，因此，学习这一技术并将其纳入你的日常机器学习工具箱，是很有必要的。

使用 Pandas 进行数据探索

本次实验通过分析电信运营商的客户离网率数据集来熟悉 Pandas 数据探索的常用方法，并构建一个预测客户离网率的简单模型。

Pandas 的主要方法

Pandas 是基于 NumPy 的一种工具，提供了大量数据探索的方法。Pandas 可以使用类似 SQL 的方式对 .csv、.tsv、.xlsx 等格式的数据进行处理分析。

Pandas 主要使用的数据结构是 Series 和 DataFrame 类。下面简要介绍下这两类：

• Series 是一种类似于一维数组的对象，它由一组数据（各种 NumPy 数据类型）及一组与之相关的数据标签（即索引）组成。
• DataFrame 是一个二维数据结构，即一张表格，其中每列数据的类型相同。你可以把它看成由 Series 实例构成的字典。

下面开始此次实验，我们将通过分析电信运营商的客户离网率数据集来展示 Pandas 的主要方法。

首先载入必要的库，即 NumPy 和 Pandas。

教学代码：

1
2

import numpy as np
import pandas as pd

通过 read_csv() 方法读取数据，然后使用 head() 方法查看前 5 行数据。

1

dataFrame = pd.read_csv('./data/telecom_churn.csv')

上图中的每行对应一位客户，每列对应客户的一个特征。

让我们查看一下该数据库的维度、特征名称和特征类型。

1

dataFrame.shape

(3333, 20)

上述结果表明，我们的列表包含 3333 行和 20 列。下面我们尝试打印列名。

1

dataFrame.columns

Index(['State', 'Account length', 'Area code', 'International plan',
       'Voice mail plan', 'Number vmail messages', 'Total day minutes',
       'Total day calls', 'Total day charge', 'Total eve minutes',
       'Total eve calls', 'Total eve charge', 'Total night minutes',
       'Total night calls', 'Total night charge', 'Total intl minutes',
       'Total intl calls', 'Total intl charge', 'Customer service calls',
       'Churn'],
      dtype='object')

我们还可以使用 info() 方法输出 DataFrame 的一些总体信息。

1

dataFrame.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 3333 entries, 0 to 3332
Data columns (total 20 columns):
State                     3333 non-null object
Account length            3333 non-null int64
Area code                 3333 non-null int64
International plan        3333 non-null object
Voice mail plan           3333 non-null object
Number vmail messages     3333 non-null int64
Total day minutes         3333 non-null float64
Total day calls           3333 non-null int64
Total day charge          3333 non-null float64
Total eve minutes         3333 non-null float64
Total eve calls           3333 non-null int64
Total eve charge          3333 non-null float64
Total night minutes       3333 non-null float64
Total night calls         3333 non-null int64
Total night charge        3333 non-null float64
Total intl minutes        3333 non-null float64
Total intl calls          3333 non-null int64
Total intl charge         3333 non-null float64
Customer service calls    3333 non-null int64
Churn                     3333 non-null bool
dtypes: bool(1), float64(8), int64(8), object(3)
memory usage: 498.1+ KB

bool、int64、float64 和 object 是该数据库特征的数据类型。这一方法同时也会显示是否有缺失值，上述结果表明在该数据集中不存在缺失值，因为每列都包含 3333 个观测，和我们之前使用 shape 方法得到的数字是一致的。

astype() 方法可以更改列的类型，下列公式将 Churn 离网率 特征修改为 int64 类型。

1
2
3
4

df = dataFrame
df.head(5)
df['Churn'] = df['Churn'].astype('int64')
df.head(5)

describe() 方法可以显示数值特征（int64 和 float64）的基本统计学特性，如未缺失值的数值、均值、标准差、范围、四分位数等。

1

df.describe()

通过 include 参数显式指定包含的数据类型，可以查看非数值特征的统计数据。

1

df.describe(include=['object', 'bool'])

value_counts() 方法可以查看类别（类型为 object ）和布尔值（类型为 bool ）特征。让我们看下 Churn 离网率 的分布。

1

df['Churn'].value_counts()

0    2850
1     483
Name: Churn, dtype: int64

上述结果表明，在 3333 位客户中， 2850 位是忠实客户，他们的 Churn 值为 0。调用 value_counts() 函数时，加上 normalize=True 参数可以显示比例。

1

df['Churn'].value_counts(normalize=True)

0    0.855086
1    0.144914
Name: Churn, dtype: float64

排序

DataFrame 可以根据某个变量的值（也就是列）排序。比如，根据每日消费额排序（设置 ascending=False 倒序排列）。

1

df.sort_values(by='Total day charge', ascending=False).head(5)