归档

1. Pandas基础篇

Python有了NumPy的Pandas，用Python处理数据就像使用Exel或SQL一样简单方便。
Pandas是基于NumPy的Python 库，它被广泛用于快速分析数据，以及数据清洗和准备等工作。可以把 Pandas 看作是 Python版的Excel或Table。Pandas 有两种数据结构：
Series和DataFrame，Pandas经过几个版本的更新，目前已经成为数据清洗、处理和分析的不二选择。

1.1 问题：Pandas有哪些优势？

科学计算方面NumPy是优势，但NumPy中没有标签，数据清理、数据处理就不是其强项了。而DataFrame有标签，就像SQL中的表一样，所以在数据处理方面DataFrame就更胜一筹了，具体包含以下几方面：
（1）读取数据方面
Pandas提供强大的IO读取工具，csv格式、Excel文件、数据库等都可以非常简便地读取，对于大数据，pandas也支持大文件的分块读取。
（2）在数据清洗方面
面对数据集，我们遇到最多的情况就是存在缺失值，Pandas把各种类型数据类型的缺失值统一称为NaN,Pandas提供许多方便快捷的方法来处理这些缺失值NaN。
（3）分析建模阶段
在分析建模阶段，Pandas自动且明确的数据对齐特性，非常方便地使新的对象可以正确地与一组标签对齐，由此，Pandas就可以非常方便地将数据集进行拆分-重组操作。
（4）结果可视化方面
结果展示方面，我们都知道Matplotlib是个数据视图化的好工具，Pandas与Matplotlib搭配，不用复杂的代码，就可以生成多种多样的数据视图。

1.2 Pandas数据结构

Pandas中两个最常用的对象是Series和DataFrame。使用pandas前，需导入以下内容：

import numpy as np
from pandas import Series,DataFrame
import pandas as pd

import numpy as np

from pandas import Series,DataFrame

import pandas as pd

Pandas主要采用Series和DataFrame两种数据结构。Series是一种类似一维数据的数据结构，由数据(values)及索引(indexs)组成，而DataFrame是一个表格型的数据结构，它有一组序列，每列的数据可以为不同类型（NumPy数据组中数据要求为相同类型）,它既有行索引，也有列索引。

a1=np.array([1,2,3,4])
a2=np.array([5,6,7,8])
a3=np.array(['a','b','c','d'])
df=pd.DataFrame({'a':a1,'b':a2,'c':a3})
df

a1=np.array([1,2,3,4])

a2=np.array([5,6,7,8])

a3=np.array(['a','b','c','d'])

df=pd.DataFrame({'a':a1,'b':a2,'c':a3})

图1-1 DataFrame结构

1.3 Series

上章节我们介绍了多维数组（ndarray），当然，它也包括一维数组，Series类似一维数组，为啥还要介绍Series呢？或Series有哪些特点？
Series一个最大特点就是可以使用标签索引，序列及ndarray也有索引，但都是位置索引或整数索引，这种索引有很多局限性，如根据某个有意义标签找对应值，切片时采用类似[2:3]的方法，只能取索引为2这个元素等等，无法精确定位。
Series的标签索引（它位置索引自然保留）使用起来就方便多了，且定位也更精确，不会产生歧义。以下通过实例来说明。
（1）使用Series

import numpy as np
from pandas import Series,DataFrame
import pandas as pd

s1=Series([1,3,6,-1,2,8])

s1

import numpy as np

from pandas import Series,DataFrame

import pandas as pd

s1=Series([1,3,6,-1,2,8])

0 1
1 3
2 6
3 -1
4 2
5 8
dtype: int64
（2）使用Series的索引

s1.values       #显示s1的所有值
s1.index        #显示s1的索引（位置索引或标签索引）
s2=Series([1,3,6,-1,2,8],index=['a','c','d','e','b','g'])  #定义标签索引
s2

s1.values #显示s1的所有值

s1.index #显示s1的索引（位置索引或标签索引）

s2=Series([1,3,6,-1,2,8],index=['a','c','d','e','b','g']) #定义标签索引

a 1
c 3
d 6
e -1
b 2
g 8
dtype: int64
（3）根据索引找对应值

s2[['a','e']]	###根据标签索引找对应值
#当然，Series除了标签索引外，还有其它很多优点，如运算的简洁：
s2[s2>1]
s2*10

s2[['a','e']] ###根据标签索引找对应值

#当然，Series除了标签索引外，还有其它很多优点，如运算的简洁：

s2[s2>1]

s2*10

1.4 DataFrame

DataFrame除了索引有位置索引也有标签索引，而且其数据组织方式与MySQL的表极为相似，除了形式相似，很多操作也类似，这就给操作DataFrame带来极大方便。这些是DataFrame特色的一小部分，它还有比数据库表更强大的功能，如强大统计、可视化等等。
DataFrame有几个要素：index、columns、values等，columns就像数据库表的列表，index是索引，values就是值。

####自动生成一个3行4列的DataFrame，并定义其索引（如果不指定，缺省为整数索引）####及列名
d1=DataFrame(np.arange(12).reshape((3,4)),columns=['a1','a2','a3','a4'], index=['a','b','c'])
d1

####自动生成一个3行4列的DataFrame，并定义其索引（如果不指定，缺省为整数索引）####及列名

d1=DataFrame(np.arange(12).reshape((3,4)),columns=['a1','a2','a3','a4'], index=['a','b','c'])

图1-2 DataFrame结果

d1.index     #显示索引(有标签索引则显示标签索引，否则显示位置索引)
d1.columns   ##显示列名
d1.values    ##显示值

d1.index #显示索引(有标签索引则显示标签索引，否则显示位置索引)

d1.columns ##显示列名

d1.values ##显示值

1.4.1 生成DataFrame

生成DataFrame有很多，比较常用的有导入等长列表、字典、numpy数组、数据文件等。

data={'name':['zhanghua','liuting','gaofei','hedong'],'age':[40,45,50,46],'addr':['jianxi','pudong','beijing','xian']}

d2=DataFrame(data)
#改变列的次序
d3=DataFrame(data,columns=['name','age','addr'],index=['a','b','c','d'])
d3

data={'name':['zhanghua','liuting','gaofei','hedong'],'age':[40,45,50,46],'addr':['jianxi','pudong','beijing','xian']}

d2=DataFrame(data)

#改变列的次序

d3=DataFrame(data,columns=['name','age','addr'],index=['a','b','c','d'])

1.4.2 获取数据

获取DataFrame结构中数据可以采用obj[]操作、obj.iloc[]、obj.loc[]等命令。
（1）使用obj[]来获取列或行

d3[['name']]              #选取某一列
d3[['name','age']]	##选择多列
d3['a':'c']	         ##选择行
d3[1:3]		         ##选择行（利用位置索引）

d3[d3['age']>40]		###使用过滤条件

d3[['name']] #选取某一列

d3[['name','age']] ##选择多列

d3['a':'c'] ##选择行

d3[1:3] ##选择行（利用位置索引）

d3[d3['age']>40] ###使用过滤条件

（2）使用obj.loc[] 或obj.iloc[]获取行或列数据。
loc通过行标签获取行数据，iloc通过行号获取行数据。
loc 在index的标签上进行索引,范围包括start和end.
iloc 在index的位置上进行索引,不包括end.
这两者的主要区别可参考如下示例：

import pandas as pd    
data = [[1,2,3],[4,5,6],[7,8,9]]   
index = ['a','b','c']    
columns=['c1','c2','c3']    
df = pd.DataFrame(data=data, index=index, columns=columns)
###########loc的使用############
df.loc[['a','b']]              #通过行标签获取行数据
df.loc[['a'],['c1','c3']]      #通过行标签、列名称获取行列数据
df.loc[['a','b'],['c1','c3']]  #通过行标签、列名称获取行列数据

#########iloc的使用###############
df.iloc[1]                     #通过行号获取行数据
df.iloc[0:2]                   #通过行号获取行数据，不包括索引2的值
df.iloc[1:,1]                  ##通过行号、列行获取行、列数据
df.iloc[1:,[1,2]]              ##通过行号、列行获取行、列数据
df.iloc[1:,1:3]                ##通过行号、列行获取行、列数据

import pandas as pd

data = [[1,2,3],[4,5,6],[7,8,9]]

index = ['a','b','c']

columns=['c1','c2','c3']

df = pd.DataFrame(data=data, index=index, columns=columns)

###########loc的使用############

df.loc[['a','b']] #通过行标签获取行数据

df.loc[['a'],['c1','c3']] #通过行标签、列名称获取行列数据

df.loc[['a','b'],['c1','c3']] #通过行标签、列名称获取行列数据

#########iloc的使用###############

df.iloc[1] #通过行号获取行数据

df.iloc[0:2] #通过行号获取行数据，不包括索引2的值

df.iloc[1:,1] ##通过行号、列行获取行、列数据

df.iloc[1:,[1,2]] ##通过行号、列行获取行、列数据

df.iloc[1:,1:3] ##通过行号、列行获取行、列数据

【说明】
除使用iloc及loc外，早期版本还有ix格式。pandas0.20.0及以上版本，ix已经丢弃，请尽量使用loc和iloc;

1.4.3 修改数据

我们可以像操作数据库表一样操作DataFrame，删除数据、插入数据、修改字段名、索引名、修改数据等，以下通过一些实例来说明。

data={'name':['zhanghua','liuting','gaofei','hedong'],'age':[40,45,50,46],'addr':['jianxi','pudong','beijing','xian']}
d3=DataFrame(data,columns=['name','age','addr'],index=['a','b','c','d'])
d3

data={'name':['zhanghua','liuting','gaofei','hedong'],'age':[40,45,50,46],'addr':['jianxi','pudong','beijing','xian']}

d3=DataFrame(data,columns=['name','age','addr'],index=['a','b','c','d'])

图1-3 数据结构

d3.drop('d',axis=0)	###删除行，如果欲删除列，使axis=1即可
d3  ###从副本中删除，原数据没有被删除
d3.drop('addr',axis=1)   ###删除第addr列

###添加一行，注意需要ignore_index=True，否则会报错
d3.append({'name':'wangkuan','age':38,'addr':'henan'},ignore_index=True)
d3  ###原数据未变

###添加一行，并创建一个新DataFrame
d4=d3.append({'name':'wangkuan','age':38,'addr':'henan'},ignore_index=True)
d4.index=['a','b','c','d','e']	###修改d4的索引
d4.loc['e','age']=39  ###修改索引为e列名为age的值

d3.drop('d',axis=0) ###删除行，如果欲删除列，使axis=1即可

d3 ###从副本中删除，原数据没有被删除

d3.drop('addr',axis=1) ###删除第addr列

###添加一行，注意需要ignore_index=True，否则会报错

d3.append({'name':'wangkuan','age':38,'addr':'henan'},ignore_index=True)

d3 ###原数据未变

###添加一行，并创建一个新DataFrame

d4=d3.append({'name':'wangkuan','age':38,'addr':'henan'},ignore_index=True)

d4.index=['a','b','c','d','e'] ###修改d4的索引

d4.loc['e','age']=39 ###修改索引为e列名为age的值

1.4.4 汇总统计

Pandas有一组常用的统计方法，可以根据不同轴方向进行统计，当然也可按不同的列或行进行统计，非常方便。
常用的统计方法有：
表1-1 Pandas统计方法

以下通过实例来说明这些方法的使用
（1）把csv数据导入pandas

from pandas import DataFrame                  
import numpy as np                            
import pandas as pd                           
inputfile = r'C:\Users\lenovo\data\stud_score.csv'
data = pd.read_csv(inputfile,encoding='gbk') 
#其他参数，
###header=None 表示无标题,此时缺省列名为整数；如果设为0，表示第0行为标题
###names，encoding，skiprows等
#读取excel文件，可用 read_excel
df=DataFrame(data)
df.head(3) ###显示前3行

from pandas import DataFrame

import numpy as np

import pandas as pd

inputfile = r'C:\Users\lenovo\data\stud_score.csv'

data = pd.read_csv(inputfile,encoding='gbk')

#其他参数，

###header=None 表示无标题,此时缺省列名为整数；如果设为0，表示第0行为标题

###names，encoding，skiprows等

#读取excel文件，可用 read_excel

df=DataFrame(data)

df.head(3) ###显示前3行

（2）查看df的统计信息

df.count()  #统计非NaN行数

df['sub_score'].describe()	##汇总学生各科成绩
df['sub_score'].std()	##求学生成绩的标准差
df['sub_score'].var()     ##求学生成绩的方差

df.count() #统计非NaN行数

df['sub_score'].describe() ##汇总学生各科成绩

df['sub_score'].std() ##求学生成绩的标准差

df['sub_score'].var() ##求学生成绩的方差

【说明】

即各项-均值的平方求和后再除以N 。
std：表示标准差，是var的平方根。

1.4.5选择部分列

这里选择学生代码、课程代码、课程名称、程程成绩，注册日期等字段

#根据列的索引来选择
df.iloc[:,[0,1,2,4,5]]    
#或根据列名称来选择
df1=df.loc[:,['stud_code','sub_code','sub_name','sub_score','stat_date']]

#根据列的索引来选择

df.iloc[:,[0,1,2,4,5]]

#或根据列名称来选择

df1=df.loc[:,['stud_code','sub_code','sub_name','sub_score','stat_date']]

1.4.6删除重复数据

如果有重复数据（对df1的所有列），则删除最后一条记录。

df1.drop_duplicates(keep='last')

1	df1.drop_duplicates(keep='last')

1.4.7补充缺省值

（1）用指定值补充NaN值
这里要求把stat_date的缺省值（NaN）改为'2018-09-01'

df2=df1.fillna({'stat_date':'2018-11-05'})
df2.head(3)

1 2	df2=df1.fillna({'stat_date':'2018-11-05'}) df2.head(3)

（2）可视化，并在图形上标准数据

df21=df2.loc[:,['sub_name','sub_score']].head(5)
df22=pd.pivot_table(df21, index='sub_name', values='sub_score')
df22

df21=df2.loc[:,['sub_name','sub_score']].head(5)

df22=pd.pivot_table(df21, index='sub_name', values='sub_score')

df22

结果为：

（3）导入一些库及支持中文的库

import pandas as pd
from pandas import DataFrame
import matplotlib.pyplot as plt 
import matplotlib
from matplotlib.font_manager import FontProperties 
font = FontProperties(fname=r"c:\windows\fonts\simkai.ttf", size=14) 
%matplotlib inline

import pandas as pd

from pandas import DataFrame

import matplotlib.pyplot as plt

import matplotlib

from matplotlib.font_manager import FontProperties

font = FontProperties(fname=r"c:\windows\fonts\simkai.ttf", size=14)

%matplotlib inline

（4）画图

plt.figure(figsize=(10,6))
#设置x轴柱子的个数
x=np.arange(5)+1
#设置y轴的数值，需将numbers列的数据先转化为数列，再转化为矩阵格式
y=np.array(list(df22['sub_score']))
xticks1=list(df22.index) #构造不同课程类目的数列
#画出柱状图
plt.bar(x,y,width = 0.35,align='center',color = 'b',alpha=0.8)
#设置x轴的刻度，将构建的xticks代入，同时由于课程类目文字较多，在一块会比较拥挤和重叠，因此设置字体和对齐方式
plt.xticks(x,xticks1,size='small',fontproperties=font)
#x、y轴标签与图形标题
plt.xlabel('课程主题类别',fontproperties=font)
plt.ylabel('sub_score')
plt.title('不同课程的成绩',fontproperties=font)
#设置数字标签
for a,b in zip(x,y):
    plt.text(a, b+0.05, '%.0f' % b, ha='center', va= 'bottom',fontsize=14)
#设置y轴的范围
plt.ylim(0,100)
plt.show()

plt.figure(figsize=(10,6))

#设置x轴柱子的个数

x=np.arange(5)+1

#设置y轴的数值，需将numbers列的数据先转化为数列，再转化为矩阵格式

y=np.array(list(df22['sub_score']))

xticks1=list(df22.index) #构造不同课程类目的数列

#画出柱状图

plt.bar(x,y,width = 0.35,align='center',color = 'b',alpha=0.8)

#设置x轴的刻度，将构建的xticks代入，同时由于课程类目文字较多，在一块会比较拥挤和重叠，因此设置字体和对齐方式

plt.xticks(x,xticks1,size='small',fontproperties=font)

#x、y轴标签与图形标题

plt.xlabel('课程主题类别',fontproperties=font)

plt.ylabel('sub_score')

plt.title('不同课程的成绩',fontproperties=font)

#设置数字标签

for a,b in zip(x,y):

plt.text(a, b+0.05, '%.0f' % b, ha='center', va= 'bottom',fontsize=14)

#设置y轴的范围

plt.ylim(0,100)

plt.show()

运行结果

图1-4 可视化结果

1.4.8 Pandas操作MySQL数据库

（1）从MySQL数据库中获取学生基本信息表

import numpy as np
import pandas as pd
from pandas import DataFrame
import pymysql

conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='feigu', db='feigudb', charset='gbk')
#学生代码直接从数据库读取为字符型，而df2中学生代码为整数型，故需要进行类型转换
df_info= pd.read_sql('select cast(stud_code as signed) as stud_code,stud_name from stud_info', conn)

import numpy as np

import pandas as pd

from pandas import DataFrame

import pymysql

conn = pymysql.connect(host='localhost', port=3306, user='root', passwd='feigu', db='feigudb', charset='gbk')

#学生代码直接从数据库读取为字符型，而df2中学生代码为整数型，故需要进行类型转换

df_info= pd.read_sql('select cast(stud_code as signed) as stud_code,stud_name from stud_info', conn)

（2）查看df_info前3行数据

df_info.head(3)

1	df_info.head(3)

（3）选择前两个字段

df_info1=df_info.iloc[:,[0,1]]

1	df_info1=df_info.iloc[:,[0,1]]

（4）df2 与df_info1 根据字段stud_code 进行内关联

df3=pd.merge(df_info1,df2,on='stud_code',how='inner')
df3.head(3)

1 2	df3=pd.merge(df_info1,df2,on='stud_code',how='inner') df3.head(3)

（5）对df3 根据字段stud_code,sub_code进行分组，并求平均每个同学各科的平均成绩。

df4=df3.groupby(['stud_name','sub_name'],as_index=False).mean()
df4.head(3)

1 2	df4=df3.groupby(['stud_name','sub_name'],as_index=False).mean() df4.head(3)

【备注】
如果需要合计各同学的成绩，可用如下语句。

