Jarlonyan

Hinge Loss和SVM

2017-04-02T00:00:00+08:00

1. Hinge Loss

在PRML中，$hinge \, loss$常常用在 $SVM$ 中。数据的真实标签 $y=\pm 1$ 和分类器的分数$f(x)$ . $hinge \, loss$定义如下： $\ell(y,f(x))=max \big(0,1-y\cdot f(x) \big) \tag{1}$

$f(x)$是分类器决策函数的原始输出值，而不是类标。 $f(x)=wx+b \tag{2}$ 可以看出，当$y$和$f(x)$有相同的符号时，意味着$f(x)$预测出正确的分类，这时$\left| f(x) \right| \geq 1 $

SVM得到的模型是： $f(x)=\sum_{i=1}^m{\alpha_i \cdot y_i \cdot x_i^T \cdot x + b} \tag{3}$
SVM预测

$\begin{cases} f(x)\geq 0, 正类 \\ f(x)< 0, 负类 \end{cases} \tag{4}$

2. SVM、软间隔和正则化

loss function

$\ell(y,f(x))=max(0,1-y\cdot f(x)) \tag{5}$

SVM总的损失： $\sum_{i=1}^m{max \big\{ {0, 1-y_i(wx_i+b)} \big\} } \tag{6}$
SVM优化目标：

$\frac{1}{2} \lVert w \rVert ^2 + C \cdot \sum_{i=1}^m{max \big\{ {0, 1-y_i(wx_i+b)} \big\} } \tag{7}$

引入松弛变量: 引入松弛变量$\epsilon_i$，重写上面式子， $\min \limits_{w,b,\epsilon} \big\{ { \frac{1}{2} \lVert w \rVert ^2 + C \cdot \sum_{i=1}^m{ \epsilon_i }} \big\} \\ s.t. \quad y_i(w^T x_i +b) \geq 1- \epsilon_i \\ \epsilon \geq 0 \tag{8}$

Logistic Regression推导

2017-04-02T00:00:00+08:00

1.已知

假设样本 $x$ 是正样本的概率： $p(y=1|x) = \frac{1}{1+e^{-(wx+b)}} \tag{1}$
将上面这个 $sigmoid$ 函数看做是 $f(x)$ 这个$f(x)$特点:

$f^{'}(x)=f(x)\cdot \big( 1-f(x) \big) \tag{2}$

$loss \, function$: $\ell(y, p(y|x))=-\log{p(y|x)} \tag{3}$

2. 推导过程

上面的 $loss \, function$ 等价于 $\ell(y, p(y|x))=\begin{cases} -\log{p(y=1 \big| x)}, \qquad y=1 \\ -\log{\left[ 1-p(y=1\big| x) \right] }, y=0 \end{cases} \tag{4}$
将上面的式子写成一个式子

$\ell(y, p(y|x))=-y\cdot{\log{p(y=1\big| x)}}-(1-y)\cdot{\log{\left[ 1-p(y=1\big| x)\right]}} \tag{5}$

训练集的总的代价：

$\begin{alignat}{2} J(w)&=\sum_{i=1}^m {\ell(y_i,p(y_i\big| x_i))} \\ &=\sum_{i=1}^m {-y_i\cdot{\log{p(y_i=1\big| x_i)}}-(1-y_i)\cdot \log{\left[ 1-p(y_i=1\big| x_i)\right]}}\\ \end{alignat} \tag{6}$

为了简单起见，公式中的 $x$ ，$w$ 用增广向量表示，用 $f(wx)$ 来表示 $p(y=1 x)$ 。那么：

$J(w)=\sum_{i=1}^m{-y_i\cdot \log{f(w \cdot x_i)}-(1-y_i)\cdot \log{\left[ 1-f(w \cdot x_i)\right]}} \tag{7}$

对式子关于$w$求导：

$\begin{align*} \frac{ \partial J(w)}{ \partial w} & =\frac{ \partial\left\{ { \sum_{i=1}^m{-y_i\cdot \log{f(w \cdot x_i)}-(1-y_i)\cdot \log{\left[ 1-f(w \cdot x_i)\right]}} } \right\}}{ \partial w} \tag{8} \\ & =\sum_{i=1}^m {-y_i\cdot {(1-f(w \cdot x_i))}\cdot x_i -(1-y_i)\cdot (-1) \cdot f(w \cdot x_i) \cdot x_i } \tag{9} \\ & =-\sum_{i=1}^m { x_i \big\{ { y_i \cdot (1-f(w \cdot x_i))-(1-y_i \cdot f(w \cdot x_i) }) \big\} } \tag{10} \\ & =-\sum_{i=1}^m { x_i \big\{ { y_i-f(w \cdot x_i) } \big\} } \tag{11} \end{align*}$

3. 求解方法

3.1 梯度下降法

$w=w-\eta \cdot \frac{\partial J(w)}{\partial w} \tag{12}$

3.2 牛顿法

$w=w-\eta \cdot \frac{ J^{'}(w)}{ J^{''}(w)}=w-\eta \cdot \frac{\partial ^ 2 J(w)}{ \partial w \cdot \partial w^{T} } \tag{13}$

ROC和AUC

2017-04-02T00:00:00+08:00

1. 精确度、召回率、准确率

精确度(precision)：又叫查准率,预测为正例的样本中，有多少比例是真正的正例。
召回率(recall):又叫查全率，真正的正样本中，有多少比例是预测对了。
准确率(accuracy):正确预测的比例也就是有百分之几的样本被正确的分类了，（包括正、负样本）。
计算公式：

-	P(真正)	N(真正)
P(预测)	TP	FP
N(预测)	FN	TN

真阳性(TP)——正确的肯定真阴性(TN)——正确的否定假阳性(FP)——错误的肯定，假报警，第一类错误假阴性(FN)——错误的否定，未命中，第二类错误

精确度：(precision) 精确度P: $P=\frac{TP}{TP+FP} \tag{1}$

召回率：(recall) $R=\frac{TP}{TP+FN} \tag{2}$

$F1-measure$

$F1-measure$计算公式如下： $F=\frac{2 \cdot Precision \cdot Recall}{ Precision + Recall } \tag{3}$

2. PR曲线和ROC曲线

如何得到PR曲线？对于一些模型（e.g. Logistic Regression、SVM、神经网络）输出一个得分score。将score从大到小排序，依次以每个score为阈值，预测样本的正负，得到分类结果，然后计算precision和recall。假设测试集有200个样本，那么就可以得到200个precision-recall，以precision为x轴，recall为y轴就可以在二维坐标图中得到PR曲线。
如何得到ROC曲线？方法和上面的类似，只是x轴是假阳性率， y轴是真阳性率 sklearn中的ROC

为什么用ROC曲线？

既然已经这么多评价标准，为什么还要使用ROC和AUC呢？因为ROC曲线有个很好的特性：当测试集中的正负样本的分布变化的时候，ROC曲线能够保持不变。在实际的数据集中经常会出现类不平衡（class imbalance）现象，即负样本比正样本多很多（或者相反），而且测试数据中的正负样本的分布也可能随着时间变化。

matplotlib数据可视化

2017-04-02T00:00:00+08:00

1.画点状图

import pylab as pl
import matplotlib
x=[10,20,11,12,15,25]
y=[3,6,9,8,7,4]
co=[1,2,3,4,5,6]
fig1=pl.figure()
for i in range(0,len(x)):
pl.plot(x[i],y[i],'o',color=cm(co[i]*1.0/6)) #画点状图
plt.scatter(random(10), random(10), marker='x', color=colors[0])
pl.text(x[i],y[i],str(y[i])+'*',color='red') #在某个位置写字
pl.xlim(0,45)
pl.title('cluster graph ')
pl.show()
#=========================
pl.bar(x,y) #画柱状图

2.柱状图

import matplotlib.pyplot as plt
import numpy as np
dict = {'A': 40, 'B': 70, 'C': 30, 'D': 85}
for i, key in enumerate(dict):#Circulate both index and value(Here is key)
plt.bar(i, dict[key], color='r', width=0.2)
plt.xticks(np.arange(len(dict))+0.1, dict.keys())#Translation
plt.yticks(dict.values())
plt.grid(True)
plt.show()

plt.bar(x_list, value_list, color='b', width=0.2,alpha=0.5)
plt.bar(x_list, value_list2, color='r', width=0.2,alpha=0.5)

plt.xticks(np.arange(len(x_list))+0.1, x_list, rotation=70)
plt.legend(['good user','bad user'])
plt.show()

3.折线图

x = []
yQ = []
yARI = []
delta = 0
while delta <= 1.0:
x.append(delta)
ARI = Evaluation.calculateARI(true_labels, predict)
Q = Evaluation.calculateQ(G, communities)
yARI.append(ARI)
yQ.append(Q)
delta += 0.1
# end of while
pl.plot(x, yARI)
pl.plot(x, yNMI)
pl.plot(x, yQ)
pl.plot(x, yPurity)
pl.legend(('ARI', 'Q'), loc='upper right')
pl.ylim(0, 1.1)
pl.show()

4.画多个子图

fig1=plt.figure()
fig1.add_subplot(4,1,1)
plt.plot(x1,y1)
fig1.add_subplot(4,1,2)
plt.plot(x2,y2)
fig1.add_subplot(4,1,3)
plt.plot(x3,y3)
fig1.add_subplot(4,1,4)
plt.plot(x4,y4)

5.带有颜色深浅的散点图：

x=[1, 1, 2, 3, 5]
y=[1.2, 1.1, 5, 4, 2]
z=[ 1, 3, 8, 5, 2 ]
plt.scatter(x, y, c=z,s=50)
plt.colorbar()
plt.show()

效果：

6.颜色

颜色之间的对应关系为
b—blue c—cyan g—green k—-black
m—magenta r—red w—white y—-yellow
有三种表示颜色的方式:
a:用全名 b:16进制如：#FF00FF c：RGB或RGBA元组（1,0,1,1） d：灰度强度如：‘0.7’

7.点的形状

标记风格有多种：
. Point marker
, Pixel marker
o Circle marker
v Triangle down marker
^ Triangle up marker
< Triangle left marker
> Triangle right marker
1 Tripod down marker
2 Tripod up marker
3 Tripod left marker
4 Tripod right marker
s Square marker
p Pentagon marker
* Star marker
h Hexagon marker
H Rotated hexagon D Diamond marker
d Thin diamond marker
| Vertical line (vlinesymbol) marker
_ Horizontal line (hline symbol) marker
+ Plus marker
x Cross (x) marker

8.线的形状

符号和线型之间的对应关系
- 实线
-- 短线
-. 短点相间线
： 虚点线
plt.plot(y, 'cx--', y+1, 'mo:', y+2, 'kp-.');

9. 画网络图

对网络数据画图。需要安装networkx网络。

import networkx as nx
pos=nx.spectral_layout(G)
clusterResult=[ ]是节点的社区划分结果
nx.draw(G,with_labels=True,node_color=clusterResult,node_size=300)
plt.show()

networkx社交网络包

2017-04-02T00:00:00+08:00

networkx是Python中用来计算网络结构的包。其中包含网络的数据结构，对于社交网络中的一些算法的研究，非常方便。

1. 一个demo

1.1 先建立一个网络

import networkx as nx
G = nx.random_graphs.barabasi_albert_graph(100,3) #生成一个n=1000，m=3的BA无标度网络
print G.degree(0) #返回某个节点的度
print G.degree() #返回所有节点的度
print nx.degree_histogram(G) #返回图中所有节点的度分布序列（从1至最大度的出现频次）

1.2. 用matplotlib将网络画出来

将上面的网络图用matplotlib画出来

import networkx as nx
import matplotlib.pyplot as plt
pos=nx.spectral_layout(G)
clusterResult=[ 1 for i in range(0,100)]#这是节点的社区划分结果
nx.draw(G,with_labels=True,node_color=clusterResult,node_size=100)
plt.show()

2 network的一些常用方法

2.1 网络结构的创建

创建网络结构

G = nx.Graph() #建立一个空的无向图G

2.2 网络结构的属性

获取节点的邻居、度

G.neighbors(i) #节点i的所有邻居
G.degree(i) #节点i的度

2.3 读写gml文件

网络结构的数据集存储在*.gml文件中，可以使用networkx读取、写入gml文件。

import networkx as nx             #导入networkx包
G=nx.read_gml("dolphins.gml")  #从文件中读入网络

pandas数理统计

2017-04-02T00:00:00+08:00

1. 造表DataFrame

#造表头
import pandas as pd
df=pd.DataFrame()
cols_name=[ "id", "x", "y" ]

#插入一行
record=[ id, x, y ]
ser_record=dict( (k,v) for k,v in zip(cols_name, record) )
df=df.append( pd.Series(ser_record), ignore_index=True)

2. 增加一行

#插入一行
record=[ id, x, y ]
ser_record=dict( (k,v) for k,v in zip(cols_name, record) )
df=df.append( pd.Series(ser_record), ignore_index=True)

3. 删除行

df.drop( [22,33], axis=0) #22,33是行的index； axis=0表示删除的是行，是横轴

#可以记录下索引，然后一次性删除
df=df.drop(delete_index_list)	

4. 表的选择select

注意多个条件（与：&、或：|）

df=df.ix[ (df.name.notnull()) & (df.num<20) , : ]

5. dataframe遍历

一般方法：

for iter_index in df.index:
    time=df.loc[iter_index, 'time']
    do_some_thing_with_time(time)
    df.loc[ iter_index, 'time']=time

这个程序是一个网友的程序，他想让do_some_thing_with_time(time)找出DataFrame中time相同的行，给这些time加上后缀，使得DataFrame的每一行time都不同。也就是说需要遍历，然后再修改DataFrame。但是这样会很慢很慢。

另一个网友有另外一个方法：使用Series.apply函数来调用do_some_thing_with_time()，自然就得到了一个新的处理time列

df.time2=df.time.apply( do_some_thing_with_time )

6. 根据一列生成另外一列

df['timesection']=map( lambda x: 1 if (x/100>=9) else (2 if (x%100>==5) else 3), df['time'])

7. 取子表

a=df.iloc[:, [2,3] ] #取第3，4列组成的子表
a=df.ix[:, ["name","time"]] #或者这样

如果加上上面的取某些行的条件，就是取子表了。

8. 取表的单独一个属性列

这个方法是使用map函数，得到的x是一个list

x=map( lambda a: a, df["x"] )

9. 聚合操作group by

df_group是一个DataFrameGroupBy对象

df_group=df.groupby("time") 
df_dict=dict(list(df_group)) #转化
for key in df_dict:
    df2=df_dict[key]

10. 两个表连接

joined_df=pd.merge(df1, df2, left_on='id1', right_on='id2', how='inner')

11. 改变一个列的值的类型

df['time']=df['time'].astype(int)

12. 排序，根据某一列排序

df=df.sort_values(by='time')

13. apply, applymap, map函数

apply, applymap, map apply是作用在dataframe上，用于对row或者column进行计算 applymap是作用在dataframe上，是元素级别的操作， map是作用在Series上，是元素级别的操作

print frame.apply(lambda x:x.max()-x.min()) #默认是应用在每一列上
print frame.apply(lambda x:x.max()-x.min(), axis=0) #应用在每一行上
print frame.applymap( lambda x: '%.2f' % x )

14. 打乱dataframe

将一个dataframe对象打乱，并且重新生成索引。打乱行

train_set=train_set.sample(frac=1.0)	#打乱
train_set=train_set.reset_index(drop=True)

15. 去除重复的行

df=df.drop_duplicates()

16. pandas读写文件

df=pd.read_csv(filename,encoding="utf-8")  #读取csv文件
df=pd.read_table(filename,delim_whitespace=True,encoding="utf-8") #读取以空格分隔的一般文本文件
df.to_csv(outputfile,index=False,encoding="utf-8") #将数据写入文件

如果文件太大，需要分块读取。

reader = pd.read_table('tmp.sv', sep='|', chunksize=4)

python学习

2017-04-02T00:00:00+08:00

1、基础知识

1.1 常用安装命令

pip list           #在commond中。查看已经安装的包。
pip install ****.whl    #pip是自带程序，需要设置环境变量。以后就可以从网站下载*.whl格式的扩展包了。使用这个命令安装。
pip uninstall ***       #卸载某包

pip install **     #一般安装用这个就行。

#有时候上面命令会下载超时,使用下面这个命令，指定从douban下载
pip install ** -i https://pypi.douban.com/simple 

#在mac中自带python2.7，有时候需要更新包，由于maxos采用了更高级的内核保护机制，会发生错误。就用这个命令。
sudo pip install numpy --upgrade --ignore-installed 

#有时候有些包用pip会出错，用conda。
conda install **  

2. Python数据结构

2.1 元组tuple

Python中的元组一旦创建了，不能以任何方式改变。元组和字符串序列都是不可变序列。

定义元组tuple用圆括号()
```
a=(1,2,3,'44','555')
```
元组索引，从0开始，元组内元素有确定的顺序

a[0]
a[-1]    #负的索引，从尾部开始计数
a[1:6]   #对元组切片操作，切片得到新的元组

元组遍历

for b in a:
    print b

for i in range(0,len(a)):
    print a[i]

2.2 列表list

列表是Python中最常用的数据结构，它是可变的序列。

定义列表用方括号[]

a=[1,2,3,'44','555']

列表的内置函数

a.append(3)
a.insert(3,900)  #下标3处，插入900
a.extend([7,9])  #合并两个list
a.index(100)  #搜索，找不到会爆异常
a.remove(3)  #删除一个值，首次出现
a.pop()   #删除最后一个元素

2.3 集合set

定义集合用花括号{},或者内置函数
```
s={3,5,7,8}
s=set(alist)
```
2.4 字典dict

根据两个list构造字典

keys = ['a', 'b', 'c']
values = [1, 2, 3]
dictionary = dict(zip(keys, values))
print dictionary

3. Python奇淫技巧

3.1 求两个list的交集，并集，差集

print list(set(a).intersection(set(b)))   #获取两个 list 的交集
print list(set(a).union(set(b)))        #获取两个 list 的并集
print list(set(b).difference(set(a)))    #获取两个 list 的差集

3.2 优先权队列的用法

from queue import Queue
from queue import PriorityQueue
prioqueue=PriorityQueue()
prioqueue.put((1,'hahaha'))  
prioqueue.put((5,'ustc'))
prioqueue.put((2,'nwsuaf'))
prioqueue.put((3,'tsinghua'))
prioqueue.put((6,'peking'))
prioqueue.put((4,'zhejiang'))
while prioqueue:    
    print (prioqueue.get_nowait())

3.3 import 包

modules所在的目录在Python中叫做package，比如有一个名字叫做MyPackage的package，实际上是一个目录。它的下面有3个文件，分别是： first.py 、second.py 、__init__.py 。有两种方法调用某目录下的modules。 __init__.py为空时：

from MyPackage import firstfirst.hello()

___init__.py用all=[…]指定该package下可以被imported进去的module

% cat MyPackage/__init__.py__all__=["first","second"]

3.4 排序

在Python中，当需要对一个list排序时，一般可以用 list.sort() 或者 sorted(iterable[, cmp[, key[, reverse]]]).其中：cmp(e1,e2) 是带两个参数的比较函数，返回值：负数（e1 < e2）、0（e1=e2）、正数（e1>e2）。默认为None，即用内建的比较函数。key 是带一个参数的函数，用来为每个元素提取比较值，默认为None，即直接比较每个元素。reverse 是一个布尔值，表示是否反转比较结果。* cmp 使用自定义排序规则来进行排序。比如list中每个元素都是2-tuple，(keyword, weight)，我们使用weight来进行排序（从高到低）。可以这样：

def my_cmp(e1, e2):    
    return -cmp(e1[1],e2[1])
a_list=[('aa',1),('bb',2),('cc',3)]
a_list.sort(my_cmp)

如果使用lambda函数：

a_list=[('aa',1),('bb',2),('cc',3)]
a_list.sort(lambda e1,e2: cmp(e1[1],e2[1]))

key

def my_key(e):    
   return e[1]  #return key 11,10,12
L = [('aa', 11), ('bb', 10), ('cc', 12)]
L.sort(key=my_key,reverse=1) #key 大到小 reverse=0 时候从小到大

如果使用lambda函数：

a_list=[('aa',1),('bb',2),('cc',3)]
a_list.sort(key=lambda e:e[1])

字典排序

dic = {'a':31, 'bc':5, 'c':3, 'asd':4, '33':56, 'd':0}
print sorted(dic.iteritems(), key=lambda d:d[1], reverse = False ) 
#排序后是一个list:  [('d', 0), ('c', 3), ('asd', 4), ('bc', 5), ('a', 31), ('33', 56)]

3.5 列表推导

列表推导（List comprehension）的作用是为了更方便地生成列表（list）。比如，一个list变量的元素均为数字，如果需要将每个元素的值乘以2并生成另外一个list。如果使用列表推导，可以这样：

list1 = [1,2,4,5,12]
list2 = [item*2 for item in list1 ]
print list2

可以通过if过滤掉不想要的元素，例如提取出list1中小于10的元素：

list1 = [1,2,4,5,12]
list2 = [item for item in list1 if item < 10 ]
print list2

如果要将两个list中的元素进行组合，可以：

list1 = [1,2,3]
list2 = [4,5,6]
list3 = [(item1,item2) for item1 in list1 for item2 in list2 ]
print list3

3.6 is和==的区别

Python中的对象包含三要素： id ,、 type、 value其中， id 用来唯一标识一个对象， type 标识对象的类型， value 是对象的值。is判断的是 a对象是否就是b对象，是通过 id 来判断的==判断的是a对象的值是否和b对象的值相等，是通过 value 来判断的

>>> a=100
>>> b=100.0
>>> a is b
False
>>> a==b
True

3.7 进度条

step=0      
for i in range(0,666):
    step+=1
    if step%10==0:  #显示进度条
        running_fraction=step*100.0/666
        sys.stdout.write(str(running_fraction)+'% \r')
        sys.stdout.flush()  

4、高级话题

4.1 Python特殊语法： lambda 、 filter 、 map 、 reduce

Python内置了一些非常有趣但非常有用的函数，冲分体现了Python语言的魅力！！* lambdalambda函数也叫匿名函数，比如：

def f(x):    
    return x**2    
print f(4)

使用lambda函数，写成这样：

g = lambda x : x**2print g(4)

lambda会创建一个函数对象，但不会把这个函数对象赋值给一个标识符，而def则会把函数对象赋值给一个变量。此外，lambda只是一个表达式，而def则是一个语句。lambda语句被用来创建新的函数对象，并且在运行时返回他们。

print   reduce(lambda  x,y: x*y  , range(1,1001))

reduce（functionA，iterableB），functionA为需要两个变量的函数，并返回一个值。iterableB为可迭代变量，如List等。reduce函数将B中的元素从左到右依次传入函数A中，再用函数A返回的结果替代传入的参数，反复执行，则可将B reduce成一个单值。在此，是将1到1000的连续整数列表传入lambda函数并用两个数的积替换列表中的数，实际的计算过程为：(…((1×2)×3)×4)×…×1000)，最后的结果即1000的阶乘。* 关于lambda函数，一些用过的技巧：

list_a_b_c_sorted=sorted(list_a_b_c,key=lambda a_tuple:a_tuple[1]) 
#list_a_b_c是一个列表，列表的元素是一个三元组(a,b,c)，按照关键字为b来排序
cluster_list=defaultdict(lambda:[])   #定义了一个字典。value是一个list

为什么使用lambda

使用Python写一些执行脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。
对于一些抽象的，不会别的地方再复用的函数，有时候给函数起个名字也是个难题，使用lambda不需要考虑命名的问题。
使用lambda在某些时候让代码更容易理解。

filter

filter(function,sequence) ：对 sequence 中的 item 依次执行 function(item) a将执行结果为 True 的 item 组成一个 List/String/Tuple （取决于 sequence 的类型）返回。比如：

def f(x):     
    return x % 2 != 0 and x % 3 != 0 
filter(f, range(2, 25))

打印出： [5, 7, 11, 13, 17, 19, 23]

map map(function, sequence) ：对 sequence 中的item依次执行 function(item) ，将执行结果组成一个List返回。比如：
```
def cube(x):     
   return x*x*x map(cube, range(1, 11))
```
打印出：[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
reduce reduce(function, sequence, starting_value) ：对 sequence 中的 item 顺序迭代调用 function ，如果有 starting_value ，还可以作为初始值调用，例如可以用来对 List 求和：
```
def add(x,y):    
  return x + yreduce(add, range(1, 11))
```
打印出：55 （注：1+2+3+4+5+6+7+8+9+10）
```
reduce(add, range(1, 11), 20)
```
打印出： 75 （注：1+2+3+4+5+6+7+8+9+10+20）

4.2 闭包

什么是闭包？

闭包（ closure ）是函数式编程的重要的语法结构。函数式编程是一种编程范式（面向过程和面向对象也都是编程范式）。在面向过程中，有函数（ function ）；在面向对象中，有对象（ object ）。函数和对象的根本目的是以某种逻辑方式组织代码，并且提高代码的可重复使用性（ reusability ）。闭包也是一种组织代码的结构，它同样提高了代码阿德可重复使用性。

为什么要闭包？

闭包可以有效地减少了函数所需要定义的参数数目。这对于并行运算来说有重要的意义。在并行运算的环境下，让每台电脑负责一个函数，然后将一台电脑的输出和下一台电脑的输入串联起来。最终，像流水线一样工作。从串联的电脑集群一端输入数据，从另一端输出数据。这样的情境最适合只有一个参数输入的函数。闭包就可以实现这一目的。

怎么用闭包？

例题1

def make_add(a):    
    def add(b):        
        return a+b    
    return addp=make_add(23)
q=make_add(44)
print p(100)
print q(100)

打印出：123 144make_add是一个函数，带有一个参数a，这个函数里面又定义了一个新函数，在新函数中，外部传递过来的参数a和自己的参数b绑定在一起了。我们将b看做新函数的一个配置信息，配置信息不同，函数的功能就不一样了，也就是能够得到定制之后的函数。在看一下运行结果，虽然p和q都是make_add生成的，但是因为配置参数不同，后面执行相同的参数后得到了不同的结果，这就是闭包。

例题2

def hellocounter(name):    
    count=0    
    def counter():       
        nonlocal count        
        count+=1        
    print ('Hello,',name,',',str(count)+' access!')    
    return counter
hello = hellocounter('yan')
hello()
hello()
hello()

执行结果(python3.4)

Hello, yan , 1 access!Hello, yan , 2 access!Hello, yan , 3 access!

可以将这个程序看做统计一个函数调用次数的函数。

例题3装饰器

def makebold(fn):    
    def wrapped():        
        return '<b>'+fn()+'</b>'    
    return wrapped
def makeitalic(fn):    
    def wrapped():        
        return '<i>'+fn()+'</i>'    
    return wrapped@makebold@makeitalic
def hello():    
    return 'Hello World'print (hello())

执行结果

<b><i>Hello World</i></b>

这个程序就是传说中的装饰器。装饰器就是一种闭包。装饰器的概念：对函数（参数、返回值等）进行加工处理，生成一个功能增强版的一个函数。

4.3 赋值、浅拷贝、深拷贝

赋值的3种形式：=、对象作为参数、返回值。在Python中，对象的赋值就是简单的对象引用，比如：

list_a=[1,2,3,4,5,6,7]
list_b=list_a

那么 list_b 和 list_a 是一样的，他们指向同一片内存， list_b 是 list_a 的别名，是引用。赋值操作（包括对象作为参数、返回值），不会开辟新的内存空间，它只是复制了新对象的引用。也就是说除了 list_b 这个名字外，没有其他的内存开销。

浅拷贝有3种形式：切片操作，工厂函数，copy模块中的copy函数。比如：

list_b = list_a[:]list_b = [each for each in list_a]  #切片操作
list_b = list(list_a)       # 工厂函数
list_b=copy.copy(list_a)    # copy函数

浅拷贝产生的 list_b 不再是 list_a 了，使用 is 可以发现他们不是同一个对象，用 id 查看他们也不指向同一片内存。但是如果列表元素中有高级结构比如list，那么修改了list_b中的list元素，也会修改list_a中的，因为浅拷贝仅仅拷贝了一层。

深拷贝只有一种形式。 copy 模块中的 deepcopy 函数

卷积神经网络

2017-04-02T00:00:00+08:00

1. 卷积神经网络

[TOC]

1. CNN基本结构

在CNN中输入是图像，权值W就是卷积模板，一般是卷积层和下采样层交替，最后是全连接的神经网络，也就是上述经典的人工神经网络。如下是一个简单的卷积神经网络示意图

2. 基础知识

2.1 局部感受野

所谓的局部感受野，指的是隐藏层到输入层是局部连接，并不是全连接。普通的神经网络中，隐层节点会全连接到一个图像的每个像素点上，而在卷积神经网络中，每个隐层节点只连接到图像某个局部块上，从而大大减少需要训练的权值参数。举个栗子，依旧是1000×1000的图像，使用10×10的感受野，那么每个神经元只需要100个权值参数。

2.2 参数共享

即便是局部感受野，参数还是太多，那么需要参数共享（也叫权值共享）进一步减少参数。在上面的局部连接中，每个神经元都对应100个参数，一共1000000个神经元，如果这1000000个神经元的100个参数都是相等的，那么参数数目就变为100了。

怎么理解权值共享呢？我们可以这100个参数（也就是卷积操作）看成是提取特征的方式，该方式与位置无关。这其中隐含的原理则是：图像的一部分的统计特性与其他部分是一样的。这也意味着我们在这一部分学习的特征也能用在另一部分上，所以对于这个图像上的所有位置，我们都能使用同样的学习特征。

更直观一些，当从一个大尺寸图像中随机选取一小块，比如说 8x8 作为样本，并且从这个小块样本中学习到了一些特征，这时我们可以把从这个 8x8 样本中学习到的特征作为探测器，应用到这个图像的任意地方中去。特别是，我们可以用从 8x8 样本中所学习到的特征跟原本的大尺寸图像作卷积，从而对这个大尺寸图像上的任一位置获得一个不同特征的激活值。

2.3 卷积操作

卷积运算表示为： $conv2(\boldsymbol{A}, \boldsymbol{B}) $ ，让B在A上滑动，对应位置上的元素的积之和构成结果C的一个元素。卷积运算有两种形式：窄卷积$ conv2(\boldsymbol{A}, \boldsymbol{B}, ‘valid’)$ 、宽卷积 $conv2(\boldsymbol{A}, \boldsymbol{B}, ‘full’)$。一般的是窄卷积，如果矩阵A的上下左右预先添加一些零向量，那么就是宽卷积。卷积操作得到的C就是特征图，也叫 $feature \; map$ 。在上面的CNN的构造图中，每一层是由多个$feature \; map$ 构成的，每个$feature \; map$ 中含有很多神经元。

3. 前向传播

3.1. 卷积层

假设当前层是 $l$，那么输入是：$\boldsymbol{U}_i^l$ $\boldsymbol{U}_i^l=\sum_{j=1}^{N_{l-1}}{ conv2(\boldsymbol{A}_j^{l-1}, \boldsymbol{K}_{ij}^l) + b_{ij}^l} \tag{1}$

输出： $ \boldsymbol{A}_i^l $ $\boldsymbol{A}_i^l =f(\boldsymbol{U}_i^l) \tag{2}$ （说明：英文字母的黑体大写表示矩阵，英文字母的非黑体小写表示标量。）

3.2. 池化层

输入：$\boldsymbol{U}_i^l$ $\boldsymbol{U}_i^l= \beta_i^l \cdot down(\boldsymbol{A}_i^{l-1})+b_i^l \tag{3}$

输出： $ \boldsymbol{A}_i^l $ $\boldsymbol{A}_i^l =f(\boldsymbol{U}_i^l) \tag{4}$

4. 误差反向传播

4.1. 全连接层

全连接层的反向传播求导和BP神经网络是一样的。 $\frac{\partial J}{ \partial \boldsymbol{W}^l} =\boldsymbol{\delta}^l ( \boldsymbol{x}^{l-1})^T \tag{5}$

$\frac{\partial J}{ \partial \boldsymbol{b}^l} =\boldsymbol{\delta}^l \tag{6}$

4.2. 卷积层

误差在卷积层的敏感性： $\begin{align*} \boldsymbol{\delta}_i^l & \stackrel{\rm def}{=} \tag{7} \frac{\partial J}{ \partial \boldsymbol{U}_i^l } \\ & = \frac{\partial J}{ \partial \boldsymbol{A}_i^l } \otimes \frac{\partial \boldsymbol{A}_i^l}{ \partial \boldsymbol{U}_i^l } \tag{8} \\ & = \frac{\partial J}{ \partial \boldsymbol{U}_i^{l+1} } \cdot \frac{\partial \boldsymbol{U}_i^{l+1}}{ \partial \boldsymbol{A}_i^l } \otimes f'(\boldsymbol{U}_i^l) \tag{9} \\ & = up(\boldsymbol{\delta}_i^{l+1}) \cdot \beta_i^{l+1} \otimes f'(\boldsymbol{U}_i^l) \tag{10} \\ & = \beta_i^{l+1} \cdot up(\boldsymbol{\delta}_i^{l+1}) \otimes f'(\boldsymbol{U}_i^l) \tag{11} \end{align*}$

在上面公式中，本来 $\frac{\partial J}{ \partial \boldsymbol{U}_i^{l+1} }$ 得到的是 $ \boldsymbol{\delta}_i^{l+1} $ ，但是 $ \boldsymbol{\delta}_i^{l+1} $ 和当前的卷积层的feature map的宽度和高度并不相同，这是因为之前采用了下采样操作，所以，为了保证能够和后面的矩阵相乘，需要对$ \boldsymbol{\delta}_i^{l+1} $ 做一个上采样操作。此外， $\beta_i^{l+1}$ 是一个标量，自然可以提到前面去。 $\otimes$ 运算是指两个矩阵的对应位置上的元素进行相乘，得到一个新的矩阵，它并不是矩阵的乘法运算。 $\boldsymbol{\delta}_i^l$ 是二维的。

误差对卷积层的参数求偏导数： $\frac{\partial J}{\partial b_{i}^l} = \sum_{s,t}{ (\boldsymbol{\delta}_i^l)_{st} } \tag{12}$

$\begin{align*} \frac{\partial J}{\partial \boldsymbol{K}_{ij}^l} & = \sum_{s,t}{ (\boldsymbol{\delta}_i^l)_{st} (P_j^{l-1})_{st}} \tag{13} \\ &=rot180( conv2(A_j^{l-1}, rot180 \big( \boldsymbol {\delta}_i^l)) \big) \tag{14} \end{align*}$

$(P_j^{l-1}){st}$ 是 $(\boldsymbol{\delta}_i^l){st}$ 所连接的 $l-1$ 层中 $\boldsymbol{A}_j^{l-1}$ 中相关的元素构成的矩阵。公式(14)是文献[2]中提到的。

4.3. 池化层

误差在池化层的敏感性： $\begin{align*} \boldsymbol{\delta}_i^l & \stackrel{\rm def}{=} \tag{15} \frac{\partial J}{ \partial \boldsymbol{U}_i^l } \\ & = \frac{\partial J}{ \partial \boldsymbol{A}_i^l } \otimes \frac{\partial \boldsymbol{A}_i^l}{ \partial \boldsymbol{U}_i^l } \tag{16} \\ & = \frac{\partial J}{ \partial \boldsymbol{U}_i^{l+1} } \cdot \frac{\partial \boldsymbol{U}_i^{l+1}}{ \partial \boldsymbol{A}_i^l } \otimes f'(\boldsymbol{U}_i^l) \tag{17} \\ & = \sum_{j=1}^{N_l}{f'(\boldsymbol{U}_i^l) \otimes conv2( \boldsymbol{\delta}_i^{l+1}, \boldsymbol{K}_{ij}^{l+1}) } \tag{18} \end{align*}$

误差对池化层的参数求偏导数： $\frac{\partial J}{\partial b_{i}^l} = \sum_{s,t}{ (\boldsymbol{\delta}_i^l)_{st} } \tag{19}$

$\frac{\partial J}{\partial \beta_i^l} = \sum_{s,t}{ (\boldsymbol{\delta}_i^l \otimes d_i^{l-1} )_{st}} \tag{20}$

其中，$d_i^{l-1}=down(A_i^{l-1})$ 。

5. 参考

[1] Introduction to Convolutional Neural Networks

[2] Notes on Convolutional Neural Networks

[3] Implementation of Training Convolutional Neural Networks

[4] http://blog.csdn.net/stdcoutzyx/article/details/41596663

[5] http://www.moonshile.com/post/juan-ji-shen-jing-wang-luo-quan-mian-jie-xi

[6] ImageNet Classification with Deep Convolutional Neural Networks

[7] Deep Convolutional Neural Networks for Image Classification

循环神经网络RNN

2017-04-02T00:00:00+08:00

1. RNN的网络结构

1.1 论文中$RNN$的结构

1.2 我的理解

以前我们的样本是作为一个向量直接输入模型的。现在RNN中，一个样本拆分成若干个向量的序列，比如，句子拆分成词向量序列，$60 \times 80$的图像可以看成从上到下有60个向量序列。

$RNN$ 的输入为$\big{ {x^0,x^1,…,x^t,x^{t+1},…} }$ ，而输出为$\big{ {y^0,y^1,…,y^t,y^{t+1},…} }$。这里的 $x^t$ 指的是 $t$ 时刻对应的那个单词的词向量。

想象一下，如果将神经网络展开，会得到若干层的网络。比如，对一个包含10个单词的句子，那么展开的网络便是一个10级的神经网络，每一级代表一个单词。单词需要向量化 $(ont-hot, word2vec ,\, blabla…)$

权值是共享的，所以实际上只有第一幅图展示的网络结构。

2. 模型推导

2.1 符号表示

样本 $x$ 可以表示成若干个序列$\big{ {x^1, x^2, …, x^t,…,x^T} \big}$, 向量 $x^t$ 的维度都是$D$。注意：为了简单起见，我们没有$bias$，因为使用的是增广向量。 $x_d^t$ 表示 $t$ 时刻输入向量 $x^t$ 在第 $d$ 个维度的值。 $\alpha_s^t , \, h_s^t$ 分别表示隐藏层的输入值和激活值。 $\beta_k^t, \, \hat{y}k^t$ 分别表示输出层的输入值和激活值。 $U{ds}$ 表示输入层到隐藏层的权重 $V_{sk}$ 表示隐藏层到输出层的权重 $W_{ss^{‘}}$ 表示隐藏层到隐藏层的权重

2.2 前向传播

$t$ 时刻的隐藏层

隐藏层的第 $s$ 个节点，它的输入来源有两个，一个是 $t$ 时刻的输入，另一个是 $t-1$ 时刻的历史信息。 $t$ 时刻隐藏层第 $s$ 个单元的输入值： $\alpha_s^t=\sum_{d=1}^D{ U_{ds} \cdot x_d^t+ \sum_{s^{'}}^S{ W_{s^{'}s} \cdot h_{s^{'}}^{t-1} } } \tag{1}$

$t$ 时刻隐藏层第 $s$ 个单元的激活值： $h_s^t=f(\alpha_s^t) \tag{2}$

$t$ 时刻的输出层

$t$ 时刻输出层第 $k$ 个单元的输入值： $\beta_k^t=\sum_{s=1}^S{V_{sk} \cdot h_s^t} \tag{3}$

$t$ 时刻输出层第 $k$ 个单元的激活值： $\hat{y}_k^t=g(\beta_k^t) \tag{4}$

2.3 激活函数

激活函数:双曲正切函数 $tanh$ $f(x)=\frac{e^x-e^{-x}} { e^x+e^{-x} } \tag{5}$ 双曲正切函数的导函数： $f^{'}(x)=1-\big( f(x) \big)^2 \tag{6}$
激活函数 $Sigmoid$： $f(x)=\frac{1}{1+e^{-x}} \tag{7}$ 其导函数为： $f^{'}(x)=f(x) \cdot \big( { 1-f(x) } \big) \tag{8}$

2.4 $Loss \,\, Function$

可以是重构误差： $\begin{align*} \mathcal{L}(\hat{y}, y)&=\frac{1}{2} \cdot \sum_{t=1}^T{ { \big \lVert { \hat{y}^t-y^t } \big \rVert }^2 } \tag{9} \\ & =\frac{1}{2} \cdot \sum_{t=1}^T{ \sum_{k=1}^K{ \big( { \hat{y}_k^t-y_k^t } \big) }^2} \tag{10} \end{align*}$
也可以是交叉熵误差： $\mathcal{L}(\hat{y}, y)=-\sum_{t=1}^T{ \sum_{k=1}^K{ y_k^t \cdot \log{ \hat{y}_k^t } +(1-{y}_k^t) \cdot \log{(1-\hat{y}_k^t)} } } \tag{11}$

2.5 反向传播

首先假设输出层单元的激活函数是 $g(x)$ ,隐藏层单元的激活函数是 $f(x)$ 。使用的 $Loss \,\, Function$ 是重构误差函数。

2.5.1 两个偏导数

误差对输出层输入值的偏导数 $\begin{align*} \delta_k^t & \stackrel{\rm def}{=} \frac{ \partial \mathcal{L} }{ \partial \beta_k^t } = \frac{\partial \mathcal{L}}{ \partial \hat{y}_k^t } \cdot \frac{\partial \hat{y}_k^t}{ \partial \beta_k^t } \tag{12} \\ & = \underline { \big( \hat{y}_k^t - y_k^t \big)} \cdot \underline { g^{'}(\beta_k^t)} \tag{13} \end{align*}$
误差对隐藏层输入值的偏导数隐层的误差，一部分来自于输出层，另一部分来自于下一时刻的隐藏层。 $\begin{align*} \delta_s^t & \stackrel{\rm def}{=}\frac{ \partial \mathcal{L} }{ \partial \alpha_s^t } = \sum_{k=1}^K{ \frac{\partial \mathcal{L}}{ \partial \beta_k^t } \cdot \frac{\partial \beta_k^t}{ \partial h_s^t } \cdot \frac{\partial h_s^t}{ \partial \alpha_s^t } } \tag{14} \\ & = \sum_{k=1}^K{ \delta_k^t \cdot V_{sk} \cdot f^{'}(\alpha_s^t) } \tag{15} \end{align*}$

2.5.2 误差对 $U ,\, V ,\, W$ 的梯度

误差对 $V$ 的梯度 $\begin{align*} \nabla V_{sk} &=\frac{ \partial \mathcal{L} }{ \partial V_{sk} } = \sum_{t=1}^T{ \frac{\partial \mathcal{L}}{ \partial \beta_k^t } \cdot \frac{\partial \beta_k^t}{ \partial V_{sk} } } \tag{16} \\ & = \sum_{t=1}^T{ \delta_k^t \cdot h_s^t } \tag{17} \end{align*}$
误差对 $W$ 的梯度 $\begin{align*} \nabla W_{s^{'}s} &=\frac{ \partial \mathcal{L} }{ \partial W_{s^{'}s} } = \sum_{t=1}^T{ \frac{\partial \mathcal{L}}{ \partial \alpha_s^t } \cdot \frac{\partial \alpha_s^t}{ \partial W_{s^{'}s} } } \tag{18} \\ & = \sum_{t=1}^T{ \delta_s^t \cdot h_{s^{'}}^{t-1} } \tag{19} \end{align*}$
误差对 $U$ 的梯度 $\begin{align*} \nabla U_{ds} &=\frac{ \partial \mathcal{L} }{ \partial U_{ds} } = \sum_{t=1}^T{ \frac{\partial \mathcal{L}}{ \partial \alpha_s^t } \cdot \frac{\partial \alpha_s^t}{ \partial U_{ds} } } \tag{20} \\ & = \sum_{t=1}^T{ \delta_s^t \cdot x_d^t } \tag{21} \end{align*}$

3. 参考

[1] http://ir.hit.edu.cn/~jguo/docs/notes/bptt.pdf [2] http://blog.csdn.net/u011414416/article/details/46709965

神经网络

2017-04-02T00:00:00+08:00

1. 标准的神经网络

神经单元上的非线性映射函数 $f$ 是 $sigmoid$ 函数： $f(x)=\frac{1}{1+e^{-x}} \tag{1}$

$sigmoid$ 函数的导函数很有特点： $f^{'}(x)=f(x) \cdot \big( 1-f(x) \big) \tag{2}$

2. 推导过程

2.1 $Loss \, Function$

$Loss \, Function$: $\ell(\hat{y}, y)=\sum_{k=1}^K{ \big( \hat{y}^{(k)}-y^{(k)}} \big)^2 \tag{3}$
样本 $(x_i, y_i)$ 在模型上的均方误差为： $E_i=\frac{1}{2} \sum_{k=1}^K{ \big( \hat{y}_i^{(k)} -y_i^{(k)}\big)^2 } \tag{4}$ 注意：$y_i^{(k)}$中的$k$是指第$k$个输出单元，并不是指$k$次方

2.2 权值的梯度

误差从输出层反传到隐层，推导$\nabla W_{ks}$

$\begin{align*} \nabla W_{ks} & = \frac{\partial E_i}{\partial W_{ks}} \tag{5} \\ & = \frac{\partial E_i}{\partial \hat{y}_i^{(k)} } \cdot \frac{\partial \hat{y}_i^{(k)}}{ \partial \beta^{(k)}} \cdot \frac{\partial \beta^{(k)}}{\partial W_{ks}} \tag{6} \\ & = \underline {(\hat{y}_i^{(k)}-y_i^{(k)}) } \cdot \underline { \hat{y}_i^{(k)} \cdot (1-\hat{y}_i^k)} \cdot \underline {h^{(s)}} \tag{7} \end{align*}$

误差从隐层反传到输入层，推导$\nabla V_{sd}$

$\begin{align*} \nabla V_{sd} & = \frac{\partial E_i}{\partial V_{sd}} \tag{8} \\ & = \frac{\partial E_i}{\partial h^{(s)} } \cdot \frac{\partial h^{(s)}}{ \partial \alpha^{(s)}} \cdot \frac{\partial \alpha^{(s)}}{\partial V_{sd}} \tag{9} \\ & = \underline{ \sum_{k=1}^K{\frac{\partial E_i}{\partial \beta^{(k)}}\cdot \frac{\partial \beta^{(k)}}{\partial h^{(s)}}} } \cdot \underline{ h^{(s)} \cdot (1-h^{(s)}) } \cdot \underline{ x_i^{(d)} } \tag{10} \\ & = \underline{ \sum_{k=1}^K{\hat{y}_i^{(k)}(1-\hat{y}_i^{(k)})(\hat{y}_i^{(k)}-y_i^{(k)})W_{hk}} } \cdot \underline{ h^{(s)} (1-h^{(s)}) } \cdot \underline{ x_i^{(d)} } \tag{11} \end{align*}$

2.3 $bias$ 的梯度

输出层的$\nabla bias$ $\begin{align*} \nabla b^{(k)}&=\frac{\partial E_i}{\partial b^{(k)}}=\frac{\partial E_i}{\partial \hat{y}_i^{(k)}} \cdot \frac{\partial \hat{y}_i^{(k)}}{\partial b^{(k)}} \tag{12} \\ &=\underline{(\hat{y}_i^{(k)}-y_i^{(k)})} \cdot \underline{ \hat{y}_i^{(k)} \cdot (1-\hat{y}_i^{(k)}) } \tag{13} \end{align*}$
隐藏层的$\nabla bias$ $\begin{align*} \nabla c^{(s)}&= \frac{ \partial E_i }{ \partial c^{(s)} }= \frac{\partial E_i}{\partial h^{(s)}} \cdot \frac{\partial h^{(s)}}{ \partial c^{(s)}} \tag{14}\\ &= \underline{ \sum_{k=1}^K{\frac{\partial E_i}{\partial \beta^{(k)}}\cdot \frac{\partial \beta^{(k)}}{\partial h^{(s)}}} } \cdot \underline{ h^{(s)} \cdot (1-h^{(s)}) } \tag{15} \\ &= \underline{ \sum_{k=1}^K{\hat{y}_i^{(k)}(1-\hat{y}_i^{(k)})(\hat{y}_i^{(k)}-y_i^{(k)})W_{hk}} } \cdot \underline{ h^{(s)} \cdot (1-h^{(s)}) } \tag{16} \end{align*}$

3. 伪代码（用梯度下降法）

梯度下降算法训练神经网络:

4. SGD

为了解决梯度下降算法训练样本输入数据太大，学习速度太慢的问题，产生了一种新的算法叫做随机梯度下降算法 $Stochastic \;\; Gradient \,\, Descent$ 。随机选取的m个输入样本, ${ x_1, x_2,…, x_m }$ 称作 $mini-batch$ 。

$\nabla W \approx \frac{1}{m} \cdot \sum_{i=1}^m{ \nabla W_{x_i}} \tag{17}$

梯度下降和SGD的区别：

–标准梯度下降是在权值更新前对所有样例汇总误差，而随机梯度下降的权值是通过考查某个训练样例来更新的

–在标准梯度下降中，权值更新的每一步对多个样例求和，需要更多的计算

–标准梯度下降，由于使用真正的梯度，标准梯度下降对于每一次权值更新经常使用比随机梯度下降大的步长

–如果标准误差曲面有多个局部极小值，随机梯度下降有时可能避免陷入这些局部极小值中

5. 向量化表示

为了实现神经网络方便，我们将其参数用矩阵或者向量表示。

5.1. 基础

黑体表示矢量或者矩阵，非黑体表示标量。假设当前层是 $l$，那么输入向量是：$\boldsymbol{z}^l$ $\boldsymbol{z}^l= \boldsymbol{W}^l \cdot \boldsymbol{a}^{l-1} + \boldsymbol{b}^l \tag{18}$

输出向量是：$ \boldsymbol{a}^l $ $\boldsymbol{a}^l= f(\boldsymbol{z}^l ) \tag{19}$

5.2. 推导

神经网络的损失在 $l$ 层上的传播误差向量化形式为：

$\boldsymbol{\delta}^l \stackrel{\rm def}{=} \frac{\partial J}{ \partial \boldsymbol{z}^l } = \begin{bmatrix} \delta_1^l \\ \delta_2^l \\ ...\\ \delta_n^l \end{bmatrix} = \begin{bmatrix} \frac{\partial J}{ \partial a_1^l } \dot \\ \frac{\partial a_1^l}{ \partial z_1^l } \\ \frac{\partial J}{ \partial a_2^l } \dot \\ \frac{\partial a_2^l}{ \partial z_2^l } \\ ...\\ \frac{\partial J}{ \partial a_n^l } \dot \\ \frac{\partial a_n^l}{ \partial z_n^l } \\ \end{bmatrix} = \begin{bmatrix} \frac{\partial J}{ \partial a_1^l } \\ \frac{\partial J}{ \partial a_2^l } \\ ...\\ \frac{\partial J}{ \partial a_n^l } \\ \end{bmatrix} \otimes \begin{bmatrix} f'(z_1^l) \\ f'(z_2^l) \\ ...\\ f'(z_n^l) \\ \end{bmatrix} \\ = \frac{\partial J}{ \partial {\boldsymbol{a}}^l } \otimes \boldsymbol{f}'(\boldsymbol{z}^l) \tag{20}$

当 $l=L$ 时候， $\boldsymbol{\delta}^L = \frac{\partial J}{ \partial \boldsymbol{a}^L } \otimes \boldsymbol{f}'(\boldsymbol{z}^L) = (\boldsymbol{\hat{y}} - \boldsymbol{y}) \otimes \boldsymbol{f}'(\boldsymbol{z}^L) \tag{21}$

当 $l \not = L$ 时候， $\boldsymbol{\delta}^l = \frac{\partial J}{ \partial \boldsymbol{a}^l } \otimes \boldsymbol{f}'(\boldsymbol{z}^l) = \underline{ \frac{\partial J}{ \partial \boldsymbol{z}^{l+1}} \cdot \frac{\partial \boldsymbol{z}^{l+1}}{ \partial \boldsymbol{a}^l } } \otimes \boldsymbol{f}'(\boldsymbol{z}^L) = \underline{ \boldsymbol{\delta}^{l+1} \boldsymbol{W}^{l+1} } \otimes \boldsymbol{f}'(\boldsymbol{z}^l) \tag{22}$

对参数 $\boldsymbol{W} $ 的偏导数：

由于 $J$ 对 $w_{ij}^l$的导数为： $\frac{\partial J}{ \partial w_{ij}^l} = \frac{\partial J}{ \partial z_i^l} \cdot \frac{\partial z_i^l}{ \partial w_{ij}^l} = \delta_i^l \cdot a_j^{l-1} \tag{23}$

所以，总的损失对 $l$ 层的权重矩阵的偏导数为：

$\frac{\partial J}{ \partial \boldsymbol{W}^l } = \begin{bmatrix} \delta_1^l \cdot \boldsymbol{a}^{l-1} \\ \delta_2^l \cdot \boldsymbol{a}^{l-1} \\ ...\\ \delta_n^l \cdot \boldsymbol{a}^{l-1} \end{bmatrix} = \begin{bmatrix} \delta_1^l \\ \delta_2^l \\ ...\\ \delta_n^l \end{bmatrix} \cdot \left[a_1^l,a_2^l,...,a_m^l \right]= \boldsymbol{\delta}^l \cdot (\boldsymbol{a}^{l-1})^T \tag{24}$

对 $ \boldsymbol{b} $ 的偏导数：

由于 $J$ 对 $b_{i}^l$的导数为： $\frac{\partial J}{ \partial b_{i}^l} = \frac{\partial J}{ \partial z_i^l} \cdot \frac{\partial z_i^l}{ \partial b_{i}^l} = \delta_i^l \tag{25}$

所以，$J$ 对 $\boldsymbol{b}^l$的偏导数为： $\frac{\partial J}{ \partial \boldsymbol{b}^l} = \boldsymbol{\delta}^l \tag{26}$

Jarlonyan

Hinge Loss和SVM

1. Hinge Loss

2. SVM、软间隔和正则化

Logistic Regression推导

1.已知

2. 推导过程

3. 求解方法

3.1 梯度下降法

3.2 牛顿法

ROC和AUC

1. 精确度、召回率、准确率

2. PR曲线和ROC曲线

matplotlib数据可视化

1.画点状图

2.柱状图

3.折线图

4.画多个子图

5.带有颜色深浅的散点图：

6.颜色

7.点的形状

8.线的形状

9. 画网络图

networkx社交网络包

1. 一个demo

1.1 先建立一个网络

1.2. 用matplotlib将网络画出来

2 network的一些常用方法

2.1 网络结构的创建

2.2 网络结构的属性

2.3 读写gml文件

pandas数理统计

1. 造表DataFrame

2. 增加一行

3. 删除行

4. 表的选择select

5. dataframe遍历

6. 根据一列生成另外一列

7. 取子表

8. 取表的单独一个属性列

9. 聚合操作group by

10. 两个表连接

11. 改变一个列的值的类型

12. 排序，根据某一列排序

13. apply, applymap, map函数

14. 打乱dataframe

15. 去除重复的行

16. pandas读写文件

python学习

1、基础知识

1.1 常用安装命令

2. Python数据结构

2.1 元组tuple

2.2 列表list

2.3 集合set

2.4 字典dict

3. Python奇淫技巧

3.1 求两个list的交集，并集，差集

3.2 优先权队列的用法

3.3 import 包

3.4 排序

3.5 列表推导

3.6 is和==的区别

3.7 进度条

4、高级话题

4.1 Python特殊语法： lambda 、 filter 、 map 、 reduce

4.2 闭包

4.3 赋值、浅拷贝、深拷贝

卷积神经网络

1. 卷积神经网络

1. CNN基本结构

2. 基础知识

2.1 局部感受野

2.2 参数共享

2.3 卷积操作

3. 前向传播

3.1. 卷积层

3.2. 池化层

4. 误差反向传播

4.1. 全连接层