df3.groupby(['stud_name'],as_index=False).sum().head(3)

1	df3.groupby(['stud_name'],as_index=False).sum().head(3)

（6）选择数学分析课程，并根据成绩进行降序。

df4[df4['sub_code'].isin(['10101'])].sort_values(by='sub_score', ascending=False)

1	df4[df4['sub_code'].isin(['10101'])].sort_values(by='sub_score', ascending=False)

（7）取前5名

df_top5=df4[df4['sub_code'].isin(['10101'])].sort_values(by='sub_score', ascending=False).head(5)
df_top5

1 2	df_top5=df4[df4['sub_code'].isin(['10101'])].sort_values(by='sub_score', ascending=False).head(5) df_top5

注：DataFrame数据结构的函数或方法有很多，大家可以通过df.[Tab键]方式查看，具体命令的使用方法，如df.count(),可以在Ipython命令行下输入：?df.count() 查看具体使用，退出帮助界面，按q即可。

1.4.9 Pandas操作excel

把DataFrame数据写入excel中的多个sheet中

with pd.ExcelWriter(r'C:\Users\lenovo\test1107.xlsx') as writer:
    df2.to_excel(writer,sheet_name='df2',index=False)   #不保存序列号
    df1.to_excel(writer,sheet_name='学生成绩')          #同时保存序列号
    writer.save()
df2.to_csv("test1107.csv",index=False,sep=',')  #把Pandas数据写人csv文件

with pd.ExcelWriter(r'C:\Users\lenovo\test1107.xlsx') as writer:

df2.to_excel(writer,sheet_name='df2',index=False) #不保存序列号

df1.to_excel(writer,sheet_name='学生成绩') #同时保存序列号

writer.save()

df2.to_csv("test1107.csv",index=False,sep=',') #把Pandas数据写人csv文件

1.4.10 Pandas的三板斧

我们知道数据库中有很多函数可用作用于表中元素，DataFrame也可将函数（内置或自定义）应用到各列或行上，而且非常方便和简洁，具体可用通过DataFrame的apply、applymap和map来实现，其中apply、map对数据集中的每列或每行的逐元操作，applymap对dataframe的每个元素进行操作，这些函数对数据处理的强大工具。以下通过实例说明具体使用。

d1=DataFrame(np.arange(12).reshape((3,4)),index=['a','b','c'],columns=['a1','a2','a3','a4'])
d1

1 2	d1=DataFrame(np.arange(12).reshape((3,4)),index=['a','b','c'],columns=['a1','a2','a3','a4']) d1

d1.apply(lambda x:x.max()-x.min(),axis=0) ###列级处理
d1.applymap(lambda x:x*2)   ###处理每个元素
d1.iloc[1].map(lambda x:x*2)   ###处理每行数据

d1.apply(lambda x:x.max()-x.min(),axis=0) ###列级处理

d1.applymap(lambda x:x*2) ###处理每个元素

d1.iloc[1].map(lambda x:x*2) ###处理每行数据

1.4.11 处理时间序列

pandas最基本的时间序列类型就是以时间戳（时间点）（通常以python字符串或datetime对象表示）为索引的Series：

dates = ['2017-06-20','2017-06-21','2017-06-22','2017-06-23','2017-06-24']
ts = pd.Series(np.random.randn(5),index = pd.to_datetime(dates))
ts

dates = ['2017-06-20','2017-06-21','2017-06-22','2017-06-23','2017-06-24']

ts = pd.Series(np.random.randn(5),index = pd.to_datetime(dates))

索引为日期的DataFrame数据的索引、选取以及子集构造

ts.index
#传入可以被解析成日期的字符串
ts['2017-06-21']
#传入年或年月
ts['2017-06']
#时间范围进行切片
ts['2017-06-20':'2017-06-22']

ts.index

#传入可以被解析成日期的字符串

ts['2017-06-21']

#传入年或年月

ts['2017-06']

#时间范围进行切片

ts['2017-06-20':'2017-06-22']

1.4.12 数据离散化

如何离散化连续性数据？在一般开发语言中，可以通过控制语句来实现，但如果分类较多时，这种方法不但繁琐，效率也比较低。在Pandas中是否有更好方法？如果有，又该如何实现呢？
pandas有现成方法，如cut或qcut等，不需要编写代码，至于如何使用还是通过实例来说明。

import numpy as np
import pandas as pd
from pandas import DataFrame
df9=DataFrame({'age':[21,25,30,32,36,40,45,50],'type':['1','2','1','2','1','1','2','2']},columns=['age','type'])
df9

import numpy as np

import pandas as pd

from pandas import DataFrame

df9=DataFrame({'age':[21,25,30,32,36,40,45,50],'type':['1','2','1','2','1','1','2','2']},columns=['age','type'])

df9

现在需要对age字段进行离散化, 划分为(20,30],(30,40],(40,50].

level=[20,30,40,50]	##划分为(20,30],(30,40],(40,50]
groups=['A','B','C']	##对应标签为A,B,C
df9['age_t']=pd.cut(df9['age'],level,labels=groups)  ##新增字段为age_t
df10=df9[['age','age_t','type']]
df10

level=[20,30,40,50] ##划分为(20,30],(30,40],(40,50]

groups=['A','B','C'] ##对应标签为A,B,C

df9['age_t']=pd.cut(df9['age'],level,labels=groups) ##新增字段为age_t

df10=df9[['age','age_t','type']]

df10

1.4.13 交叉表

我们平常看到的数据格式大多像数据库中的表，如购买图书的基本信息：
表1-2 客户购买图书信息

这样的数据比较规范，比较适合于一般的统计分析。但如果我们想查看客户购买各种书的统计信息，就需要把以上数据转换为如下格式：
表1-3 客户购买图书的对应关系

我们观察一下不难发现，把表1-3中书代码列旋转为行就得到表2数据。如何实现行列的互换呢？编码能实现，但比较麻烦，还好，pandas提供了现成的方法或函数，如stack、unstack、pivot_table函数等。以下以pivot_table为例说明具体实现。

import numpy as np
import pandas as pd
from pandas import DataFrame
df=DataFrame({'书代码':['p211','p211','sp2','sp2','hd28','hd28'],'客户类型':['A','B','A','B','A','C'],'购买量':[1,2,3,2,10,1]},columns=['书代码','客户类型','购买量'])
df

import numpy as np

import pandas as pd

from pandas import DataFrame

df=DataFrame({'书代码':['p211','p211','sp2','sp2','hd28','hd28'],'客户类型':['A','B','A','B','A','C'],'购买量':[1,2,3,2,10,1]},columns=['书代码','客户类型','购买量'])

实现行列互换，把书代码列转换为行或索引

pd.pivot_table(df,values='购买量',index='客户类型',columns='书代码')

1	pd.pivot_table(df,values='购买量',index='客户类型',columns='书代码')

####转换后，出现一些NaN值或空值，我们可以把NaN修改为0
pd.pivot_table(df,values='购买量',index='客户类型',columns='书代码',fill_value=0)

1 2	####转换后，出现一些NaN值或空值，我们可以把NaN修改为0 pd.pivot_table(df,values='购买量',index='客户类型',columns='书代码',fill_value=0)

第1章 NumPy基础

在机器学习和深度学习中，图像、声音、文本等输入数据最终都要转换为数组或矩阵。如何有效进行数组和矩阵的运算？这就需要充分利用NumPy。NumPy是数据科学的通用语言，而且与Pytorch关系非常密切，它是科学计算、深度学习的基石。尤其对Pytorch而言，其重要性更加明显。Pytorch中的Tensor与NumPy非常相似，它们之间可以非常方便地进行转换，掌握NumPy是学好Pytorch的重要基础，故我们把它列为全书第1章。
为什么是NumPy？实际上Python本身含有列表（list）和数组（array），但对于大数据来说，这些结构有很多不足。因列表的元素可以是任何对象，因此列表中所保存的是对象的指针。例如为了保存一个简单的[1,2,3]，都需要有3个指针和三个整数对象。对于数值运算来说这种结构显然比较浪费内存和CPU等宝贵资源。至于array对象，它直接保存数值，和C语言的一维数组比较类似。但是由于它不支持多维，在上面的函数也不多，因此也不适合做数值运算。
NumPy（Numerical Python 的简称）的诞生弥补了这些不足，NumPy提供了两种基本的对象：ndarray（N-dimensional array object）和 ufunc（universal function object）。ndarray是存储单一数据类型的多维数组，而ufunc则是能够对数组进行处理的函数。
NumPy的主要特点：
（1）ndarray，快速和节省空间的多维数组，提供数组化的算术运算和高级的广播功能。
（2）使用标准数学函数对整个数组的数据进行快速运算，而不需要编写循环。
（3）读取/写入磁盘上的阵列数据和操作存储器映像文件的工具。
（4）线性代数，随机数生成，和傅里叶变换的能力。
（5）集成C，C++，Fortran代码的工具。
本章主要内容如下：
 如何生成NumPy数组
 如何存取元素
 NumPy的算术运算
 数组变形
 批量处理
 NumPy的通用函数
 NumPy的广播机制

1.1 生成NumPy数组

NumPy是Python的外部库，不在标准库中。因此，若要使用它，需要先导入NumPy。

import numpy as np

1	import numpy as np

导入NumPy后，可通过np.+Tab键，查看可使用的函数，如果对其中一些函数的使用不很清楚，还可以在对应函数+?，再运行，就可很方便的看到如何使用函数的帮助信息。
np.然后按'Tab'键，将出现如下界面：

运行如下命令，便可查看函数abs的详细帮助信息。

np.abs?

np.abs?

NumPy不但强大，而且还非常友好。
接下来我们将介绍NumPy的一些常用方法，尤其是与机器学习、深度学习相关的一些内容。
NumPy封装了一个新的数据类型ndarray（n-dimensional array），它是一个多维数组对象。该对象封装了许多常用的数学运算函数，方便我们做数据处理、数据分析等。如何生成ndarray呢？这里我们介绍生成ndarray的几种方式，如从已有数据中创建、利用random创建、创建特殊多维数组、使用arange函数等。

1.1.1 从已有数据中创建数组

直接对 Python 的基础数据类型(如列表、元组等) 进行转换来生成 ndarray:
（1）将列表转换成 ndarray

import numpy as np

lst1 = [3.14, 2.17, 0, 1, 2]
nd1 =np.array(lst1)
print(nd1)
# [3.14 2.17 0.   1.   2.  ]
print(type(nd1))
# <class 'numpy.ndarray'>

import numpy as np

lst1 = [3.14, 2.17, 0, 1, 2]

nd1 =np.array(lst1)

print(nd1)

# [3.14 2.17 0. 1. 2. ]

print(type(nd1))

# <class 'numpy.ndarray'>

（2）嵌套列表可以转换成多维 ndarray

import numpy as np

lst2 = [[3.14, 2.17, 0, 1, 2], [1, 2, 3, 4, 5]]
nd2 =np.array(lst2)
print(nd2)
# [[3.14 2.17 0.   1.   2.  ]
#  [1.   2.   3.   4.   5.  ]]
print(type(nd2))
# <class 'numpy.ndarray'>

import numpy as np

lst2 = [[3.14, 2.17, 0, 1, 2], [1, 2, 3, 4, 5]]

nd2 =np.array(lst2)

print(nd2)

# [[3.14 2.17 0. 1. 2. ]

# [1. 2. 3. 4. 5. ]]

print(type(nd2))

# <class 'numpy.ndarray'>

如果把上面示例中的列表换成元组也同样适合。

1.1.2 利用 random 模块生成数组

在深度学习中，我们经常需要对一些参数进行初始化，为了更有效训练模型，提高模型的性能，有些初始化还需要满足一定条件，如满足正态分布或均匀分布等。这里我们介绍几种常用的方法，表1-1列举了 np.random 模块常用的函数。
表1-1 np.random模块常用函数

下面我们来看看一些函数的具体使用:

import numpy as np

nd3 =np.random.random([3, 3])
print(nd3)
# [[0.43007219 0.87135582 0.45327073]
#  [0.7929617  0.06584697 0.82896613]
#  [0.62518386 0.70709239 0.75959122]]
print("nd3的形状为:",nd3.shape)
# nd3的形状为: (3, 3)

import numpy as np

nd3 =np.random.random([3, 3])

print(nd3)

# [[0.43007219 0.87135582 0.45327073]

# [0.7929617 0.06584697 0.82896613]

# [0.62518386 0.70709239 0.75959122]]

print("nd3的形状为:",nd3.shape)

# nd3的形状为: (3, 3)

为了每次生成同一份数据，可以指定一个随机种子，使用shuffle函数打乱生成的随机数。

import numpy as np

np.random.seed(123)
nd4 = np.random.randn(2,3)
print(nd4)
np.random.shuffle(nd4)
print("随机打乱后数据:")
print(nd4)
print(type(nd4))

import numpy as np

np.random.seed(123)

nd4 = np.random.randn(2,3)

print(nd4)

np.random.shuffle(nd4)

print("随机打乱后数据:")

print(nd4)

print(type(nd4))

输出结果:
[[-1.0856306 0.99734545 0.2829785 ]
[-1.50629471 -0.57860025 1.65143654]]
随机打乱后数据:
[[-1.50629471 -0.57860025 1.65143654]
[-1.0856306 0.99734545 0.2829785 ]]

1.1.3 创建特定形状的多维数组

参数初始化时，有时需要生成一些特殊矩阵，如全是 0 或 1 的数组或矩阵，这时我们可以利用np.zeros、np.ones、np.diag来实现，如表1-2所示。
表1-2 NumPy 数组创建函数

下面我们通过几个示例来说明:

import numpy as np

# 生成全是 0 的 3x3 矩阵
nd5 =np.zeros([3, 3])
#生成与nd5形状一样的全0矩阵
#np.zeros_like(nd5)
# 生成全是 1 的 3x3 矩阵
nd6 = np.ones([3, 3])
# 生成 3 阶的单位矩阵
nd7 = np.eye(3)
# 生成 3 阶对角矩阵
nd8 = np.diag([1, 2, 3])

print(nd5)
# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]
print(nd6)
# [[1. 1. 1.]
#  [1. 1. 1.]
#  [1. 1. 1.]]
print(nd7)
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]
print(nd8)
# [[1 0 0]
#  [0 2 0]
#  [0 0 3]]

import numpy as np

# 生成全是 0 的 3x3 矩阵

nd5 =np.zeros([3, 3])

#生成与nd5形状一样的全0矩阵

#np.zeros_like(nd5)

# 生成全是 1 的 3x3 矩阵

nd6 = np.ones([3, 3])

# 生成 3 阶的单位矩阵

nd7 = np.eye(3)

# 生成 3 阶对角矩阵

nd8 = np.diag([1, 2, 3])

print(nd5)

# [[0. 0. 0.]

# [0. 0. 0.]

# [0. 0. 0.]]

print(nd6)

# [[1. 1. 1.]

# [1. 1. 1.]

# [1. 1. 1.]]

print(nd7)

# [[1. 0. 0.]

# [0. 1. 0.]

# [0. 0. 1.]]

print(nd8)

# [[1 0 0]

# [0 2 0]

# [0 0 3]]

有时我们可能需要把生成的数据暂时保存起来，以备后续使用。

import numpy as np

nd9 =np.random.random([5, 5])
np.savetxt(X=nd9, fname='./test1.txt')
nd10 = np.loadtxt('./test1.txt')
print(nd10)

import numpy as np

nd9 =np.random.random([5, 5])

np.savetxt(X=nd9, fname='./test1.txt')

nd10 = np.loadtxt('./test1.txt')

print(nd10)

输出结果:
[[0.41092437 0.5796943 0.13995076 0.40101756 0.62731701]
[0.32415089 0.24475928 0.69475518 0.5939024 0.63179202]
[0.44025718 0.08372648 0.71233018 0.42786349 0.2977805 ]
[0.49208478 0.74029639 0.35772892 0.41720995 0.65472131]
[0.37380143 0.23451288 0.98799529 0.76599595 0.77700444]]

1.1.4 利用 arange、linspace 函数生成数组

arange 是 numpy 模块中的函数，其格式为:

arange([start,] stop[,step,], dtype=None)

1	arange([start,] stop[,step,], dtype=None)

其中start 与 stop 指定范围，step 设定步长，生成一个 ndarray，start 默认为 0，步长 step 可为小数。Python有个内置函数range功能与此类似。

import numpy as np

print(np.arange(10))
# [0 1 2 3 4 5 6 7 8 9]
print(np.arange(0, 10))
# [0 1 2 3 4 5 6 7 8 9]
print(np.arange(1, 4, 0.5))
# [1.  1.5 2.  2.5 3.  3.5]
print(np.arange(9, -1, -1))
# [9 8 7 6 5 4 3 2 1 0]

import numpy as np

print(np.arange(10))

# [0 1 2 3 4 5 6 7 8 9]

print(np.arange(0, 10))

# [0 1 2 3 4 5 6 7 8 9]

print(np.arange(1, 4, 0.5))

# [1. 1.5 2. 2.5 3. 3.5]

print(np.arange(9, -1, -1))

# [9 8 7 6 5 4 3 2 1 0]

linspace 也是 numpy 模块中常用的函数，其格式为:

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

1	np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

它可以根据输入的指定数据范围以及等份数量，自动生成一个线性等分向量，其中endpoint (包含终点)默认为 True，等分数量num默认为 50。如果将retstep设置为 True，则会返回一个带步长的 ndarray。

import numpy as np

print(np.linspace(0, 1, 10))
#[0.         0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
# 0.66666667 0.77777778 0.88888889 1.        ]

import numpy as np

print(np.linspace(0, 1, 10))

#[0. 0.11111111 0.22222222 0.33333333 0.44444444 0.55555556

# 0.66666667 0.77777778 0.88888889 1. ]

值得一提的，这里并没有像我们预期的那样，生成 0.1, 0.2, ... 1.0 这样步长为0.1的 ndarray，这是因为 linspace 必定会包含数据起点和终点，那么其步长则为(1-0) / 9 = 0.11111111。如果需要产生 0.1, 0.2, ... 1.0 这样的数据，只需要将数据起点 0 修改为 0.1 即可。
除了上面介绍到的 arange 和 linspace，NumPy还提供了 logspace 函数，该函数使用方法与 linspace 使用方法一样，读者不妨自己动手试一下。

1.2 获取元素

上节我们介绍了生成ndarray的几种方法，数据生成后，如何读取我们需要的数据？这节我们介绍几种常用方法。

import numpy as np
np.random.seed(2019)
nd11 = np.random.random([10])
#获取指定位置的数据，获取第4个元素
nd11[3]
#截取一段数据
nd11[3:6]
#截取固定间隔数据
nd11[1:6:2]
#倒序取数
nd11[::-2]
#截取一个多维数组的一个区域内数据
nd12=np.arange(25).reshape([5,5])
nd12[1:3,1:3]
#截取一个多维数组中，数值在一个值域之内的数据
nd12[(nd12>3)&(nd12<10)]
#截取多维数组中，指定的行,如读取第2,3行
nd12[[1,2]]  #或nd12[1:3,:]
##截取多维数组中，指定的列,如读取第2,3列
nd12[:,1:3]

import numpy as np

np.random.seed(2019)

nd11 = np.random.random([10])

#获取指定位置的数据，获取第4个元素

nd11[3]

#截取一段数据

nd11[3:6]

#截取固定间隔数据

nd11[1:6:2]

#倒序取数

nd11[::-2]

#截取一个多维数组的一个区域内数据

nd12=np.arange(25).reshape([5,5])

nd12[1:3,1:3]

#截取一个多维数组中，数值在一个值域之内的数据

nd12[(nd12>3)&(nd12<10)]

#截取多维数组中，指定的行,如读取第2,3行

nd12[[1,2]] #或nd12[1:3,:]

##截取多维数组中，指定的列,如读取第2,3列

nd12[:,1:3]

如果对上面这些获取方式还不是很清楚，没关系，下面我们通过图形的方式进一步说明，如图1-1所示，左边为表达式，右边为表达式获取的元素。注意不同的边界，表示不同的表达式。

图1-1 获取多维数组中的元素
获取数组中的部分元素除通过指定索引标签外，还可以使用一些函数来实现，如通过random.choice函数可以从指定的样本中进行随机抽取数据。

import numpy as np
from numpy import random as nr

a=np.arange(1,25,dtype=float)
c1=nr.choice(a,size=(3,4))  #size指定输出数组形状
c2=nr.choice(a,size=(3,4),replace=False)  #replace缺省为True，即可重复抽取。
#下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。
c3=nr.choice(a,size=(3,4),p=a / np.sum(a))
print("随机可重复抽取")
print(c1)
print("随机但不重复抽取")
print(c2)
print("随机但按制度概率抽取")
print(c3)

import numpy as np

from numpy import random as nr

a=np.arange(1,25,dtype=float)

c1=nr.choice(a,size=(3,4)) #size指定输出数组形状

c2=nr.choice(a,size=(3,4),replace=False) #replace缺省为True，即可重复抽取。

#下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。

c3=nr.choice(a,size=(3,4),p=a / np.sum(a))

print("随机可重复抽取")

print(c1)

print("随机但不重复抽取")

print(c2)

print("随机但按制度概率抽取")

print(c3)

打印结果：
随机可重复抽取
[[ 7. 22. 19. 21.]
[ 7. 5. 5. 5.]
[ 7. 9. 22. 12.]]
随机但不重复抽取
[[ 21. 9. 15. 4.]
[ 23. 2. 3. 7.]
[ 13. 5. 6. 1.]]
随机但按制度概率抽取
[[ 15. 19. 24. 8.]
[ 5. 22. 5. 14.]
[ 3. 22. 13. 17.]]

1.3 NumPy的算术运算

在机器学习和深度学习中，涉及大量的数组或矩阵运算，这节我们重点介绍两种常用的运算。一种是对应元素相乘，又称为逐元乘法(element-wise product)，运算符为np.multiply(), 或 *。另一种是点积或内积元素，运算符为np.dot()。

1.3.1对应元素相乘

对应元素相乘（element-wise product）是两个矩阵中对应元素乘积。np.multiply 函数用于数组或矩阵对应元素相乘，输出与相乘数组或矩阵的大小一致，其格式如下:

numpy.multiply(x1, x2, /, out=None, *, where=True,casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

1	numpy.multiply(x1, x2, /, out=None, *, where=True,casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])

其中x1，x2之间的对应元素相乘遵守广播规则，NumPy的广播规则本章第7小节将介绍。以下我们通过一些示例来进一步说明。

A = np.array([[1, 2], [-1, 4]])
B = np.array([[2, 0], [3, 4]])
A*B
##结果如下：
array([[ 2,  0],
       [-3, 16]])
#或另一种表示方法
np.multiply(A,B)
#运算结果也是
array([[ 2,  0],
       [-3, 16]])

A = np.array([[1, 2], [-1, 4]])

B = np.array([[2, 0], [3, 4]])

A*B

##结果如下：

array([[ 2, 0],

[-3, 16]])

#或另一种表示方法

np.multiply(A,B)

#运算结果也是

array([[ 2, 0],

[-3, 16]])

矩阵A和B的对应元素相乘，用图1-2直观表示为：

图1-2 对应元素相乘示意图
NumPy数组不仅可以和数组进行对应元素相乘，也可以和单一数值（或称为标量）进行运算。运算时，NumPy数组每个元素和标量进行运算，其间会用到广播机制（1.7小节将详细介绍）。

print(A*2.0)
print(A/2.0)

1 2	print(A*2.0) print(A/2.0)

[[ 2. 4.]
[-2. 8.]]
[[ 0.5 1. ]
[-0.5 2. ]]
由此，推而广之，数组通过一些激活函数后，输出与输入形状一致。

X=np.random.rand(2,3)
def softmoid(x):
    return 1/(1+np.exp(-x))
def relu(x):
    return np.maximum(0,x)
def softmax(x):
    return np.exp(x)/np.sum(np.exp(x))

print("输入参数X的形状：",X.shape)
print("激活函数softmoid输出形状：",softmoid(X).shape)
print("激活函数relu输出形状：",relu(X).shape)
print("激活函数softmax输出形状：",softmax(X).shape)

X=np.random.rand(2,3)

def softmoid(x):

return 1/(1+np.exp(-x))

def relu(x):

return np.maximum(0,x)

def softmax(x):

return np.exp(x)/np.sum(np.exp(x))

print("输入参数X的形状：",X.shape)

print("激活函数softmoid输出形状：",softmoid(X).shape)

print("激活函数relu输出形状：",relu(X).shape)

print("激活函数softmax输出形状：",softmax(X).shape)

输入参数X的形状： (2, 3)
激活函数softmoid输出形状： (2, 3)
激活函数relu输出形状： (2, 3)
激活函数softmax输出形状： (2, 3)

1.3.2 点积运算

点积运算（dot product）又称为内积，在NumPy用np.dot表示，其一般格式为：

numpy.dot(a, b, out=None)

1	numpy.dot(a, b, out=None)

以下通过一个示例来说明dot的具体使用及注意事项。

X1=np.array([[1,2],[3,4]])
X2=np.array([[5,6,7],[8,9,10]])
X3=np.dot(X1,X2)
print(X3)

X1=np.array([[1,2],[3,4]])

X2=np.array([[5,6,7],[8,9,10]])

X3=np.dot(X1,X2)

print(X3)

[[21 24 27]
[47 54 61]]
以上运算，用图1-3可表示为：

图1-3 矩阵的点积示意图，对应维度的元素个数需要保持一致
如图1-3所示，矩阵X1和矩阵X2进行点积运算，其中X1和X2对应维度（即X1的第2个维度与X2的第1个维度）的元素个数必须保持一致，此外，矩阵X3的形状是由矩阵X1的行数与矩阵X2的列数构成的。

1.4 数组变形

在机器学习以及深度学习的任务中，通常需要将处理好的数据以模型能接受的格式喂给模型，然后模型通过一系列的运算，最终返回一个处理结果。然而，由于不同模型所接受的输入格式不一样，往往需要先对其进行一系列的变形和运算，从而将数据处理成符合模型要求的格式。最常见的是矩阵或者数组的运算，经常会遇到需要把多个向量或矩阵按某轴方向合并，或需要展平（如在卷积或循环神经网络中，在全连接层之前，需要把矩阵展平）。下面介绍几种常用数据变形方法。

1.4.1 更改数组的形状

修改指定数组的形状是 NumPy 中最常见的操作之一，常见的方法有很多，表1-3 列出了一些常用函数。
表1-3 NumPy中改变向量形状的一些函数

下面我们来看一些示例:
（1）reshape

import numpy as np

arr =np.arange(10)
print(arr)
# 将向量 arr 维度变换为2行5列
print(arr.reshape(2, 5))
# 指定维度时可以只指定行数或列数, 其他用 -1 代替
print(arr.reshape(5, -1))
print(arr.reshape(-1, 5))

import numpy as np

arr =np.arange(10)

print(arr)

# 将向量 arr 维度变换为2行5列

print(arr.reshape(2, 5))

# 指定维度时可以只指定行数或列数, 其他用 -1 代替

print(arr.reshape(5, -1))

print(arr.reshape(-1, 5))

输出结果:
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2 3 4]
[5 6 7 8 9]]
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
[[0 1 2 3 4]
[5 6 7 8 9]]
值得注意的是，reshape 函数支持只指定行数或列数，剩余的设置为-1即可。所指定的行数或列数一定要能被整除（如10不能被3整除），例如上面代码如果修改为arr.reshape(3,-1)将报错误。
（2）resize

import numpy as np

arr =np.arange(10)
print(arr)
# 将向量 arr 维度变换为2行5列
arr.resize(2, 5)
print(arr)

import numpy as np

arr =np.arange(10)

print(arr)

# 将向量 arr 维度变换为2行5列

arr.resize(2, 5)

print(arr)

输出结果:
[0 1 2 3 4 5 6 7 8 9]
[[0 1 2 3 4]
[5 6 7 8 9]]
（3）.T

import numpy as np

arr =np.arange(12).reshape(3,4)
# 向量 arr 为3行4列
print(arr)
# 将向量 arr 进行转置为4行3列
print(arr.T)

import numpy as np

arr =np.arange(12).reshape(3,4)

# 向量 arr 为3行4列

print(arr)

# 将向量 arr 进行转置为4行3列

print(arr.T)

输出结果:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
（4）ravel

import numpy as np

arr =np.arange(6).reshape(2, -1)
print(arr)
# 按照列优先，展平
print("按照列优先，展平")
print(arr.ravel('F'))
# 按照行优先，展平
print("按照行优先，展平")
print(arr.ravel())

import numpy as np

arr =np.arange(6).reshape(2, -1)

print(arr)

# 按照列优先，展平

print("按照列优先，展平")

print(arr.ravel('F'))

# 按照行优先，展平

print("按照行优先，展平")

print(arr.ravel())

输出结果:
[[0 1 2]
[3 4 5]]
按照列优先，展平
[0 3 1 4 2 5]
按照行优先，展平
[0 1 2 3 4 5]
（5）flatten
把矩阵转换为向量，这种需求经常出现在卷积网络与全连接层之间。

import numpy as np
a =np.floor(10*np.random.random((3,4)))
print(a)
print(a.flatten())

import numpy as np

a =np.floor(10*np.random.random((3,4)))

print(a)

print(a.flatten())

输出结果:
[[4. 0. 8. 5.]
[1. 0. 4. 8.]
[8. 2. 3. 7.]]
[4. 0. 8. 5. 1. 0. 4. 8. 8. 2. 3. 7.]
（6）squeeze
这是一个重要用来降维的函数，把矩阵中含1的维度去掉。在Pytorch中还有一种与之相反的操作，torch.unsqueeze这个后面将介绍。

import numpy as np

arr =np.arange(3).reshape(3, 1)
print(arr.shape)  #(3,1)
print(arr.squeeze().shape)  #(3,)
arr1 =np.arange(6).reshape(3,1,2,1)
print(arr1.shape) #(3, 1, 2, 1)
print(arr1.squeeze().shape) #(3, 2)

import numpy as np

arr =np.arange(3).reshape(3, 1)

print(arr.shape) #(3,1)

print(arr.squeeze().shape) #(3,)

arr1 =np.arange(6).reshape(3,1,2,1)

print(arr1.shape) #(3, 1, 2, 1)

print(arr1.squeeze().shape) #(3, 2)

（7）transpose
对高维矩阵进行轴对换，这个在深度学习中经常使用，比如把图片表示颜色的RGB顺序，改为GBR的顺序。

import numpy as np

arr2 = np.arange(24).reshape(2,3,4)
print(arr2.shape)  #(2, 3, 4)
print(arr2.transpose(1,2,0).shape)  #(3, 4, 2)

import numpy as np

arr2 = np.arange(24).reshape(2,3,4)

print(arr2.shape) #(2, 3, 4)

print(arr2.transpose(1,2,0).shape) #(3, 4, 2)

1.4.2 合并数组

合并数组也是最常见的操作之一，表1-4列举了常用的用于数组或向量合并的方法。
表1-4 NumPy 数组合并方法

[说明]
①append、concatnate以及stack都有一个 axis 参数，用于控制数组合并是按行还是按列。
②对于append和concatnate，待合并的数组必须有相同的行数或列数(满足一个即可)。
③stack、hstack、dstack待合并的数组必须具有相同的形状( shape)。
下面选择一些常用函数进行说明。
（1）append
合并一维数组

import numpy as np

a =np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.append(a, b)
print(c) 
# [1 2 3 4 5 6]

import numpy as np

a =np.array([1, 2, 3])

b = np.array([4, 5, 6])

c = np.append(a, b)

print(c)

# [1 2 3 4 5 6]

合并多维数组

import numpy as np

a =np.arange(4).reshape(2, 2)
b = np.arange(4).reshape(2, 2)
# 按行合并
c = np.append(a, b, axis=0)
print('按行合并后的结果')
print(c)
print('合并后数据维度', c.shape)
# 按列合并
d = np.append(a, b, axis=1)
print('按列合并后的结果')
print(d)
print('合并后数据维度', d.shape)

import numpy as np

a =np.arange(4).reshape(2, 2)

b = np.arange(4).reshape(2, 2)

# 按行合并

c = np.append(a, b, axis=0)

print('按行合并后的结果')

print(c)

print('合并后数据维度', c.shape)

# 按列合并

d = np.append(a, b, axis=1)

print('按列合并后的结果')

print(d)

print('合并后数据维度', d.shape)

输出结果:
按行合并后的结果
[[0 1]
[2 3]
[0 1]
[2 3]]
合并后数据维度 (4, 2)
按列合并后的结果
[[0 1 0 1]
[2 3 2 3]]
合并后数据维度 (2, 4)
（2）concatenate
沿指定轴连接数组或矩阵

import numpy as np
a =np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])

c = np.concatenate((a, b), axis=0)
print(c)
d = np.concatenate((a, b.T), axis=1)
print(d)

import numpy as np

a =np.array([[1, 2], [3, 4]])

b = np.array([[5, 6]])

c = np.concatenate((a, b), axis=0)

print(c)

d = np.concatenate((a, b.T), axis=1)

print(d)

输出结果:
[[1 2]
[3 4]
[5 6]]
[[1 2 5]
[3 4 6]]
（3）stack
沿指定轴堆叠数组或矩阵

import numpy as np

a =np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])
print(np.stack((a, b), axis=0))

import numpy as np

a =np.array([[1, 2], [3, 4]])

b = np.array([[5, 6], [7, 8]])

print(np.stack((a, b), axis=0))

输出结果:
[[[1 2]
[3 4]]

[[5 6]
[7 8]]]

1.5 批量处理

在深度学习中，由于源数据都比较大，所以通常需要采用批处理。如利用批量来计算梯度的随机梯度法（SGD），就是一个典型应用。深度学习的计算一般比较复杂，加上数据量一般比较大，如果一次处理整个数据，往往出现资源瓶颈。为了更有效的计算，一般将整个数据集分成小批量。与处理整个数据集的另一个极端是每次处理一条记录，这种方法也不科学，一次处理一条记录无法充分发挥GPU、NumPy平行处理优势。因此，实际使用中往往采用批量处理（mini-batch）。
如何把大数据拆分成多个批次呢？可采用如下步骤：
（1）得到数据集
（2）随机打乱数据
（3）定义批大小
（4）批处理数据集
以下我们通过一个示例来具体说明：

import numpy as np
#生成10000个形状为2X3的矩阵
data_train = np.random.randn(10000,2,3)
#这是一个3维矩阵，第一个维度为样本数，后两个是数据形状
print(data_train.shape)
#(10000,2,3)
#打乱这10000条数据
np.random.shuffle(data_train)
#定义批量大小
batch_size=100
#进行批处理
for i in range(0,len(data_train),batch_size):
    x_batch_sum=np.sum(data_train[i:i+batch_size])
    print("第{}批次,该批次的数据之和:{}".format(i,x_batch_sum))

import numpy as np

#生成10000个形状为2X3的矩阵

data_train = np.random.randn(10000,2,3)

#这是一个3维矩阵，第一个维度为样本数，后两个是数据形状

print(data_train.shape)

#(10000,2,3)

#打乱这10000条数据

np.random.shuffle(data_train)

#定义批量大小

batch_size=100

#进行批处理

for i in range(0,len(data_train),batch_size):

x_batch_sum=np.sum(data_train[i:i+batch_size])

print("第{}批次,该批次的数据之和:{}".format(i,x_batch_sum))

最后5行结果：
第9500批次,该批次的数据之和:17.63702580438092
第9600批次,该批次的数据之和:-1.360924607368387
第9700批次,该批次的数据之和:-25.912226239266445
第9800批次,该批次的数据之和:32.018136957835814
第9900批次,该批次的数据之和:2.9002576614446935
【说明】
批次从0开始，所以最后一个批次是9900。

1.6 通用函数

NumPy提供了两种基本的对象，即ndarray和ufunc对象。前面我们介绍了ndarray，本节将介绍NumPy的另一个对象通用函数(ufunc)，ufunc是universal function的缩写，它是一种能对数组的每个元素进行操作的函数。许多ufunc函数都是用c语言级别实现的，因此它们的计算速度非常快。此外，它们比math模块中函数更灵活。math模块的输入一般是标量，但NumPy中函数可以是向量或矩阵，而利用向量或矩阵可以避免使用循环语句，这点在机器学习、深度学习中非常重要。表1-5为NumPy常用的几个通用函数。
表1-5 NumPy几个常用通用函数

（1）math与numpy函数的性能比较：

import time
import math
import numpy as np

x = [i * 0.001 for i in np.arange(1000000)]
start = time.clock()
for i, t in enumerate(x):
    x[i] = math.sin(t)
print ("math.sin:", time.clock() - start )

x = [i * 0.001 for i in np.arange(1000000)]
x = np.array(x)
start = time.clock()
np.sin(x)
print ("numpy.sin:", time.clock() - start )

import time

import math

import numpy as np

x = [i * 0.001 for i in np.arange(1000000)]

start = time.clock()

for i, t in enumerate(x):

x[i] = math.sin(t)

print ("math.sin:", time.clock() - start )

x = [i * 0.001 for i in np.arange(1000000)]

x = np.array(x)

start = time.clock()

np.sin(x)

print ("numpy.sin:", time.clock() - start )

打印结果
math.sin: 0.5169950000000005
numpy.sin: 0.05381199999999886
由此可见，numpy.sin比math.sin快近10倍。
（2）循环与向量运算比较：
充分使用Python的NumPy库中的内建函数（built-in function），实现计算的向量化，可大大提高运行速度。NumPy库中的内建函数使用了SIMD指令。如下使用的向量化要比使用循环计算速度快得多。如果使用GPU，其性能将更强大,不过NumPy不支持GPU。Pytorch支持GPU，第5章将介绍Pytorch如何使用GPU来加速算法。

import time
import numpy as np

x1 = np.random.rand(1000000)
x2 = np.random.rand(1000000)
##使用循环计算向量点积
tic = time.process_time()
dot = 0
for i in range(len(x1)):
    dot+= x1[i]*x2[i]
toc = time.process_time()
print ("dot = " + str(dot) + "\n for loop----- Computation time = " + str(1000*(toc - tic)) + "ms")
##使用numpy函数求点积
tic = time.process_time()
dot = 0
dot = np.dot(x1,x2)
toc = time.process_time()
print ("dot = " + str(dot) + "\n verctor version---- Computation time = " + str(1000*(toc - tic)) + "ms")

import time

import numpy as np

x1 = np.random.rand(1000000)

x2 = np.random.rand(1000000)

##使用循环计算向量点积

tic = time.process_time()

dot = 0

for i in range(len(x1)):

dot+= x1[i]*x2[i]

toc = time.process_time()

print ("dot = " + str(dot) + "\n for loop----- Computation time = " + str(1000*(toc - tic)) + "ms")

##使用numpy函数求点积

tic = time.process_time()

dot = 0

dot = np.dot(x1,x2)

toc = time.process_time()

print ("dot = " + str(dot) + "\n verctor version---- Computation time = " + str(1000*(toc - tic)) + "ms")

输出结果
dot = 250215.601995
for loop----- Computation time = 798.3389819999998ms
dot = 250215.601995
verctor version---- Computation time = 1.885051999999554ms
从运行结果上来看，使用for循环的运行时间大约是向量运算的400倍。因此，深度学习算法中，一般都使用向量化矩阵运算。

1.7 广播机制

NumPy的Universal functions 中要求输入的数组shape是一致的，当数组的shape不相等的时候，则会使用广播机制。不过，调整数组使得shape一样，需满足一定规则，否则将出错。这些规则可归结为以下四条：
（1）让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐；
如：a：2x3x2 b：3x2，则b向a看齐，在b的前面加1：变为：1x3x2
（2）输出数组的shape是输入数组shape的各个轴上的最大值；
（3）如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错；
（4）当输入数组的某个轴的长度为1时，沿着此轴运算时都用（或复制）此轴上的第一组值。
广播在整个NumPy中用于决定如何处理形状迥异的数组；涉及算术运算包括(+，-，*，/…)。这些规则说的很严谨，但不直观，下面我们结合图形与代码进一步说明：
目的：A+B
其中A为4x1矩阵，B为一维向量 (3,)
要相加，需要做如下处理：
（1）根据规则1，B需要向看齐，把B变为（1,3）
（2）根据规则2，输出的结果为各个轴上的最大值，即输出结果应该为（4,3）矩阵
那么A如何由（4,1）变为（4,3）矩阵？B如何由（1,3）变为（4,3）矩阵？
3）根据规则4，用此轴上的第一组值（要主要区分是哪个轴），进行复制（但在实际处理中不是真正复制，否则太耗内存，而是采用其它对象如ogrid对象，进行网格处理）即可，
详细处理如图1-4所示。

图1-4 NumPy广播规则示意图
代码实现

import numpy as np
A = np.arange(0, 40,10).reshape(4, 1)
B = np.arange(0, 3)
print("A矩阵的形状:{},B矩阵的形状:{}".format(A.shape,B.shape))
C=A+B
print("C矩阵的形状:{}".format(C.shape))
print(C)

import numpy as np

A = np.arange(0, 40,10).reshape(4, 1)

B = np.arange(0, 3)

print("A矩阵的形状:{},B矩阵的形状:{}".format(A.shape,B.shape))

C=A+B

print("C矩阵的形状:{}".format(C.shape))

print(C)

运行结果
A矩阵的形状:(4, 1),B矩阵的形状:(3,)
C矩阵的形状:(4, 3)
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]

1.8 小结

本章主要介绍了NumPy模块的常用操作，尤其涉及对矩阵的操作，这些操作在后续程序中经常使用。NumPy内容很丰富，这里只列了一些主要内容，如果你想了解更多内容，可登录NumPy官网：http://www.numpy.org/

3.4 优化RNN

RNN擅长处理序列数据，尤其当后面数据与前面数据有依赖关系时。不过，如果这种依赖涉及长依赖的话，使用RNN的效果将受到较大影响，因长依赖就意味着时间步就要大，而根据梯度的关联规则，会发现累乘会导致激活函数导数的累乘，如果取tanh或sigmoid函数作为激活函数的话，那么必然是一堆小数在做乘法，结果就是越乘越小。随着时间序列的不断深入，小数的累乘就会导致梯度越来越小直到接近于0，这就是“梯度消失“现象。实际使用中，会优先选择tanh函数，原因是tanh函数相对于sigmoid函数来说梯度较大，收敛速度更快且引起梯度消失更慢。通常减缓梯度消失的几种方法：
1、选取更好的激活函数，如Relu激活函数。ReLU函数的左侧导数为0，右侧导数恒为1，这就避免了“梯度消失“的发生。但大于1的导数容易导致“梯度爆炸“，但设定合适的阈值可以解决这个问题。
2、加入BN层，其优点包括可加速收敛、控制过拟合，可以少用或不用Dropout和正则、降低网络对初始化权重不敏感，且能允许使用较大的学习率等。
3、改变传播结构，LSTM结构可以有效解决这个问题。接下来我们将介绍LSTM相关内容。
这些方法中，LSTM比其他几种方法效果要好，LSTM的核心思想就是增加一条记忆以往信息的传送带，这条传送带通过各种更新信息相加，而从有效避免梯度消失问题。
LSTM成功用于许多应用（如语言建模，手势预测，用户建模）。 LSTM基于记忆的序列建模架构非常有影响力——它启发了许多最新的改进方法，例如Transformers。

3.4.1 LSTMCell

1.RNN与LSTM的关系图

图1-14 RNN与LSTM的关系
从图1-14 可知，RNN对应LSTM中方框部分，方框部分的信息就是当前状态信息，该信息将通过输入门之后加入到传送带C中。

2.LSTMCell整体架构图
LSTM 通过精心设计的称作为“门”的结构来去除或者增加信息到传送带C状态的能力。门是一种让信息选择式通过的方法。他们通过含激活 sigmoid 神经网络层形成门（如图1-15中等信息进行过滤。

图1-15 LSTM架构图
LSTM三个门的主要功能：

输入门对当前信息C ̃_t进行过滤，其表示式为：

2.LSTMCell的详细结构

图1-16 LSTM的详细内部结构图
为简明起见，图1-16中假设输入为3个元素的向量，隐藏状态及传送信息都是2个元素的向量。隐藏状态与输入拼接成5个元素的向量。实际应用中输入、状态一般加上批量等维度，如[batch,input_size]，如果在LSTM模块中还需加上序列长度，形如[batch,seg_len,input_size]。multiplication是指哈达玛积，S表示Softmoid，T表示Tanh。

3.4.2 LSTMCell

LSTMCell这是LSTM的一个单元，如图1-15所示。该单元可以用PyTorch的 nn.LSTMCell模块来实现，该模块构建LSTM中的一个Cell，同一层会共享这一个Cell，但要手动处理每个时刻的迭代计算过程。如果要建立多层的LSTM，就要建立多个nn.LSTMCell。
1 .构造方法
构造方法和nn.RNNcell类似，依次传入feature_len和hidden_len，因为这只是一个计算单元，所以不涉及层数。
2. forward方法
回顾一下nn.RNNCell的forward方法，它是：
ht=nn.rnncell(x,ht-1)
即上一时刻的输出ht−1经nn.RNNCell前向计算得到这一时刻的ht。
对于nn.LSTMCell也是类似，但因为LSTM计算单元中还涉及对上一时刻的记忆Ct−1的使用，所以是
ht,ct=lstmcell(xt,(ht-1,ct-1))
因为输入xt只是t时刻的输入，不涉及seq_len，所以其shape是[batch,feature_len]
而ht和Ct在这里只是t时刻本层的隐藏单元和记忆单元，不涉及num_layers，所以其shape是 [batch,hidden_len]

3.4.3 一层的例子

每个时刻传入新的输入xt和上一时刻的隐藏单元ht−1和记忆单元Ct−1，并把这两个单元更新。

import torch
from torch import nn

# 一层的LSTM计算单元,输入的feature_len=100,隐藏单元和记忆单元hidden_len=20
cell = nn.LSTMCell(input_size=100, hidden_size=20)

# 初始化隐藏单元h和记忆单元C,取batch=3
h = torch.zeros(3, 20)
C = torch.zeros(3, 20)

# 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]
xs = [torch.randn(3, 100) for _ in range(10)]

# 对每个时刻,传入输入x_t和上个时刻的h_{t-1}和C_{t-1}
for xt in xs:
    h, C = cell(xt, (h, C))

print(h.shape)  # torch.Size([3, 20])
print(C.shape)  # torch.Size([3, 20])

import torch

from torch import nn

# 一层的LSTM计算单元,输入的feature_len=100,隐藏单元和记忆单元hidden_len=20

cell = nn.LSTMCell(input_size=100, hidden_size=20)

# 初始化隐藏单元h和记忆单元C,取batch=3

h = torch.zeros(3, 20)

C = torch.zeros(3, 20)

# 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]

xs = [torch.randn(3, 100) for _ in range(10)]

# 对每个时刻,传入输入x_t和上个时刻的h_{t-1}和C_{t-1}

for xt in xs:

h, C = cell(xt, (h, C))

print(h.shape) # torch.Size([3, 20])

print(C.shape) # torch.Size([3, 20])

3.4.4 两层的例子

在最底下一层l0层和上面的例子一样，上层还需要接受下层的输出ht作为当前输入，然后同样是依赖本层上一时刻的h和C更新本层的h和C。注意LSTM单元的输入输出结构，向上层传递的是h而不是C。

import torch
from torch import nn

# 输入的feature_len=100,变到该层隐藏单元和记忆单元hidden_len=30
cell_l0 = nn.LSTMCell(input_size=100, hidden_size=30)
# hidden_len从l0层的30变到这一层的20
cell_l1 = nn.LSTMCell(input_size=30, hidden_size=20)

# 分别初始化l0层和l1层的隐藏单元h和记忆单元C,取batch=3
# 注意l0层的hidden_len=30
h_l0 = torch.zeros(3, 30)
C_l0 = torch.zeros(3, 30)
# 而到l1层之后hidden_len=20
h_l1 = torch.zeros(3, 20)
C_l1 = torch.zeros(3, 20)

# 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]
xs = [torch.randn(3, 100) for _ in range(10)]

# 对每个时刻,从下到上计算本时刻的所有层
for xt in xs:
    h_l0, C_l0 = cell_l0(xt, (h_l0, C_l0))  # l0层直接接受xt输入
    h_l1, C_l1 = cell_l1(h_l0, (h_l1, C_l1))  # l1层接受l0层的输出h为输入

# 最后shape是不变的
print(h_l0.shape)  # torch.Size([3, 30])
print(C_l0.shape)  # torch.Size([3, 30])
print(h_l1.shape)  # torch.Size([3, 20])
print(C_l1.shape)  # torch.Size([3, 20])

import torch

from torch import nn

# 输入的feature_len=100,变到该层隐藏单元和记忆单元hidden_len=30

cell_l0 = nn.LSTMCell(input_size=100, hidden_size=30)

# hidden_len从l0层的30变到这一层的20

cell_l1 = nn.LSTMCell(input_size=30, hidden_size=20)

# 分别初始化l0层和l1层的隐藏单元h和记忆单元C,取batch=3

# 注意l0层的hidden_len=30

h_l0 = torch.zeros(3, 30)

C_l0 = torch.zeros(3, 30)

# 而到l1层之后hidden_len=20

h_l1 = torch.zeros(3, 20)

C_l1 = torch.zeros(3, 20)

# 这里是seq_len=10个时刻的输入,每个时刻shape都是[batch,feature_len]

xs = [torch.randn(3, 100) for _ in range(10)]

# 对每个时刻,从下到上计算本时刻的所有层

for xt in xs:

h_l0, C_l0 = cell_l0(xt, (h_l0, C_l0)) # l0层直接接受xt输入

h_l1, C_l1 = cell_l1(h_l0, (h_l1, C_l1)) # l1层接受l0层的输出h为输入

# 最后shape是不变的

print(h_l0.shape) # torch.Size([3, 30])

print(C_l0.shape) # torch.Size([3, 30])

print(h_l1.shape) # torch.Size([3, 20])

print(C_l1.shape) # torch.Size([3, 20])

3.4.5 PyTorch的LSTM模块

https://zhuanlan.zhihu.com/p/139617364
1、多层LSTM的网络架构

图1-17 多层LSTM架构图
2、LSTM模块

class torch.nn.LSTM(*args, **kwargs)
参数有：
    input_size：x的特征维度
    hidden_size：隐藏层的特征维度
    num_layers：lstm隐层的层数，默认为1
    bias：False则bihbih=0和bhhbhh=0. 默认为True
    batch_first：True则输入输出的数据格式为 (batch, seq, feature)，默认为：False
    dropout：除最后一层，每一层的输出都进行dropout，默认为: 0
    bidirectional：True则为双向lstm默认为False

class torch.nn.LSTM(*args, **kwargs)

参数有：

input_size：x的特征维度

hidden_size：隐藏层的特征维度

num_layers：lstm隐层的层数，默认为1

bias：False则bihbih=0和bhhbhh=0. 默认为True

batch_first：True则输入输出的数据格式为 (batch, seq, feature)，默认为：False

dropout：除最后一层，每一层的输出都进行dropout，默认为: 0

bidirectional：True则为双向lstm默认为False

3、输入
input(seq_len, batch, input_size)
参数有：
seq_len：序列长度，在NLP中就是句子长度，一般都会用pad_sequence补齐长度
batch：每次喂给网络的数据条数，在NLP中就是一次喂给网络多少个句子
input_size：特征维度，和前面定义网络结构的input_size一致

图1-18 LSTM的输入格式
如果LSTM的参数 batch_first=True，则要求输入的格式是：input(batch, seq_len, input_size)
4、隐含层
LSTM有两个输入是 h0 和 c0，可以理解成网络的初始化参数，用随机数生成即可。

h0(num_layers * num_directions, batch, hidden_size)
c0(num_layers * num_directions, batch, hidden_size)

1 2	h0(num_layers * num_directions, batch, hidden_size) c0(num_layers * num_directions, batch, hidden_size)

参数：
num_layers：隐藏层数
num_directions：如果是单向循环网络，则num_directions=1，双向则num_directions=2
batch：输入数据的batch
hidden_size：隐藏层神经元个数
注意，如果我们定义的input格式是：
input(batch, seq_len, input_size)
则H和C的格式也是要变的：

h0(batc，num_layers * num_directions, h, hidden_size)
c0(batc，num_layers * num_directions, h, hidden_size)

1 2	h0(batc，num_layers * num_directions, h, hidden_size) c0(batc，num_layers * num_directions, h, hidden_size)

5、输出
LSTM的输出是一个tuple，如下：
output,(ht, ct) = net(input)
output: 最后一个状态的隐藏层的神经元输出
ht：最后一个状态的隐含层的状态值
ct：最后一个状态的隐含层的遗忘门值
output的默认维度是：

output(seq_len, batch, hidden_size * num_directions)
ht(num_layers * num_directions, batch, hidden_size)
ct(num_layers * num_directions, batch, hidden_size)

output(seq_len, batch, hidden_size * num_directions)

ht(num_layers * num_directions, batch, hidden_size)

ct(num_layers * num_directions, batch, hidden_size)

和input的情况类似，如果我们前面定义的input格式是：
input(batch, seq_len, input_size)
则ht和ct的格式也是要变的：

ht(batc，num_layers * num_directions, h, hidden_size)
ct(batc，num_layers * num_directions, h, hidden_size)

1 2	ht(batc，num_layers * num_directions, h, hidden_size) ct(batc，num_layers * num_directions, h, hidden_size)

3.5 LSTM实现文本生实例

本实例使用2014人民日报上的一些新闻，使用PyTorch提供的nn.LSTM模型，根据提示字符串预测给定长度的语句。整个处理与3.3小节基本相同，构建模型时稍有不同，LSTM有两个变量h和c，RNN只要一个h。

3.6 GRU结构

https://blog.csdn.net/Jerr__y/article/details/58598296
LSTM门比较多，状态有C和H,其中C就相当于中间变量一样，输出只有H。有关LSTM的改进方案比较多，其中比较著名的变种 GRU（Gated Recurrent Unit ），这是由 Cho, et al. (2014) 提出。在 GRU 中，如下图所示，只有两个门：重置门（reset gate）和更新门（update gate）。同时在这个结构中，把细胞状态和隐藏状态进行了合并。最后模型比标准的 LSTM 结构要简单，而且这个结构后来也非常流行。

图1-19 GRU模型结构图
其中，r_t 表示重置门，z_t表示更新门。重置门决定是否将之前的状态（h_(t-1)）忘记。当r_t趋于 0 的时候，前一个时刻的状态信息 h_(t-1)将被忘掉，隐藏状态 h_t会被重置为当前输入的信息。更新门决定是否要将隐藏状态更新为新的状态 h ̃_t （更新门的作用相当于合并了 LSTM 中的遗忘门和输入门）。
和 LSTM 比较一下：
(1) GRU 少一个门，同时少了传送带状态 C_t。
(2) 在 LSTM 中，通过遗忘门和输入门控制信息的保留和传入；GRU 则通过重置门来控制是否要保留原来隐藏状态的信息，但是不再限制当前信息的传入。
(3) 在 LSTM 中，虽然得到了新的传送带状态 C_t，但是它仅仅作为一个中间变量，不直接输出，而是需要经过一个过滤的处理：
h_t=O_t 〖⊗tanh⁡(C〗_t)
同样，在 GRU 中, 虽然 (2) 中也得到了新的隐藏状态h_t，但是还不能直接输出，而是通过更新门来控制最后的输出：
h_t=(1-z_t )⊗h_(t-1)+z_t⊗h ̃_t
保留以往隐藏状态（h_(t-1)）和保留当前隐藏状态（h ̃_t）之间是一种互斥关系，这点从上面这个公式也可说明。如果z_t 越接近1，则(1-z_t )就越接近于0；反之，也成立。

3.7 biRNN结构

1.biRNN的网络架构
图1-20 为biRNN的网络架构图，从图中还可以看出，对于一个序列，一次向前遍历得到左LSTM，向后遍历得到右LSTM。隐层矢量直接通过拼接（concat）得到，最终损失函数直接相加，具体如下图。

图1-20 biRNN模型结构图
2、biRNN的不足
（1）biRNN模型的前向和后向LSTM模型是分开训练的，故它不是真正双向学习的模型，即biRNN无法同时向前和向后学习。
（2）biRNN如果层数多了，将出现自己看到自己的情况。下图中第2行第2列中的A|CD，此结果是第一层Bi LSTM的B位置输出内容，包括正向A和反向CD，然后直接拼接就得到A| CD。下图中第3行第2列中的ABCD, 此结果为正向BCD和反向AB | D拼接而成，当前位置需要预测的是B，但B已经在这里ABCD出现了。所以对于Bi LSTM，只要层数增加，会有一个“看到你自己”的问题。

图1-21 多层biRNN将自己看到自己示意图

利用RNN生成中文语句实例

本实例使用2014人民日报上的一些新闻（约28万条,60M），使用PyTorch提供的nn.rnn模型，根据提示字符串预测给定长度的语句。

数据下载

提取码：6l9e

3.3.1 模型架构

图1-13 RNN实例模型架构图

3.3.2 导入需要的模块

import argparse
import torch
from torch import nn
import numpy as np
from torch import nn, optim
from torch.utils.data import DataLoader

import argparse

import torch

from torch import nn

import numpy as np

from torch import nn, optim

from torch.utils.data import DataLoader

3.3.3 定义预处理函数

使用torch.utils.data生成可迭代的数据集。

class Dataset(torch.utils.data.Dataset):
    def __init__(self,args,):
        self.args = args
        self.words = self.load_words()
        self.uniq_words = self.get_uniq_words()

        self.index_to_word = {index: word for index, word in enumerate(self.uniq_words)}
        self.word_to_index = {word: index for index, word in enumerate(self.uniq_words)}
        
        self.words_indexes = [self.word_to_index[w] for w in self.words]
        

    def load_words(self):
        """加载人民日报新闻数据集"""
        with open(r'D:\python-script\py\data\people_news-03.txt',encoding='UTF-8') as f:
            corpus_chars = f.read()
            #删除一些标点符合，回车符等        
        corpus_chars = corpus_chars.replace('。', '').replace('\r', '').replace("，", '').replace(",", '').replace("？", '').replace("！", '')
        corpus_chars = corpus_chars.replace("、", '').replace('\n', '').replace('\ufeff', '')
        corpus_chars = corpus_chars[0:15000]        
        return corpus_chars
    def get_uniq_words(self):
        idx_to_char = list(set(self.words))
        return idx_to_char
    
    def __len__(self):
        return len(self.words_indexes) - self.args.sequence_length

    def __getitem__(self, index):
        return (
            torch.tensor(self.words_indexes[index:index+self.args.sequence_length]),
            torch.tensor(self.words_indexes[index+1:index+self.args.sequence_length+1]),
        )

class Dataset(torch.utils.data.Dataset):

def __init__(self,args,):

self.args = args

self.words = self.load_words()

self.uniq_words = self.get_uniq_words()

self.index_to_word = {index: word for index, word in enumerate(self.uniq_words)}

self.word_to_index = {word: index for index, word in enumerate(self.uniq_words)}

self.words_indexes = [self.word_to_index[w] for w in self.words]

def load_words(self):

"""加载人民日报新闻数据集"""

with open(r'D:\python-script\py\data\people_news-03.txt',encoding='UTF-8') as f:

corpus_chars = f.read()

#删除一些标点符合，回车符等

corpus_chars = corpus_chars.replace('。', '').replace('\r', '').replace("，", '').replace(",", '').replace("？", '').replace("！", '')

corpus_chars = corpus_chars.replace("、", '').replace('\n', '').replace('\ufeff', '')

corpus_chars = corpus_chars[0:15000]

return corpus_chars

def get_uniq_words(self):

idx_to_char = list(set(self.words))

return idx_to_char

def __len__(self):

return len(self.words_indexes) - self.args.sequence_length

def __getitem__(self, index):

return (

torch.tensor(self.words_indexes[index:index+self.args.sequence_length]),

torch.tensor(self.words_indexes[index+1:index+self.args.sequence_length+1]),

)

3.3.4 定义模型

根据图1-13构建模型，以Embedding为输入层，隐含节点数为256，共两层。为何使用Embedding层作为输入层，而不使用One-hot编码作为输入层？Embedding输入层，除可以有效压缩维度空间外（与以one-hot编码为输入层），更重要的是Embedding层在整个迭代过程中参与学习。

class Model(nn.Module):
    def __init__(self, dataset):
        super(Model, self).__init__()
        self.input_size = 128
        self.hidden_size=256
        self.embedding_dim = 128
        self.num_layers = 2

        n_vocab = len(dataset.uniq_words)
        self.embedding = nn.Embedding(
            num_embeddings=n_vocab,
            embedding_dim=self.embedding_dim,
        )
        self.rnn = nn.RNN(
            input_size=self.input_size,
            hidden_size=self.hidden_size,
            num_layers=self.num_layers,            
        )
        self.fc = nn.Linear(self.hidden_size, n_vocab)

    def forward(self, x, prev_state):
        embed = self.embedding(x)
        
        output,state = self.rnn(embed, prev_state)
        logits = self.fc(output)

        return logits,state

    def init_state(self, sequence_length):
        return (torch.zeros(self.num_layers, sequence_length, self.hidden_size))

class Model(nn.Module):

def __init__(self, dataset):

super(Model, self).__init__()

self.input_size = 128

self.hidden_size=256

self.embedding_dim = 128

self.num_layers = 2

n_vocab = len(dataset.uniq_words)

self.embedding = nn.Embedding(

num_embeddings=n_vocab,

embedding_dim=self.embedding_dim,

)

self.rnn = nn.RNN(

input_size=self.input_size,

hidden_size=self.hidden_size,

num_layers=self.num_layers,

)

self.fc = nn.Linear(self.hidden_size, n_vocab)

def forward(self, x, prev_state):

embed = self.embedding(x)

output,state = self.rnn(embed, prev_state)

logits = self.fc(output)

return logits,state

def init_state(self, sequence_length):

return (torch.zeros(self.num_layers, sequence_length, self.hidden_size))

3.3.5 定义训练模型函数

为便于管理，这里参数传入采用argparse方式。

def train(dataset, model, args):
    model.train()

    dataloader = DataLoader(
        dataset,
        batch_size=args.batch_size,
    )

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    for epoch in range(args.max_epochs):
        state = model.init_state(args.sequence_length)

        for batch, (x, y) in enumerate(dataloader):

            optimizer.zero_grad()
            
            y_pred, state = model(x, state)
            loss = criterion(y_pred.transpose(1, 2), y)

            state = state.detach()            

            loss.backward()
            optimizer.step()

            print({ 'epoch': epoch, 'batch': batch, 'loss': loss.item() })

def predict(dataset, model, text, next_words=20):
    #words = text.split(' ')
    words = list(text)
    model.eval()

    state= model.init_state(len(words))

    for i in range(0, next_words):
        x = torch.tensor([[dataset.word_to_index[w] for w in words[i:]]])
        y_pred, state = model(x, state)

        last_word_logits = y_pred[0][-1]
        p = torch.nn.functional.softmax(last_word_logits, dim=0).detach().numpy()
        word_index = np.random.choice(len(last_word_logits), p=p)
        words.append(dataset.index_to_word[word_index])

    return "".join(words)

def train(dataset, model, args):

model.train()

dataloader = DataLoader(

dataset,

batch_size=args.batch_size,

)

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(args.max_epochs):

state = model.init_state(args.sequence_length)

for batch, (x, y) in enumerate(dataloader):

optimizer.zero_grad()

y_pred, state = model(x, state)

loss = criterion(y_pred.transpose(1, 2), y)

state = state.detach()

loss.backward()

optimizer.step()

print({ 'epoch': epoch, 'batch': batch, 'loss': loss.item() })

def predict(dataset, model, text, next_words=20):

#words = text.split(' ')

words = list(text)

model.eval()

state= model.init_state(len(words))

for i in range(0, next_words):

x = torch.tensor([[dataset.word_to_index[w] for w in words[i:]]])

y_pred, state = model(x, state)

last_word_logits = y_pred[0][-1]

p = torch.nn.functional.softmax(last_word_logits, dim=0).detach().numpy()

word_index = np.random.choice(len(last_word_logits), p=p)

words.append(dataset.index_to_word[word_index])

return "".join(words)

3.3.6 设置参数

这里参数设置运行环境为jupyter notebook ，如果在命令行运行需要做一些改动。

parser = argparse.ArgumentParser(description='rnn')
parser.add_argument('--max-epochs', type=int, default=20)
parser.add_argument('--batch-size', type=int, default=256)
parser.add_argument('--sequence-length', type=int, default=20)
args = parser.parse_args([])

parser = argparse.ArgumentParser(description='rnn')

parser.add_argument('--max-epochs', type=int, default=20)

parser.add_argument('--batch-size', type=int, default=256)

parser.add_argument('--sequence-length', type=int, default=20)

args = parser.parse_args([])

3.3.7 运行模型

dataset = Dataset(args)
model = Model(dataset)
train(dataset, model, args)
print(predict(dataset, model, text='坚持破除'))

dataset = Dataset(args)

model = Model(dataset)

train(dataset, model, args)

print(predict(dataset, model, text='坚持破除'))

3.3.8 练习

1.把Emedding层改为One-hot层
2.目前学习率为固定，把固定改为动态（如与迭代次数相关关联），查看损失值的变化
3.修改学习率及迭代次数等，比较损失值的变化。
4.使用LSTM或GRU模型
5.使用GPT或BERT模型

3.2 循环神经网络语言模型

神经网络语言模型（NNLM）对统计语言模型而言（如n-gram），前进了一大步。它用词嵌入代替词索引，把词映射到低维向量，用神经网络计算代替词组的统计频率计算，从而有效避免维度灾难、增强了词的表现力和模型的泛化力。不过NNLM除计算效率问题外，主要还是基于n-gram的思想，虽然对n有所扩充，但是本质上仍然是使用神经网络编码的n-gram模型，而且对输入数据要求固定长度(一般取5-10)，这严重影响模型的性能和泛化能力，所以，如何打破n的"桎梏"一直是人们追求的方向。
循环神经网络(RNN)（尤其其改进版本LSTM）序列语言模型的提出，较好的解决了如何学习到长距离的依赖关系的问题，接下来将从多个角度、多个层次详细介绍RNN。

3.2.1 RNN结构

图1-8是循环神经网络的经典结构，从图中可以看到输入x、隐含层、输出层等，这些与传统神经网络类似，不过自循环W却是它的一大特色。这个自循环直观理解就是神经元之间还有关联，这是传统神经网络、卷积神经网络所没有的。

图1-8 循环神经网络的结构
其中U是输入到隐含层的权重矩阵，W是状态到隐含层的权重矩阵，s为状态，V是隐含层到输出层的权重矩阵。图1-8比较抽象，将它展开成图1-9，就更好理解。

图1-9循环神经网络的展开结构
这是一个典型的Elman循环神经网络，从图7-2不难看出，它的共享参数方式是各个时间节点对应的W、U、V都是不变的，这个机制就像卷积神经网络的过滤器机制一样，通过这种方法实现参数共享，同时大大降低参数量。
图1-9中隐含层不够详细，把隐含层再细化就可得图1-10。

图1-10 循环神经网络Cell的结构图
这个网络在每一时间t有相同的网络结构，假设输入x为n维向量，隐含层的神经元个数为m，输出层的神经元个数为r，则U的大小为n×m维；W是上一次的s_(t-1)作为这一次输入的权重矩阵，大小为m×m维；V是连输出层的权重矩阵，大小为m×r维。而x_t、s_t 和o_t 都是向量，它们各自表示的含义如下：
x_t是时刻t的输入；
s_t是时刻t的隐层状态。它是网络的记忆。s_t基于前一时刻的隐层状态和当前时刻的输入进行计算，
函数f通常是非线性的，如tanh或者ReLU。s_(t-1)为前一个时刻的隐藏状态，其初始化通常为0；
o_t是时刻t的输出。例如，如想预测句子的下一个词，它将会是一个词汇表中的概率向量，o_t=softmax(Vs_t)；
s_t认为是网络的记忆状态，s_t可以捕获之前所有时刻发生的信息。输出o_t的计算仅仅依赖于时刻t的记忆。
图1-10是RNN Cell的结构图，我们可以放大这个图，看看其内部结构，如图1-11所示。

图1-11 RNN 的Cell的内部结构
在图1-11中，把隐含状态s_(t-1) （假设为一个4维向量）
和输入x_t（假设为一个3维向量）拼接成一个7维向量，这个7维向量构成全连接神经网络的输入层，输出为4个节点的向量，激活函数为f，输入与输出间的权重矩阵的维度为[7,4]。这样式（1.6）可写成如下形式：

3.2.2 RNNCell代码实现

这里用Python实现（1.8)、（1.9）式，为简便起见，这里不考虑偏移量b。
1、定义激活函数

import numpy as np
#定义sigmoid激活函数
def sigmoid(x):
    return 1/(1+np.exp(-x))

#定义softmax激活函数
def softmax(x):
    # 计算每列的最大值
    column_max = np.max(x)
 
    # 每列元素都需要减去对应的最大值，否则求exp(x)易导致溢出
    exp_x=np.exp(x - column_max)
   
    # 计算softmax
    sum_x = np.sum(exp_x)
    s = exp_x /sum_x
    return s

#创建s及x
x_t,st_1 = np.random.random((1, 3)), np.random.random((1, 4))
#创建权重矩阵
U,W,V = np.random.random((3, 4)), np.random.random((4, 4)),np.random.random((4, 2))

import numpy as np

#定义sigmoid激活函数

def sigmoid(x):

return 1/(1+np.exp(-x))

#定义softmax激活函数

def softmax(x):

# 计算每列的最大值

column_max = np.max(x)

# 每列元素都需要减去对应的最大值，否则求exp(x)易导致溢出

exp_x=np.exp(x - column_max)

# 计算softmax

sum_x = np.sum(exp_x)

s = exp_x /sum_x

return s

#创建s及x

x_t,st_1 = np.random.random((1, 3)), np.random.random((1, 4))

#创建权重矩阵

U,W,V = np.random.random((3, 4)), np.random.random((4, 4)),np.random.random((4, 2))

2、定义状态及输入值，并进行拼接。

#创建s及x
x_t,st_1 = np.random.random((1, 3)), np.random.random((1, 4))
#创建权重矩阵
#创建权重矩阵
U,W,V = np.random.random((3, 4)), np.random.random((4, 4)),np.random.random((4, 2))

#拼接x_t和st_1
xs=np.concatenate((x_t,st_1),axis=1)
#拼接矩阵W和U
WU=np.concatenate((W,U),axis=0)

#创建s及x

x_t,st_1 = np.random.random((1, 3)), np.random.random((1, 4))

#创建权重矩阵

U,W,V = np.random.random((3, 4)), np.random.random((4, 4)),np.random.random((4, 2))

#拼接x_t和st_1

xs=np.concatenate((x_t,st_1),axis=1)

#拼接矩阵W和U

WU=np.concatenate((W,U),axis=0)

3、计算输出值

#计算隐含层的输出值
s_t=sigmoid(np.dot(xs, WU))
#计算输出值
o_t=softmax(np.dot(s_t,V))

#计算隐含层的输出值

s_t=sigmoid(np.dot(xs, WU))

#计算输出值

o_t=softmax(np.dot(s_t,V))

3.2.3 多层RNNCell

上节我们介绍了单个RNN的结构（即RNNCell），有了这个基础之后，我们就可对RNNCell进行拓展。RNN可以横向拓展（增加时间步或序列长度），也可纵向拓展成多层循环神经网络，如图1-12所示。

图1-12多层循环神经网络
图1-12中，序列长度为T，网络层数为3。接下来为帮助大家更好的理解，接下来我们用PyTorch实现一个2层RNN。

3.2.4 多层RNNCell的PyTorch代码实现

Pytorch提供了两个版本的循环神经网络接口，单元版的输入是每个时间步，或循环神经网络的一个循环，而封装版的是一个序列。下面我们从简单的封装版torch.nn.RNN开始,其一般格式为：

torch.nn.RNN( args, * kwargs)

1	torch.nn.RNN( args, * kwargs)

由图7-3 可知，RNN状态输出a_t的计算公式为：

nn.RNN函数中的参数说明如下：
input_size : 输入x的特征数量。
hidden_size : 隐含层的特征数量。
num_layers : RNN的层数。
nonlinearity : 指定非线性函数使用tanh还是relu。默认是tanh。
bias : 如果是False，那么RNN层就不会使用偏置权重 b_i和b_h,默认是True
batch_first : 如果True的话，那么输入Tensor的shape应该是(batch, seq, feature),输出也是这样。默认网络输入是(seq, batch, feature),即序列长度、批次大小、特征维度。
dropout : 如果值非零（该参数取值范围为0~1之间），那么除了最后一层外，其它层的输出都会加上一个dropout层，缺省为零。
bidirectional : 如果True，将会变成一个双向RNN，默认为False。

函数nn.RNN()的输入包括特征及隐含状态，记为(x_t 、h_0),输出包括输出特征及输出隐含状态，记为(output_t 、h_n)。
其中特征值x_t的形状为(seq_len, batch, input_size), h_0的形状为(num_layers * num_directions, batch, hidden_size)，其中num_layers为层数，num_directions方向数，如果取2表示双向(bidirectional,)，取1表示单向。
output_t的形状为(seq_len, batch, num_directions * hidden_size), h_n的形状为(num_layers * num_directions, batch, hidden_size)。
为使大家对循环神经网络有个直观理解，下面先用Pytorch实现简单循环神经网络，然后验证其关键要素。
首先建立一个简单循环神经网络，输入维度为10，隐含状态维度为20，单向两层网络。

rnn = nn.RNN(input_size=10, hidden_size=20,num_layers= 2)

1	rnn = nn.RNN(input_size=10, hidden_size=20,num_layers= 2)

因输入节点与隐含层节点是全连接，根据输入维度、隐含层维度，可以推算出相关权重参数的维度，w_ih应该是20x10，w_hh是20x20, b_ih和b_hh都是hidden_size。以下我们通过查询weight_ih_l0、weight_hh_l0等进行验证。

#第一层相关权重参数形状
print("wih形状{},whh形状{},bih形状{}".format(rnn.weight_ih_l0.shape,rnn.weight_hh_l0.shape,rnn.bias_hh_l0.shape))
#ih形状torch.Size([20, 10]),whh形状torch.Size([20, 20]),bih形状#torch.Size([20])
#第二层相关权重参数形状
print("wih形状{},whh形状{},bih形状{}".format(rnn.weight_ih_l1.shape,rnn.weight_hh_l1.shape,rnn.bias_hh_l1.shape))
# wih形状torch.Size([20, 20]),whh形状torch.Size([20, 20]),bih形状#torch.Size([20])

#第一层相关权重参数形状

print("wih形状{},whh形状{},bih形状{}".format(rnn.weight_ih_l0.shape,rnn.weight_hh_l0.shape,rnn.bias_hh_l0.shape))

#ih形状torch.Size([20, 10]),whh形状torch.Size([20, 20]),bih形状#torch.Size([20])

#第二层相关权重参数形状

print("wih形状{},whh形状{},bih形状{}".format(rnn.weight_ih_l1.shape,rnn.weight_hh_l1.shape,rnn.bias_hh_l1.shape))

# wih形状torch.Size([20, 20]),whh形状torch.Size([20, 20]),bih形状#torch.Size([20])

RNN网络已搭建好，接下来将输入(x_t 、h_0)传入网络，根据网络配置及网络要求，我们生成输入数据。输入特征长度为100，批量大小为32，特征维度为10的张量。隐含状态按网络要求，其形状为(2,32,20)。

#生成输入数据
input=torch.randn(100,32,10)
h_0=torch.randn(2,32,20)

#生成输入数据

input=torch.randn(100,32,10)

h_0=torch.randn(2,32,20)

将输入数据传入RNN网络,将得到输出及更新后隐含状态值。根据以上规则，输出output的形状应该是（100,32,20），隐含状态的输出形状应该与输入的形状一致。

output,h_n=rnn(input,h_0)
print(output.shape,h_n.shape)
#torch.Size([100, 32, 20]) torch.Size([2, 32, 20])

output,h_n=rnn(input,h_0)

print(output.shape,h_n.shape)

#torch.Size([100, 32, 20]) torch.Size([2, 32, 20])

其结果与我们设想的完全一致。

3 神经网络语言模型

　　n-gram语言模型简单明了，解释性较好，但有几个较大缺陷：
1、维度灾难，随着n值越大，单词组合数指数级增长，由此带来相关联合或条件概率大量为0；
2、因n一般不能超过3或4，这影响模型利用单词更多邻居信息；
3、n-gram使用单词组合的频度作为计算基础，这需要提前计算，且无法泛化到相似语句或相似单词的情况。
接下来将介绍的神经网络语言模型（NNLM），可有效避免n-gram的这些不足，NNLM使用哪些方法或技术来解决这些问题的呢？请看下节内容。

3.1 神经网络语言模型

　　Yoshua Bengio团队在2003年在论文《A Neural Probabilistic Language Model》中提出神经网络语言模型（NNLM），可以说是后续神经网络语言模型的鼻祖，其创新点有以下几点，这些亮点也是它避免n-gram模型不足的重要方法。
1、使用词嵌入(word Embedding)代替单词索引；
2、使用神经网络计算概率
当然，这个NNLM还有很多不足，其中整个模型因使用softmax，tanh等激活函数，在面对较大的语料库时（如词汇量在几万、几百万、甚至更多）计时效率很低，而且模型有点繁琐不够简练，后续我们将介绍一些改进模型。

3.1.1 神经网络语言模型（NNLM）

Yoshua Bengio团队提出的这个NNLM的架构图1-2所示。

图1-2 神经网络架构
假设该模型训练的语料库的词汇量为|V|，语料库中每个单词w_i转换成词向量的大小维度为m。把每个单词w_i转换为词嵌入的矩阵为C，其形状为|V|xm。其过程如图1-3所示。

图1-3 通过矩阵C把词索引转换为词嵌入

整个网络架构用表达式表示：
y=b+Wx+U tanh(d+Hx)
其中Wx表示输入层与输出层有直接联系（图1-2中的虚线部分），如果不要这个链接，直接设置W为0即可，b是输出层的偏置向量，d是隐层的偏置向量，里面的x即是单词到特征向量的映射，计算如下：
x=(C(w_(t-1) ),C(w_(t-2) ),⋯,C(w_(t-n+1)))
其中C是一个矩阵，其形状为|V|xm
假设隐层的神经元个数为h，那么整个模型的参数可以细化为θ = (b, d, W, U, H, C)。下面各参数含义及形状：
b是词向量x到输出层的偏移量，维度为|V|
W是词向量x到输出层的权重矩阵，维度为|V|x(n−1)m
d是隐含层的偏移量，维度为h
H是输入x到隐含层的权重矩阵，形状为hx(n-1)m
U是隐含层到输出层的权重矩阵，形状为|V|xh

网络的第一层(输入层)是将C(w_(t-1) ),C(w_(t-2) ),⋯,C(w_(t-n+1))这已知的n-1和单词的词向量首尾相连拼接起来，形成(n-1)m的向量x。
网络的第二层(隐藏层)直接用d+Hx计算得到，d是一个偏置项。之后，用tanh作为激活函数。
网络的第三层(输出层)一共有|V|个节点，最后使用softmax函数将输出值y归一化成概率。
最后，用随机梯度下降法把这个模型优化出来就可以了。

3.1.2 NNLM的PyTorch实现

这样用一个简单实例，实现3.1.1节的计算过程。
1、导入需要的库或模块

import torch
import torch.nn as nn
import torch.optim as optim
import jieba

import torch

import torch.nn as nn

import torch.optim as optim

import jieba

2、定义语料库及预处理函数

#定义一个简单语料库
sentences = [ "我喜欢苹果", "我爱运动", "我讨厌老鼠"]

#预处理语料库，得到批量数据
def make_batch(sentences):
    input_batch = []
    target_batch = []

    for sen in sentences:
        word = list(jieba.cut(sen)) #对每句话进行中文分词
        input = [word_dict[n] for n in word[:-1]] # 创建(1至n-1) 作为输入，这里实际上就是取前两个词。
        target = word_dict[word[-1]] # 这里把每句的最后一个词作为目标, 

        input_batch.append(input)
        target_batch.append(target)

    return input_batch, target_batch

#定义一个简单语料库

sentences = [ "我喜欢苹果", "我爱运动", "我讨厌老鼠"]

#预处理语料库，得到批量数据

def make_batch(sentences):

input_batch = []

target_batch = []

for sen in sentences:

word = list(jieba.cut(sen)) #对每句话进行中文分词

input = [word_dict[n] for n in word[:-1]] # 创建(1至n-1) 作为输入，这里实际上就是取前两个词。

target = word_dict[word[-1]] # 这里把每句的最后一个词作为目标,

input_batch.append(input)

target_batch.append(target)

return input_batch, target_batch

3、构建模型

# Model
class NNLM(nn.Module):
    def __init__(self):
        super(NNLM, self).__init__()
        self.C = nn.Embedding(n_class, m)
        self.H = nn.Linear(n_step * m, n_hidden, bias=False)
        self.d = nn.Parameter(torch.ones(n_hidden))
        self.U = nn.Linear(n_hidden, n_class, bias=False)
        self.W = nn.Linear(n_step * m, n_class, bias=False)
        self.b = nn.Parameter(torch.ones(n_class))

    def forward(self, X):
        X = self.C(X) # X : [batch_size, n_step, n_class]
        X = X.view(-1, n_step * m) # [batch_size, n_step * n_class]，对应x
        tanh = torch.tanh(self.d + self.H(X)) # [batch_size, n_hidden]
        output = self.b + self.W(X) + self.U(tanh) # [batch_size, n_class]，对应y
        return output

# Model

class NNLM(nn.Module):

def __init__(self):

super(NNLM, self).__init__()

self.C = nn.Embedding(n_class, m)

self.H = nn.Linear(n_step * m, n_hidden, bias=False)

self.d = nn.Parameter(torch.ones(n_hidden))

self.U = nn.Linear(n_hidden, n_class, bias=False)

self.W = nn.Linear(n_step * m, n_class, bias=False)

self.b = nn.Parameter(torch.ones(n_class))

def forward(self, X):

X = self.C(X) # X : [batch_size, n_step, n_class]

X = X.view(-1, n_step * m) # [batch_size, n_step * n_class]，对应x

tanh = torch.tanh(self.d + self.H(X)) # [batch_size, n_hidden]

output = self.b + self.W(X) + self.U(tanh) # [batch_size, n_class]，对应y

return output

4、训练模型

if __name__ == '__main__':
    n_step = 2 # 对应n-gram中n-1值
    n_hidden = 2 #对应隐含层的节点数h
    m = 2 #对应于m的值

    words_list=[]
    for sen in sentences:
        a=list(jieba.cut(sen))    
        words_list.extend(a)
    words_list=list(set(words_list))
    word_dict = {w: i for i, w in enumerate(words_list)}
    number_dict = {i: w for i, w in enumerate(words_list)}
    n_class = len(word_dict)  # 语料库中词汇量，相当与|V|

    model = NNLM()

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=0.001)

    input_batch, target_batch = make_batch(sentences)
    input_batch = torch.LongTensor(input_batch)
    target_batch = torch.LongTensor(target_batch)

    # Training
    for epoch in range(5000):
        optimizer.zero_grad()
        output = model(input_batch)

        # output : [batch_size, n_class], target_batch : [batch_size]
        loss = criterion(output, target_batch)
        if (epoch + 1) % 1000 == 0:
            print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))

        loss.backward()
        optimizer.step()
        
    #print(model.H.weight)  #查看H训练后的权重
    # 预测
    predict = model(input_batch).data.max(1, keepdim=True)[1]

    # 测试
    print([sen.split()[:2] for sen in sentences], '->', [number_dict[n.item()] for n in predict.squeeze()])

if __name__ == '__main__':

n_step = 2 # 对应n-gram中n-1值

n_hidden = 2 #对应隐含层的节点数h

m = 2 #对应于m的值

words_list=[]

for sen in sentences:

a=list(jieba.cut(sen))

words_list.extend(a)

words_list=list(set(words_list))

word_dict = {w: i for i, w in enumerate(words_list)}

number_dict = {i: w for i, w in enumerate(words_list)}

n_class = len(word_dict) # 语料库中词汇量，相当与|V|

model = NNLM()

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=0.001)

input_batch, target_batch = make_batch(sentences)

input_batch = torch.LongTensor(input_batch)

target_batch = torch.LongTensor(target_batch)

# Training

for epoch in range(5000):

optimizer.zero_grad()

output = model(input_batch)

# output : [batch_size, n_class], target_batch : [batch_size]

loss = criterion(output, target_batch)

if (epoch + 1) % 1000 == 0:

print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))

loss.backward()

optimizer.step()

#print(model.H.weight) #查看H训练后的权重

# 预测

predict = model(input_batch).data.max(1, keepdim=True)[1]

# 测试

print([sen.split()[:2] for sen in sentences], '->', [number_dict[n.item()] for n in predict.squeeze()])

5、运行结果
Epoch: 1000 cost = 0.113229
Epoch: 2000 cost = 0.015353
Epoch: 3000 cost = 0.004546
Epoch: 4000 cost = 0.001836
Epoch: 5000 cost = 0.000853
[['我喜欢苹果'], ['我爱运动'], ['我讨厌老鼠']] -> ['苹果', '运动', '老鼠']

3.1.3词嵌入特征

　　在NNLM语言模型中，通过神经网络的线性/非线性转换以及激活函数（例如softmax）得到似然条件概率值。同时因为保存了隐层的系数矩阵，因此可以得到每个文本序列以及每个词的词嵌入（Word Embedding）。词嵌入一般通过神经网络能学习语料库中的一些特性或知识，如捕获词之间的多种相似性。图1-4为在某语料库上训练得到的一个简单词嵌入矩阵，从这个特征我们可以看出，有些词是相近的，如男与女，国王与王后，苹果与橘子等，这些相似性是从语料库学习得到。如何从语料库中学习这些特征或知识？人们研究出多种有效方法，其中最著名的就是Word2vec。
另外我们可以把词嵌入这些特性，通过迁移方法，应用到下游项目中。

图1-4 词嵌入特征示意图
与从语料库中学习词嵌入类似，在视觉处理领域中，也是通过学习图像，把图像特征转换为编码，整个过程如下图1-5所示。只不过在视觉处理中我们一般不把学到的向量为词嵌入，而往往称之为编码。

图1-5 把图像转换为编码示意图

3.1.4 word2vec简介

　　词嵌入（word Embedding）最早由 Hinton 于 1986 年提出的，可以克服独热表示的缺点。解决词汇与位置无关问题，可以通过计算向量之间的距离（欧式距离、余弦距离等）来体现词与词的相似性。其基本想法是直接用一个普通的向量表示一个词，此向量为：
[0.792, -0.177, -0.107, 0.109, -0.542, ...]，常见维度50或100。用这种方式表示的向量，“麦克”和“话筒”的距离会远远小于“麦克”和“天气”的距离。
词嵌入表示的优点是解决了词汇与位置无关问题，不足是学习过程相对复杂且受训练语料的影响很大。训练这种向量表示的方法较多，常见的有LSA、PLSA、LDA、Word2Vec等，其中Word2Vec是Google在2013年开源的一个工具，Word2Vec是一款用于词向量计算的工具，同时也是一套生成词向量的算法方案。Word2Vec算法的背后是一个浅层神经网络，其网络深度仅为3层，所以，严格说Word2Vec并非深度学习范畴。但其生成的词向量在很多任务中都可以作为深度学习算法的输入，因此，在一定程度上可以说Word2Vec技术是深度学习在NLP领域的基础。训练Word2Vec主要有以下两种模型来训练得到：
1、CBOW模型
CBOW模型包含三层，输入层、映射层和输出层。其架构如图1-6。CBOW模型中的w(t)为目标词，在已知它的上下文w(t-2)，w(t-1)，w(t+1)，w(t+2)的前提下预测词w(t)出现的概率，即：p(w/context(w))。目标函数为：

图1-6 CBOW模型
CBOW模型训练其实就是根据某个词前后若干词来预测该词，这其实可以看成是多分类。最朴素的想法就是直接使用softmax来分别计算每个词对应的归一化的概率。但对于动辄十几万词汇量的场景中使用softmax计算量太大，于是需要用一种二分类组合形式的hierarchical softmax，即输出层为一棵二叉树。
2、Skip-gram模型
Skip-gram模型同样包含三层，输入层，映射层和输出层。其架构如图1-7。Skip-Gram模型中的w(t)为输入词,在已知词w(t)的前提下预测词w(t)的上下文w(t-2)，w(t-1)，w(t+1)，w(t+2)，条件概率写为：p(context(w)/w)。目标函数为：

图1-7 Skip-gram模型

1.序列建模概述

卷积神经网络（CNN）善于处理网格化数据，如图像、视频等，虽然也可处理序列化数据，但应该不是它的强项，因序列化数据往往长短不一，而且序列数据往往与数据的前后位置有关，如我们经常看到的文本就是典型的序列数据。
如何对序列数据构建模型？早期通常采用统计语言模型（），统计语言模型的计算使用链式法则，把联合概率转换为条件概率，但随着序列长度的增长，其复杂度会指数级增长，为简化统计语言模型的计算，人们利用马尔科夫假设，这个假设的内容是：任何一个词出现的概率只和它前面的 1 个或若干个词有关。基于这个假设，人们提出n元语法（n -gram）模型。n -gram中的“n”很重要，它表示任何一个词出现的概率，只和它前面的 n-1 个词有关。
n元语法（ n -gram），时间步t的词wt基于前面所有词的条件概率只考虑了最近时间步的n−1个词。如果要考虑比t−(n−1)更早时间步的词对wt的可能影响，我们需要增大n。但这样模型参数的数量将随之呈指数级增长，而一个词的语义往往跟比较长，为此，必须另辟蹊径。
n-gram 的优点有很多，首先它是一种直观的自然语言理解与处理方式，对参数空间进行了优化，并具有很强的解释性。它包含前 n-1 个词的全部信息，不会产生丢失和遗忘。除此以外，它还具有计算逻辑简单的优点。
但与此同时，n-gram 也具有本质上的缺陷：n-gram 无法建立长期依赖，当 n 过大时仍会被数据的稀疏性严重影响，实际使用中往往仅使用 bigram 或 trigram；n-gram 基于频次进行统计，没有足够的泛化能力。因此，神经网络语言模型逐渐取代传统的统计自然语言模型成为主流，接下来我们对神经网络语言模型进行介绍。
首先实现这个转换的就是AI大咖Bengio ，在2003年发表在JMLR上发表了题为《A Neural Probabilistic Language Model》论文，在这篇具有开创性的论文中，有两个对NLP影响深远的创新点。一个是词向量，另一个是使用神经网络实现条件概率的计算。
不过Bengio提出的这个神经网络语言模型(NNLM)，主要是实现和优化n-gram模型，除计算效率不高外，对序列基于固定长度，这点严重限制了NNLM的进一步发展。为解决长度可变及实现更长记忆，人们利用循环神经网络（RNN）来解决序列数据建模问题。利用循环神经网络无需刚性地记忆所有固定长度的序列，而是通过隐藏状态来存储（或记忆）之前时间步的信息，当然，由于RNN存在梯度消失问题，这种记忆一般是短时的，无法记忆较长的依赖关系，这点严重影响模型的性能。
解决长距离记忆问题，人们又提出一种RNN的几种改进模型，如LSTM模型、GRU模型等，这些模型中隐含状态的生成不像RNN一次性生成方法隐含状态，而是在原来内容的基础上添加一些新的内容。
虽然LSTM解决了序列模型的长距离依赖问题，但其计算只能严格从左到到右，或从右到左，无法实现并发处理。当前为了提升模型性能所要求的语料库也愈来愈大，这严重影响计算效率。
为了解决计算效率和长期依赖问题，最近人们又提出Transformer架构，使用这种架构既可解决长期依赖问题，又可很好的使用并发处理，从而极大提升模型性能及训练效率。在Transformer的基础上，人们提出了GPT、BERT、T5等预训练模型。这些模型在NLP领域打破了很多历史记录。
这里我们对序列建模的历史做了一个简单介绍，不涉及很多细节，接下来从业务场景、模型分解、可视化模型、模型拓展、模型实现等多个角度、多种方式、多个层次分别进行说明。

2统计语言模型

2.1统计语言模型

统计语言模型从统计的角度预测标记序列的概率分布，根据模型的设计，标记可以是词、字符等，这里我们以标记为词为例，对于句子ω_1,ω_2,⋯,ω_n的概率p(ω_1,ω_2⋯ω_n )，根据概率的链式法则，可求导整个句子的概率：
p(ω_1,ω_2⋯ω_n )=p(ω_1 )p(ω_2 |ω_1)p(ω_3 |ω_1,ω_2)⋯p(ω_n |ω_1,⋯ω_(n-1)) （1.1）
如何计算p(ω_n |ω_1,⋯ω_(n-1))？根据大数定律，该条件概率可利用极大似然估计来计算。
即，p(ω_n│ω_1,⋯ω_(n-1) )=(C(ω_1,⋯ω_(n-1),ω_n))/(C(ω_1,⋯ω_(n-1))) （1.2）
其中，C(.)表示子序列在语料库或数据集上的出现的次数。
这种计算方法存在两个致命的缺陷：一个缺陷是参数空间过大；另外一个缺陷是数据稀疏严重，长序列出现的频率非常低。
为了解决这个问题，通常引入了马尔科夫假设：一个词的出现仅仅依赖于它前面1个或有限的几个词，这就是接下来将介绍的n-gram模型。

2.2 n-gram模型

n-gram 是最为普遍的统计语言模型。它的基本思想是将文本里面的内容进行大小为 n 的滑动窗口操作，形成长度为 n 的短语子序列，利用最大似然估计，把条件概率的计算转换为对所有短语子序列的出现频度的计算。直观上理解，n-gram 就是将句子长度缩短为只考虑前 n-1 个词。
如果一个词的出现不依赖于它前面的词，即句子中各词为相互独立，那么我们就称之为一元语法(或unigram)，式（1.1）可表示为：
p(ω_1,ω_2⋯ω_n )=p(ω_1 )p(ω_2)p(ω_3)⋯p(ω_n)
如果一个词的出现仅依赖于它前面一个词，那么我们就称之为二元语法(或bigram)。式（1.1）可表示为：
p(ω_1,ω_2⋯ω_n )=p(ω_1 )p(ω_2 |ω_1)p(ω_3 |ω_2)⋯p(ω_n |ω_(n-1))
如果一个词的出现仅依赖于它前面出现的两个词，那么我们就称之为三元语法（或trigram）。式（1.1）可表示为：
p(ω_1,ω_2⋯ω_n )=p(ω_1 )p(ω_2 |ω_1)p(ω_3 |〖ω_1,ω〗_2)⋯p(ω_n |〖ω_(n-2),ω〗_(n-1))
在实践中用的最多的就是bigram和trigram了，而且效果很不错。高于四元的用的较少，因为训练它需要更庞大的语料，而且数据稀疏严重，时间复杂度高，精度却提高的不多。
这里举一个小数量的例子进行辅助说明：假设我们有一个语料库，如下：

<s>表示一个语句的开始，</s>表示一个语句的结束。
想要预测“我喜欢”这一句话的下一个字。我们分别通过 trigram 进行预测
通过 trigram，便是要对 P(w | 我喜欢)进行计算，经统计，“我喜欢她”出现了2次，“我喜欢车”出现了1次，通过最大似然估计可以求得P（她|我喜欢）=2/3，P（车|我喜欢）=1/3，因此我们通过 bigram 预测出的整句话为: 我喜欢她

随着n的提升，我们拥有了更多的前置信息量，可以更加准确地预测下一个词。但这也带来了一个问题，数据随着n的提升变得更加稀疏了，导致很多预测概率结果为0。当遇到零概率问题时，我们可以通过平滑来缓解 n-gram 的稀疏问题。

2.3 n-gram的简单应用

搜索引擎（Baidu或者Google）、或者输入法的猜想或者提示。你在用百度时，输入一个或几个词，搜索框通常会以下拉菜单的形式给出几个像下图1-1一样的备选内容，这些备选内容其实是在猜想你想要搜索的那个词串。

图1-1 在百度输入关键字
图1-1中出现的词串（或短语）的排序，通过上面的介绍，你或许已发现，这其实是以n-gram模型为基础来实现的。

3 神经语言模型

3.2 循环神经网络语言模型

3.2.1 RNNCell架构
3.2.2 RNNCell代码实现
3.2.3 多层RNNCell
3.2.4 多层RNNCell代码实现

3.3 RNN生成文本实例

3.4 优化RNN

3.4.1 LSTMCELL
3.4.2 LSTMCell代码实现
3.4.3 多层LSTMCell结构
3.4.4 多层LSTMCell代码实现
3.4.5 LSTM架构
3.4.6 LSTM代码实现
3.4.7 biRNN

4 RNN应用实例（即将完成）

5 RNN拓展（即将完成）

5.1 ELMO
5.2 Encoder-Decoder
5.2 Attention and self-Attention
5.3 Transformer简介
5.4 BERT简介
5.5 GPT简介

BERT以Transformer的Encoder为架构，已MLM为模型，在很多领域取得历史性的的突破。这里以Transformers上基于中文语料库上训练的预训练模型bert-base-chinese为模型，以BertForSequenceClassification为下游任务模型，在一个中文数据集上进行语句分类。具体包括如下内容：
 使用BERT的分词库Tokenizer
 可视化BERT注意力权重
 用BERT预训练模型微调下游任务
 训练模型

14.1 背景说明

本章用到预训练模型库Transformers，Transformers为自然语言理解（NLU）和自然语言生成（NLG）提供了最先进的通用架构（BERT、GPT、GPT-2、Transformer-XL、XLNET、XLM、T5等等），其中有超过32个100多种语言的预训练模型并同时支持TensorFlow 2.0和Pythorch1.0两大深度学习框架。可用pip安装Transformers。

pip install transformers

1	pip install transformers

Transformers的官网：https://github.com/huggingface
这章使用BERT模型中汉语版本：BERT-Base, Chinese: 包括简体和繁体汉字，共12层，768个隐单元，12个Attention head，110M参数。中文 BERT 的字典大小约有 2.1 万个标识符(tokens)，这些预训练模型可以从Transformers官网下载。
使用了可视化工具BertViz，它的安装步骤如下：
1.下载bertviz：
https://github.com/jessevig/bertviz
2.解压到jupyter notebook当前目录下
bertviz-master

14.1.1 查看中文BERT字典里的一些信息

1.导入需要的库
指定使用预训练模型bert-base-chinese。

import torch
from transformers import BertTokenizer
from IPython.display import clear_output

# 指定繁简中文 BERT-BASE预训练模型
PRETRAINED_MODEL_NAME = "bert-base-chinese"  
# 获取预测模型所使用的tokenizer
tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)

import torch

from transformers import BertTokenizer

from IPython.display import clear_output

# 指定繁简中文 BERT-BASE预训练模型

PRETRAINED_MODEL_NAME = "bert-base-chinese"

# 获取预测模型所使用的tokenizer

tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)

2. 查看tokenizer的信息

vocab = tokenizer.vocab
print("字典大小：", len(vocab))

1 2	vocab = tokenizer.vocab print("字典大小：", len(vocab))

运行结果：
字典大小： 21128
3.查看分词的一些信息

import random
random_tokens = random.sample(list(vocab), 5)
random_ids = [vocab[t] for t in random_tokens]

print("{0:20}{1:15}".format("token", "index"))
print("-" * 30)
for t, id in zip(random_tokens, random_ids):
    print("{0:15}{1:10}".format(t, id))

import random

random_tokens = random.sample(list(vocab), 5)

random_ids = [vocab[t] for t in random_tokens]

print("{0:20}{1:15}".format("token", "index"))

print("-" * 30)

for t, id in zip(random_tokens, random_ids):

print("{0:15}{1:10}".format(t, id))

运行结果：
token index
------------------------------
##san 10978
王 4374
##and 9369
蚀 6008
60 8183

BERT 使用当初 Google NMT 提出的 WordPiece Tokenization ，将本来的 words 拆成更小粒度的 wordpieces，有效处理不在字典里头的词汇。中文的话大致上就像是 character-level tokenization，而有 ## 前缀的 tokens 即为 wordpieces。
除了一般的wordpieces以外，BERT还有5个特殊tokens：
 [CLS]：在做分类任务时其最后一层的表示.会被视为整个输入序列的表示；
 [SEP]：有两个句子的文本会被串接成一个输入序列，并在两句之间插入这个token作为分割；
 [UNK]：没出现在BERT字典里头的字会被这个token取代；
 [PAD]:zero padding掩码，将长度不一的输入序列补齐方便做batch运算；
 [MASK]：未知掩码，仅在预训练阶段会用到。

14.1.2 使用Tokenizer分割中文语句

让我们利用中文BERT的tokenizer将一个中文句子断词。

text = "[CLS] 他移开这[MASK]桌子，就看到他的手表了。"
tokens = tokenizer.tokenize(text)
ids = tokenizer.convert_tokens_to_ids(tokens)

print(text)
print(tokens[:10], '...')
print(ids[:10], '...')

text = "[CLS] 他移开这[MASK]桌子，就看到他的手表了。"

tokens = tokenizer.tokenize(text)

ids = tokenizer.convert_tokens_to_ids(tokens)

print(text)

print(tokens[:10], '...')

print(ids[:10], '...')

运行结果：
[CLS] 他移开这[MASK]桌子，就看到他的手表了。
['[CLS]', '他', '移', '开', '这', '[MASK]', '桌', '子', '，', '就'] ...
[101, 800, 4919, 2458, 6821, 103, 3430, 2094, 8024, 2218] ...

14.2 可视化BERT注意力权重

现在马上让我们看看给定上面有 [MASK] 的句子，BERT会填入什么字。

14.2.1 BERT对MAKS字的预测

"""
导入已训练好的masked语言模型并对有[MASK]的句子做预测
"""
from transformers import BertForMaskedLM

# 除了tokens 以外我们还需要辨別句子的segment ids
tokens_tensor = torch.tensor([ids])  # (1, seq_len)
segments_tensors = torch.zeros_like(tokens_tensor)  # (1, seq_len)
maskedLM_model = BertForMaskedLM.from_pretrained(PRETRAINED_MODEL_NAME)
clear_output()

# 使用masked LM 估计[MASK]位置所代表的实际标识符(token)
maskedLM_model.eval()
with torch.no_grad():
    outputs = maskedLM_model(tokens_tensor, segments_tensors)
    predictions = outputs[0]
    # (1, seq_len, num_hidden_units)
del maskedLM_model

# 将[MASK]位置的概率分布取前k个最有可能的标识符出来
masked_index = 5
k = 3
probs, indices = torch.topk(torch.softmax(predictions[0, masked_index], -1), k)
predicted_tokens = tokenizer.convert_ids_to_tokens(indices.tolist())

# 显示前k个最可能的字。一般取第一个作为预测值
print("輸入 tokens ：", tokens[:10], '...')
print('-' * 50)
for i, (t, p) in enumerate(zip(predicted_tokens, probs), 1):
    tokens[masked_index] = t
    print("Top {} ({:2}%)：{}".format(i, int(p.item() * 100), tokens[:10]), '...')

"""

导入已训练好的masked语言模型并对有[MASK]的句子做预测

"""

from transformers import BertForMaskedLM

# 除了tokens 以外我们还需要辨別句子的segment ids

tokens_tensor = torch.tensor([ids]) # (1, seq_len)

segments_tensors = torch.zeros_like(tokens_tensor) # (1, seq_len)

maskedLM_model = BertForMaskedLM.from_pretrained(PRETRAINED_MODEL_NAME)

clear_output()

# 使用masked LM 估计[MASK]位置所代表的实际标识符(token)

maskedLM_model.eval()

with torch.no_grad():

outputs = maskedLM_model(tokens_tensor, segments_tensors)

predictions = outputs[0]

# (1, seq_len, num_hidden_units)

del maskedLM_model

# 将[MASK]位置的概率分布取前k个最有可能的标识符出来

masked_index = 5

k = 3

probs, indices = torch.topk(torch.softmax(predictions[0, masked_index], -1), k)

predicted_tokens = tokenizer.convert_ids_to_tokens(indices.tolist())

# 显示前k个最可能的字。一般取第一个作为预测值

print("輸入 tokens ：", tokens[:10], '...')

print('-' * 50)

for i, (t, p) in enumerate(zip(predicted_tokens, probs), 1):

tokens[masked_index] = t

print("Top {} ({:2}%)：{}".format(i, int(p.item() * 100), tokens[:10]), '...')

运行结果：
輸入 tokens ： ['[CLS]', '他', '移', '开', '这', '[MASK]', '桌', '子', '，', '就'] ...
--------------------------------------------------
Top 1 (83%)：['[CLS]', '他', '移', '开', '这', '张', '桌', '子', '，', '就'] ...
Top 2 ( 7%)：['[CLS]', '他', '移', '开', '这', '个', '桌', '子', '，', '就'] ...
Top 3 ( 0%)：['[CLS]', '他', '移', '开', '这', '间', '桌', '子', '，', '就'] ...

BERT透过关注这桌这两个字，从2万多个wordpieces的可能性中选出"张"作为这个情境下[MASK] token的预测值，效果还是不错的。

14.2.2 导入可视化需要的库

1.导入需要的库

from transformers import BertTokenizer, BertModel
from bertv_master.bertviz import head_view

1 2	from transformers import BertTokenizer, BertModel from bertv_master.bertviz import head_view

2.创建可视化使用html配置函数

# 在 jupyter notebook 显示visualzation 
def call_html():
  import IPython
  display(IPython.core.display.HTML('''<script src="/static/components/requirejs/require.js"></script><script>// <![CDATA[
requirejs.config({ paths: { base: '/static/base', "d3": "https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.8/d3.min", jquery: '//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min', }, });
// ]]></script>'''))

# 在 jupyter notebook 显示visualzation

def call_html():

import IPython

display(IPython.core.display.HTML('''<script src="/static/components/requirejs/require.js"></script><script>// <![CDATA[

requirejs.config({ paths: { base: '/static/base', "d3": "https://cdnjs.cloudflare.com/ajax/libs/d3/3.5.8/d3.min", jquery: '//ajax.googleapis.com/ajax/libs/jquery/2.0.0/jquery.min', }, });

// ]]></script>'''))

14.2.3 可视化

# 記得我们是使用中文 BERT
model_version = 'bert-base-chinese'
model = BertModel.from_pretrained(model_version, output_attentions=True)
tokenizer = BertTokenizer.from_pretrained(model_version)

# 情境 1 的句子
sentence_a = "老爸叫小宏去买酱油，"
sentence_b = "回来慢了就骂他。"

# 得到tokens后输入BERT模型获取注意力权重(attention)
inputs = tokenizer.encode_plus(sentence_a,sentence_b,return_tensors='pt', add_special_tokens=True)
token_type_ids = inputs['token_type_ids']
input_ids = inputs['input_ids']
attention = model(input_ids, token_type_ids=token_type_ids)[-1]
input_id_list = input_ids[0].tolist() # Batch index 0
tokens = tokenizer.convert_ids_to_tokens(input_id_list)
call_html()

# 用BertViz可视化
head_view(attention, tokens)

# 記得我们是使用中文 BERT

model_version = 'bert-base-chinese'

model = BertModel.from_pretrained(model_version, output_attentions=True)

tokenizer = BertTokenizer.from_pretrained(model_version)

# 情境 1 的句子

sentence_a = "老爸叫小宏去买酱油，"

sentence_b = "回来慢了就骂他。"

# 得到tokens后输入BERT模型获取注意力权重(attention)

inputs = tokenizer.encode_plus(sentence_a,sentence_b,return_tensors='pt', add_special_tokens=True)

token_type_ids = inputs['token_type_ids']

input_ids = inputs['input_ids']

attention = model(input_ids, token_type_ids=token_type_ids)[-1]

input_id_list = input_ids[0].tolist() # Batch index 0

tokens = tokenizer.convert_ids_to_tokens(input_id_list)

call_html()

# 用BertViz可视化

head_view(attention, tokens)

运行结果：

图14-1 某词对其它词注意力权重示意图
这是BERT第 10 层 Encoder block 其中一个 head 的注意力结果,从改图可以看出，左边的这个他对右边的“宏”字关注度较高。

自己动手做大数据系统（第2版）

作者：飞谷云团队

编写时间：2020年2月（武汉加油、共克时艰）

交流QQ群：50926571

（镜像文件下载小程序）

前言

为帮助读者更好地阅读和理解《自己动手做大数据系统》（第二版）中的实操部分，本文档主要讲解了如何使用Docker容器集群来运行书中的演示程序。容器集群共包括12个实例

镜像名称	功能	运行服务名
flink_single	Flink单节点服务	StandaloneSessionClusterEntrypoint TaskManagerRunner
hbase-master	Hadoop、HBase、Spark集群主节点服务 HBaseThriftServer服务 SparkThriftServer服务演示程序Flask服务	NameNode SecondaryNameNode HRegionServer ThriftServer Master ResourceManager SparkSubmit HMaster
hbase-slave1	Hadoop、HBase、Spark集群从节点服务	HMaster --backup HRegionServer NodeManager DataNode CoarseGrainedExecutorBackend Worker
hbase-slave2	Hadoop、HBase、Spark集群从节点服务 Hive metestore服务	上同hbase-slave1节点多出来一个HiveMetaStore
kafka_single	使用本机ZooKeeper服务的单节点Kafka Broker服务	QuorumPeerMain Kafka
mysql	存储Hive元数据和演示程序数据的MySQL数据库	mysqld
redis	单节点Redis数据库	redis-server
slave01	运行模拟站点2的Apache服务收集本机web访问日志的flume agent服务	apache2 flume-ng
slave02	运行模拟站点1的Apache服务收集本机web访问日志的flume agent服务	apache2 flume-ng
zoo1	为HBase提供ZooKeeper服务的集群	QuorumPeerMain
zoo2		QuorumPeerMain
zoo3		QuorumPeerMain

注意：

阅读本文档假设你已经掌握了简单的Docker操作知识。
本镜像文件只是保证书中演示项目正常运行，并没有包含书中全部章节的演示代码内容。
本镜像文件中各个组件的配置文件不具有通用性，不要直接用于任何生产环境。
由于Docker容器的特性限制，集群中任何一个节点上新增或修改文件后，Docker容器重启后都会还原成初始状态。请特别注意！！
宿主机上的/root/feiguyun_book2/volume目录下的hadoop、hbase、mysql、spark、zk这5个目录不要做任何改动，不要删除这5个目录，也不要删除或添加目录中的任何内容。
宿主机上的/root/feiguyun_book2/volume/code目录映射到镜像节点hbase-master的/code目录，存放在code目录下的内容在Docker容器重启后不会丢失。

第一章 Docker环境安装和容器启动

一、选择宿主机操作系统

宿主机系统选用CentOS 6.10或7.x，或者是Ubuntu 18.04 LTS。本文档使用的是CentOS 7.6版本。在宿主机上统一使用root用户完成Docker镜像安装。以下命令查看OS版本号。

cat /etc/centos-release

CentOS Linux release 7.6.1810 (Core)

读者也可以在windows平台上先安装CentOS 的虚拟机，在虚拟机中运行Docker。本安装文档就是在虚拟机中测试完成的。无论使用实体机还是虚拟机作为宿主机，硬件资源最低需要硬盘为50G，内存为12G。

二、修改yum源

由于在安装docker服务时会先安装一些前置工具，可以把CentOS的yum源改成国内的。具体方法可参考网上资料。（https://www.cnblogs.com/wdjsbk/p/9629931.html）

三、在宿主机上安装Docker服务

依次运行以下命令

3-1. yum install -y yum-utils device-mapper-persistent-data lvm2

3-2. yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

3-3. yum makecache fast

3-4. rpm --import https://mirrors.aliyun.com/docker-ce/linux/centos/gpg

四、安装docker-ce服务

4-1. yum install docker-ce

4-2. usermod -aG docker $(whoami)

4-3. systemctl enable docker.service

4-4. systemctl start docker.service

五、在宿主机上安装docker-compose服务

5-1. yum install epel-release -y

5-2. yum install -y python-pip

5-3. python -m pip install --upgrade pip -i https://pypi.douban.com/simple

5-4. pip --version

pip 20.0.2 from /usr/lib/python2.7/site-packages/pip (python 2.7)

5-5. yum install python-devel

5-6. yum groupinstall "Development Tools"

5-7. yum install -y gcc g++ kernel-devel

5-8. pip install docker-compose -i https://pypi.douban.com/simple

最后查看docker-compose版本号

5-9. docker-compose -version

docker-compose version 1.25.4, build unknown

六、加载镜像文件和启动容器实例

6-1. 在/root目录下创建文件夹feiguyun_book2，把百度云盘下载的所有tar.gz文件放入该文件夹下。从读者QQ群文件中下载docker-compose.yml文件放入文件夹feiguyun_book2。把从读者QQ群文件中下载的code文件夹放入/root/feiguyun_book2/volume/目录下

6-2. 进入/root/feiguyun_book2目录，运行docker images命令，确保没有任何镜像文件；运行docker ps命令，确保没有任何镜像进程运行。如下图：

6-3. 加载镜像文件，在/root/feiguyun_book2目录下，依次运行以下命令

docker load < 1

docker load < 2

docker load < 3

docker load < 4

docker load < 5

docker load < 6

docker load < 7

docker load < 8

docker load < 9

注意：当镜像文件比较大时，加载文件会比较慢

6-4. 加载完成后，查看所有镜像文件列表

6-5.使用命令 docker network create hadoop-docker 创建网络

6-6. 创建mysql数据库表存放目录。在feiguyun_book2目录下运行以下两个命令行

mkdir volume/mysql

chown -R 999 volume/mysql/

6-7. docker-compose up -d 启动Docker镜像服务

6-7. docker-compose ps查看所有镜像进程启动情况，如下图所示

第二章大数据环境初始化及启动、验证

一、格式化HDFS。只需要运行一次

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master hdfs namenode -format

最后运行的结果如下所示

二、初始化Hive元数据库。只需要运行一次

Hive的元数据存放在mysql节点的数据库中，需要先创建可以连接mysql数据库的账户。在/root/feiguyun_book2目录下运行命令：

2-1. docker-compose exec mysql bash

进入到mysql 节点，使用cli工具进入数据库（下面红色部分是输入的命令内容）

root@mysql:/# mysql -u root -p

Enter password: ****** <root用户的密码是hadoop>

进入后输入如下红色部分：

mysql> use mysql;

mysql> GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY 'hadoop' WITH GRANT OPTION;

mysql> FLUSH PRIVILEGES;

mysql> select host,user from user;

+-----------+---------------+

| host | user |

+-----------+---------------+

| % | docker |

| % | root |

| localhost | mysql.session |

| localhost | mysql.sys |

| localhost | root |

+-----------+---------------+

5 rows in set (0.00 sec)

运行完成，可以退出mysql 节点。

2-2. 在feiguyun_book2目录下输入以下命令，初始化hive数据库表数据

docker-compose exec hbase-master schematool -dbType mysql -initSchema

最后运行结果如下

三、启动Hadoop服务

在/root/feiguyun_book2目录下运行命令：

3-1. docker-compose exec hbase-master start-dfs.sh

3-2. docker-compose exec hbase-master start-yarn.sh

验证yarn服务和dfs服务

docker-compose exec hbase-master bash 输入命令进入hbase-master节点，在该节点中输入命令：

cd /root/hadoop/share/hadoop/mapreduce

3-4. hadoop jar hadoop-mapreduce-examples-2.7.7.jar pi 3 10

最后可以看到输出以下内容：

Estimated value of Pi is 3.60000000000000000000

四、启动Hive metastore服务

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-slave2 bash

进入hbase-slave2节点，启动服务，运行如下命令：

cd /root/hive/bin

4-1. nohup ./hive --service metastore&

启动后可以进入hive验证一下服务

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master bash

进入hbase-master节点，启动hive cli，使用如下步骤：

[root@hbase-master /]# which hive

/root/hive/bin/hive

[root@hbase-master /]# hive

hive> show databases;

default

Time taken: 1.767 seconds, Fetched: 1 row(s)

hive> exit;

五、启动HBase服务

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master bash

进入hbase-master节点，启动服务，运行如下命令：

cd /root/hbase/bin

5-1. ./start-hbase.sh

启动后等待15秒左右，启动hbase shell，使用如下步骤：

[root@hbase-master /]# which hbase

/root/hbase/bin/hbase

[root@hbase-master /]# hbase shell

hbase(main):001:0> status

1 active master, 1 backup masters, 3 servers, 0 dead, 0.6667 average load

看到HBase节点状态都正常，顺便把两个表创建了，如下红色部分命令：

hbase(main):002:0> create 'rpt_artcl',{NAME=>'cf', VERSIONS=>3, COMPRESSION=>'GZ'}

0 row(s) in 5.7520 seconds

=> Hbase::Table - rpt_artcl

hbase(main):003:0> create 'access_log',{NAME=>'cf', VERSIONS=>3, COMPRESSION=>'GZ'}

0 row(s) in 2.4530 seconds

=> Hbase::Table - access_log

hbase(main):004:0> list

TABLE

access_log

rpt_artcl

2 row(s) in 0.0690 seconds

=> ["access_log", "rpt_artcl"]

最后使用exit退出HBase shell

【注】如果输入status命令显示ZooKeeper服务错误，请先查看文档最后“故障排除”中的解决办法。

在hbase-master节点启动Hbase thrift server服务

在/root/hbase/bin目录下运行命令

5-2. sh hbase-daemon.sh start thrift

六、启动Spark服务

在/root/feiguyun_book2目录下运行命令：

6-1. docker-compose exec hbase-master start-all.sh

启动后，登录hbase-slave2（或hbase-master、hbase-slave1）节点上验证spark服务

cd /root/spark/

6-2. ./bin/spark-submit --class org.apache.spark.examples.SparkPi --master spark://hbase-master.hadoop-docker:7077 examples/jars/spark-examples_2.11-2.4.1.jar 10

运行最后可以看到输出的Pi值如下，说明Spark正常使用

Pi is roughly 3.141452

七、启动SparkThriftServer服务

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master bash 进入hbase-master节点后，运行下面红色命令

7-1. hdfs dfs -chmod -R 777 /tmp

7-2. cd /root/spark/sbin/

7-3. ./start-thriftserver.sh --hiveconf hive.server2.thrift.http.port=10000 --master spark://hbase-master.hadoop-docker:7077 --jars $HIVE_HOME/lib/hive-hbase-handler-2.3.4.jar,$HIVE_HOME/lib/hbase-client-1.4.9.jar,$HIVE_HOME/lib/hbase-common-1.4.9.jar,$HIVE_HOME/lib/hbase-server-1.4.9.jar,$HIVE_HOME/lib/hbase-protocol-1.4.9.jar,$HIVE_HOME/lib/guava-12.0.1.jar,$HIVE_HOME/lib/htrace-core-3.2.0-incubating.jar

验证sparkThriftServer服务

登录hbase-slave2（或hbase-master、hbase-slave1）节点，输入下面红色部分

[root@hbase-slave2 /]# cd /root/spark/bin

[root@hbase-slave2 bin]# ./beeline

Beeline version 1.2.1.spark2 by Apache Hive

beeline> !connect jdbc:hive2://hbase-master:10000/

Connecting to jdbc:hive2://hbase-master:10000/

Enter username for jdbc:hive2://hbase-master:10000/: root

Enter password for jdbc:hive2://hbase-master:10000/: ****

（注意：这里的登录账户是运行 beeline的用户的用户名和密码, root用户的密码是root）

SLF4J: ... ...

Connected to: Spark SQL (version 2.4.1)

Driver: Hive JDBC (version 1.2.1.spark2)

Transaction isolation: TRANSACTION_REPEATABLE_READ

0: jdbc:hive2://hbase-master:10000/> show databases;

+-------------------------+--+

| databaseName |

+-------------------------+--+

| default |

+-------------------------+--+

1 row selected (2.507 seconds)

0: jdbc:hive2://hbase-master:10000/> !q

Closing: 0: jdbc:hive2://hbase-master:10000/

第三章演示程序数据初始化及运行步骤

一、初始化Hive表

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master bash 进入节点后，运行下面命令

hive -f /code/source-code/ch4/create-tables.hql

运行后，如果没有出错，可以进入beeline客户端查看所有创建的表，共10张。如下图所示：

二、运行数据导入程序

在/root/feiguyun_book2目录下运行命令：

docker-compose exec hbase-master bash 进入hbase-master节点后，运行下面命令

2-1. cd /code/source-code/ch4/etl_job/

2-2. chmod +x artcl_hive2hbase/hive2hbase.sh

2-3. python3.6 run.py 20200220 ß参数20200220也可以改成其他任意日期

初始化脚本会运行大概7分钟，最终把数据插入到HBase中。以下是运行截图。

正常执行完毕后，可以进入HBase中查看记录数量，如下所示

hbase(main):001:0> count 'rpt_artcl'

90 row(s) in 1.7790 seconds

=> 90

运行导入数据程序只需执行一次，无需更换成其他日期重复运行，因为输入数据是固定的。

三、启动Flask前端查看数据

在hbase-master节点上运行下面命令

python36 /code/ch7/flask_app/run.py

运行后不要关闭该窗口。然后在宿主机上打开浏览器，输入http://宿主机IP地址:5000/index 比如我的宿主机IP地址是192.168.1.4，则可以输入 http://192.168.1.4:5000/index

进入演示程序后，可以进入“检索抓取文章”页面，输入时间段进行检索，如下所示

时间段请选择2017-5-1至2019-5-1之间的日期，其他日期段没有数据。

四、确认两个模拟网站正常访问

比如我的宿主机IP地址是192.168.1.4，则可以在浏览器中输入以下网址查看模拟新闻站点

http://192.168.1.4:10080/site1.com/

http://192.168.1.4:20080/site2.com/

五、创建kafka主题

进入宿主机/root/feiguyun_book2目录，输入以下命令

docker exec -it kafka_single bash

进入后创建weblog主题，如下命令

5-1. kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic weblog

5-2. kafka-topics.sh --list --zookeeper localhost:2181

以下是命令运行截图

创建后退出该节点即可。

六、启动两个Flume Agent客户端

进入宿主机/root/feiguyun_book2目录，输入以下命令

docker-compose exec slave01 bash

进入slave01节点后，在根目录输入如下命令，启动后不要关闭窗口

6-1. flume-ng agent --conf /opt/flume/conf/ --f /opt/weblog2kafka.conf --name a1 -Dflume.root.logger=INFO,console

在宿主机中启动新的terminal，进入/root/feiguyun_book2目录

docker-compose exec slave02 bash

进入slave02节点后，在根目录输入如下命令，启动后不要关闭窗口

6-2. flume-ng agent --conf /opt/flume/conf/ --f /opt/weblog2kafka.conf --name a1 -Dflume.root.logger=INFO,console

七、启动Flink并加载job

容器中Flink服务默认自动启动，只需要打开浏览器查看WebUI即可，比如我的宿主机IP地址是192.168.1.4，则可以在浏览器中输入http://192.168.1.4:8081/

参照本书11.5章节介绍的步骤，把flink2hbase_docker.jar提交作业至Flink(flink2hbase_docker.jar文件在QQ群文件中可以获得)，如下图所示

八、运行站点模拟访问程序

在宿主机上打开浏览器，输入http://宿主机IP地址:5000/ pvchart，比如我的宿主机IP地址是192.168.1.4，则可以输入 http://192.168.1.4:5000/pvchart

点击开始模拟按钮，会刷新图表20秒，如下图所示

演示完成后，可以到“检索访问日志”页面查看刚才模拟访问的页面地址，在http://192.168.1.4:5000/access_log 页面，如下所示。注意查询开始结束时间要选择刚才模拟访问的时间段，其他区间可能没有数据。

九、运行词云图生成和统计程序

根据刚才模拟访问的日志，可以生成关键字词云图，访问地址是 http://192.168.1.4:5000/wordcloud，注意查询开始结束时间要选择刚才模拟访问的时间段，如下所示：

注意：其中的英文单词是未被剔除的HTML标签，有兴趣的读者可以完善自己的stopwords停用词典。如下图是生成访问关键字占比统计，时间段同样要选择刚才模拟访问的20秒。

第四章如何关闭服务

一、关闭大数据组件服务步骤

离线大数据组件主要安装在hbase-master节点上，下面的操作都在hbase-master上运行：

cd /root/hbase/bin

./hbase-daemon.sh stop thrift

./stop-hbase.sh

cd /root/spark/sbin

./stop-thriftserver.sh

./stop-all.sh

cd /root/hadoop/sbin

./stop-yarn.sh

./stop-dfs.sh

流式大数据组件的服务不用手动关闭。

二、关闭容器集群

确认关闭hbase-master上的服务后，可以进入宿主机关闭容器集群服务。

在/root/feiguyun_book2目录下运行命令：

docker-compose down 如下所示

注意事项：

关闭容器集群后如果要再次启动，只需要在/root/feiguyun_book2目录下执行

docker-compose up -d

启动命令即可，不需要再次执行格式化HDFS和初始化Hive元数据库。

“非习劳无以进业”---- 希望您能通过以上步骤的指引，顺利运行演示程序，并最终学有所获！！

（完）

附录故障排除

一、Hadoop启动失败

Hadoop集群启动后，可以分别登录hbase-master,hbase-slave1,hbase-slave2三个节点，依次查看Java进程是否正确。如果HDFS或MapReduce无法正常运行，可在hbase-master节点手动关闭dfs和yarn服务，尝试再次启动。

二、HBase启动失败

在虚拟机作为宿主机的场景下，经常会出现HBase首次启动失败，hbase-master节点上的HMaster进程启动后自动消失，进入hbase shell客户端使用status查看状态会提示ZooKeeper服务出错。

出现这种错误的原因是由于系统资源紧张，ZooKeeper集群和HBase通讯出故障。zoo1,zoo2,zoo3三个节点的ZooKeeper服务都是随着Docker服务自动启动的，不必手动运行。当HBase服务启动失败时，可以先进入hbase-slave1和hbase-slave2节点，使用kill命令杀掉HRegionServer服务，最后进入hbase-master节点，运行：

cd /root/hbase/bin/

./stop-hbase.sh

关闭HBase服务，再使用 ./start-hbase.sh 启动，往往就正常了。

三、Spark启动失败

Spark启动失败的情况比较少见，可以尝试关闭后再启动。或者可以修改hbase-master节点上Spark启动脚本里面内存使用量，由于本演示程序只使用Spark作为Hive的计算引擎这一个特性，可以把内存使用量调小，比如定义成256M。

四、初始化Hive表错误

Hive表DDL都定义在create-tables.hql文件中，只需要运行一次。如果第一次运行失败，再次运行前，要修改create-tables.hql文件，注释掉 create database feigu 这行。

五、运行数据导入程序错误

运行该步骤前要确保Hive metastore和HBase服务及SparkThriftServer服务都已正常启动，否则会报错。

六、运行站点模拟访问程序错误

点击开始模拟按钮后会出现坐标轴，但没有生成折线。出现这种错误要依次排查3处：

模拟新闻站点运行是否正常

打开浏览器，访问slave01或slave02的新闻站点，同时进入slave01或slave02的终端，运行 tail -f /var/log/apache2/access.log 看是否有日志输出。

Kafka中weblog主题是否正常接收到数据

如果flume-ng可以收到日志数据，则进入kafka_single节点的终端，启动一个消费者

kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic weblog --from-beginning

来订阅weblog主题的数据，看是否有数据输出

Flink作业是否运行正常

如果kafka主题可以接收到数据，要排查Flink作业日志输出，在WebUI上查看TaskManager的Logs中是否有异常抛出，如下所示

然后再查看Stdout页面中是否打印出如下内容

七、其他问题

可以在QQ群50926571中提问，或是在feiguyunai上发帖求助。

python-ai-02