Implement of "Single Image Haze Removal Using Dark Channel Prior"

compute dark channel

1
2
3
4
import cv2
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
1
2
3
4
src=cv2.imread('haze_img/9.jpg')
plt.title('src')
plt.axis('off')
plt.imshow(src[:,:,::-1])

png

1
2
3
4
5
6
7
8
9
10
11
12
def compute_dark_channel(img,patch_size=15):
    h,w=img.shape[:2]
    b, g, r = cv2.split(img)
    bgr_min_img = cv2.min(cv2.min(b, g), r)
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (patch_size,patch_size))
    dark_channel_img = cv2.erode(bgr_min_img, kernel)
    return dark_channel_img
dark_channel_img=compute_dark_channel(src,patch_size=15)
plt.title('dark_channel_img')
plt.axis('off')
plt.imshow(dark_channel_img,cmap='gray')

png

compute atmosphere

We first pick the top 0.1% brightest pixels in the dark channel. Among these pixels, the pixels with highest intensity in the input image I is selected as the atmospheric light.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def compute_atmosphere_light(img,dark_channel_img):
    h,w=dark_channel_img.shape[:2]
    num_of_candiate=int(0.001*h*w)
    dark_channel=dark_channel_img.reshape(-1,1)[:,0]
    arg_sorted=np.argsort(dark_channel)[::-1]
    img=img.astype(np.float32)
    atmosphere_light=np.zeros((3,))
    for i in range(num_of_candiate):
        index=arg_sorted[i]
        row_index=index//w
        col_index=index%w
        for c in range(3):
            atmosphere_light[c]=max(atmosphere_light[c],img[row_index,col_index][c])
    return atmosphere_light
atmosphere_light=compute_atmosphere_light(src,dark_channel_img)
print(atmosphere_light)
[255. 252. 249.]

Estimate the Transmission and Soft Matting

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def guied_filter(I,P,radius,epsilon):
    window_size=2*radius+1
    meanI=cv2.blur(I,(window_size,window_size))
    meanP=cv2.blur(P,(window_size,window_size))
    II=I**2
    IP=I*P
    corrI=cv2.blur(II,(window_size,window_size))
    corrIP=cv2.blur(IP,(window_size,window_size))
    varI=corrI-meanI**2
    covIP=corrIP-meanI*meanP
    a=covIP/(varI+epsilon)
    b=meanP-a*meanI
    meanA=cv2.blur(a,(window_size,window_size))
    meanB=cv2.blur(b,(window_size,window_size))
    transmission_rate=meanA*I+meanB
    return transmission_rate
1
2
3
4
5
6
7
8
def compute_transmission_rate(img,atmosphere_light_max,dark_channel_img,omega=0.95,guided_filter_radius=50,epsilon=0.0001):
    h,w=img.shape[:2]
    img_gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    zero_mat=np.zeros((h,w))
    transmition_rate_est=cv2.max(zero_mat,np.ones_like(zero_mat)-omega*dark_channel_img/atmosphere_light_max)
    #transmission_rate = guied_filter(img_gray,transmition_rate_est, guided_filter_radius, epsilon)
    transmission_rate=cv2.ximgproc.guidedFilter(img_gray.astype(np.float32),transmition_rate_est.astype(np.float32),guided_filter_radius,epsilon)
    return transmission_rate
1
2
3
4
transmission_rate=compute_transmission_rate(src,np.max(atmosphere_light),dark_channel_img)
plt.title('transmission_rate')
plt.axis('off')
plt.imshow(transmission_rate,cmap='gray')

png

Recovering the Scene Radiance

1
2
3
4
5
6
7
8
9
10
min_transmission=0.1
transmission_rate[transmission_rate<min_transmission]=min_transmission
dehaze_img=np.zeros_like(src,dtype=np.uint8)
for c in range(3):
    dehaze_img[:,:,c]=(src[:,:,c]-atmosphere_light[c])/transmission_rate+atmosphere_light[c]
dehaze_img[dehaze_img>255]=255
dehaze_img[dehaze_img<0]=0
plt.title('dehaze')
plt.axis('off')
plt.imshow(dehaze_img[:,:,::-1])

png

Reference

[1] He K, Sun J, Tang X. Single image haze removal using dark channel prior[C]// Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on. IEEE, 2009:1956-1963.
[2] He K, Sun J, Tang X. Guided Image Filtering[M]// Computer Vision – ECCV 2010. Springer Berlin Heidelberg, 2010:1397-1409.

展开全文 >>

GeoMAN

GeoMAN:Multi-level Attention Networks for Geo-sensory Time Series Predicti on 论文笔记

论文亮点

在encoder阶段加入两种类型的attention机制，包括local attention和global attention，分别学到同一sensor内各个特征之间的关系，以及不同sensor之间的关系。Decoder阶段的temporal attention机制学习到序列时序之间的关系。加入外部因子融合模块。
总的来说：GeoMAN的网络结构以Encoder-Decoder作为基础结构，Encoder阶段加入了spatio attention（包括local attention和global attention),Decoder阶段加入了tempral attention和external attention。

Attention细节

文中用到的符号：$Y=(y^1,y^2,…,y^{N_g})\in R^{N_g \times T}$表示所有sensor测量到的在T时间序列内的数据。其中$y^i\in R^T$表示sensor i的测量值。使用$X^i=(x^{i,1},x^{i,2},…,x^{i,N_l})^{T}=(x_1^i,x_2^i,…,x_T^i)\in R^{N_l\times T}$表示sensor i的local features。将所有sensor的local feature组合在一起，得到global feature,$\chi={X^1,X^2,…,X^{N_g}}$以此作为sensor i的global 特征。

Spatio Attention

Local Attention

Local Attention的目的是找出同一个sensor之间不同特征的权重关系，遵循以下方法来进行：
$e_t^k=v_l^T tanh(W_l[h_{t-1};s_{t-1}]+U_lx^{i,k}+b_l)$
根据$\alpha_t^k=\frac{exp(e_t^k)}{\sum_{j=1}^{N_l}exp(e_t^j)}$计算特征k的权重，这里其实就是一个softmax函数。
最后得到：
$x_t^{local}=(\alpha_t^1x_t^{i,1},\alpha_t^2x_t^{i,2},…,\alpha_t^{N_l}x_t^{i,N_l})^T$
上述公式中，$v_l,b_l\in R^T$,$W_l\in R^{T\times 2m}$,$U_l\in R^{T\times T}$

Global Attention

主要目的是找到不同sensor测量的特征之间的关系。
对于目标sensor i和另一个sensor l,通过以下式子计算attention的权重。
$g_t^l=v_g^T tanh(W_g[h_{t-1};s_{t-1}]+U_gy^l+W_g’X^lu_g+b_g)$
其中，$v_g,u_g,b_g \in R^T$,$W_g \in R^{T\times 2m}$,$U_g\in R^{T\times T}$,$W_g’\in R^{T\times N_l}$都是需要学习的参数。
另外还加入一个矩阵$P\in R^{N_g\times N_g}$来表征地理空间的相似性。
最后，和local attention机制类似，将权重用softmax整合起来。
$\beta _t^l=\frac{exp((1-\lambda)g_t^l+\lambda P_{i,l})}{\sum _{j=1}^{N_g}exp((1-\lambda)g_t^j+\lambda P_{i,j})}$
然后$x_t^{global}=(\beta_t^1y_t^1,\beta_t^2y_t^2,…,\beta_t^{N_g}y_t^{N_g})^T$

Tempral Attention

解决时序过长时，Encoder-Decoder性能下降的问题。
$u_{t’}^o=v_d^Ttanh(W_d’[d_{t’-1};s_{t’-1}’]+W_dh_o+b_d)$
$\gamma_{t’}^o=\frac{exp(u_{t’}^o)}{\sum_{j=1}^{T}exp(u_{t’}^j)}$
$c_{t’}=\sum_{o=1}^{T}\gamma_{t’}^oh_o$
其中$W_d\in R^{m\times m}$,$W_d’\in R^{m\times 2n}$,$v_d,b_d\in R_m$是可以学习的参数。

External Attention

将各种外界的影响因素，embedding起来。
$ex_{t’}\in R^{N_e}$,其中t’是decoder中的未来时间点。

Encoder-Decoder结构

Encoder阶段

将local attention和global attention的结果concat起来作为Encoder的输入。
$x_t=[x_t^{local};x_t^{global}]$,其中$x_t\in R^{N_l+N_g}$,然后根据$h_t=f_e(h_{t-1},x_t)$更新hiddent state，其中$f_e$是LSTM单元。

Decoder阶段

在Decoder阶段，根据t’时刻的加权求和的上下文向量$c_{t’}$，加上$ex_{t’}$和$y_{t’-1}^i$来更新decoder的hidden state，$d_{t’}=f_d(d_{t’-1},[y_{t’-1}^i;ex_{t’};c_{t’}])$,其中$f_d$是decoder中使用的LSTM单元。然后使用下式得到$y_{t’}^i$,$y_{t’}^i=v_y^T(W_m[c_{t’};d_{t’}]+b_m)+b_y$其中$W_m\in R^{n\times ( m+n)}$,$b_m\in{R^n}$将$[c_{t’};d_{t’}]\in R^{m+n}$映射到hidden state的尺度。最后用线性变换产生最后的预测输出。

实验结果

使用MSE作为损失函数，最后的实验结果详见原论文。在其所用数据集上达到了state-of-the-art。

源码阅读及实现

官方tensorflow 实现学习

pytorch 实现

参考资料

1、原论文 GeoMAN: Multi-level Attention Networks for Geo-sensory Time Series Prediction
2、官方Tensorflow实现

展开全文 >>

用Seq2Seq做时间序列预测

Useful Blogs

1、keras-seq-2-seq-signal-prediction
2、seq2seq-signal-prediction
3、ts_seq2seq_intro/
4、https://github.com/Arturus/kaggle-web-traffic
5、Sequence to Sequence Learning with Neural Networks Paper
6、Attention is All You Need paper
7、https://pytorch.org/tutorials/intermediate/seq2seq_translation_tutorial.html
8、https://github.com/Arturus/kaggle-web-traffic/blob/master/how_it_works.md
9、https://github.com/skyhuang1208/kaggle-web-traffic-time-series-forecasting
10、https://www.analyticsvidhya.com/blog/2018/02/time-series-forecasting-methods/
11、https://www.analyticsvidhya.com/blog/2018/08/auto-arima-time-series-modeling-python-r/
12、http://chandlerzuo.github.io/blog/2017/11/darnn
13、A Dual-Stage Attention-Based Recurrent Neural Network for Time Series Prediction
14、https://github.com/yoshall/GeoMAN

Tips

1、注意RNN中Many-to-Many 和 Encoder-Decoder模型的区别。Many-to-Many是一个整体的模型，而Encoder-Decoder是将模型分为不同的Encoder-Decoder两个部分。
2、尝试将Encoder和Decoder的结构设为不同，如将hidden_size以及layers设为不同，如果hidden_size设为不同，需要在Encoder最后加一个全连接层，将输出维度与Decoder的输入维度匹配。
3、尝试使用attention模块。
4、

AI challenge 2018 天气预报赛题

一些尝试

Baseline

使用fbprophet根据年、日变化特征预测

Seq2Seq的思路

数据分析

分析t2m_obs,rh2m_obs,w10m_obs三个特征的变化趋势，以及与其他特征之间的一些关系

特征选择

初步：9个obs特征+时刻特征+月份特征+31个M特征
其中时刻特征和月份特征因为涉及到循环，如23时和0时应该在数值上相邻，于是使用cos，sin来编码。
如下面这样：

1
2
3
hour_period = 24 / (2 * np.pi)
validation_data['hour_cos'] = np.cos(validation_data.index.hour / hour_period)
validation_data['hour_sin'] = np.sin(validation_data.index.hour / hour_period)

模型建立

使用Encoder-Decoder组成的Seq2Seq结构，以前108个时间段的所有特征作为输入，以待预测的推移36个时间段的3个目标特征作为输出。
Encoder阶段使用LSTM 第一步：将输入维度变化到与LSTM的隐藏层相同，一种思路是使用全连接层，一种是使用LSTM input_size=输入维度，hidden_size=LSTM。第二步：使用多层LSTM stack。尝试过3层，5层。
Decoder阶段：以Encoder阶段的最后一个隐藏层输入作为隐藏层，Input目前选择初始化为全零。也是多层LSTM,最后使用Decoder阶段的output作为输入的一部分。
Attention Module：加入attention module，将Encoder阶段的outputs，与Decoder中的LSTM的outputs作为attention模块输入，输出最后的output。
加上一层全连接层将维度进行转换。

目前的测试结果来看：效果不理想，存在过拟合的现象，训练loss降低的情况下，验证的loss反而升高了。尝试dropout，似乎对结果没有提升。

尝试改进措施

1、尝试Decoder阶段的Input不为零，改用其它有意义的信息，需要再看资料解决。（Decoder inputs in Seq2Seq Model）（input特征已经加入，正在尝试效果）应该实现位移一位？
2、参数初始化问题
3、一个可能的思路：最后输出之前，加入待预测特征的前一年同一时刻(24365-1h到24365+1h)前后共3小时的观测数据值、前一天（23-25h前）前后3小时的观测数据值、用fbprophet预测的该时刻的观测值。这些特征与输出拼接起来，再加入一个全连接层，作为最后的输出。（相当于手动加入历史数据及变化趋势数据并线性组合起来）：已经加入了前一天的观测数据作为辅助，fbprophet预测的数据尚未加入。

最新模型想法：
以fbprophet预测的t2m,rh2m,w10m数据作为Decoder的inputs。
最后一层融合的数据包括 前一天（23-25h之前）的观测数据，以及fbprophet预测的观测值。
即把fbprophet预测的值用在了两个地方，一是作为Decoder部分的输入，一是作为最后融合特征的一部分。
先尝试这个模型的效果。

然后考虑进一步的优化方向：
1、加入更多的数据特征，（即将M类信息也作为特征输入）
2、考虑更鲁棒的填充缺失值算法。如使用prophet辅助填充缺失值。
3、考虑取出outliners，将太过明显的噪声滤掉，替换为更平滑的数据。

最新模型的特点：Encoder-Decoder作为基础结构，以input sequence作为decoder的input输入
新的想法：分析各个因素之间的相关性，添加相关性较强的特征作为因素

Decoder Inputs选用当前 input的 t2m_obs,rh2m_obs,w10m_obs,t2m_M,rh2m_M,w10m_M,t2m_prophet,rh2m_prophet,w10m_prophet,hour_sin,hour_cos,month_sin,month_sin作为输入。
Decoder output之后，将等待预测时刻的t2m_M,rh2m_M,w10m_M,t2m_prophet,rh2m_prophet,w10m_prophet与output融合，作为最后输出。（使用depth_wise 1D conv实现融合）
融合策略如何改进？

改进措施：
比较MinMaxScaler和StandardScaler

分析数据，去掉outlines

尝试GeoMAN中的attention方法

展开全文 >>

Chapter 4. Training Models

前面几章在不知道具体原理的情况下，我们已经使用sklearn搭建模型并解决了一些实际问题，这章介绍一些原理，以便我们更好地选择算法模型。

1 Linear Regression

线性回归的基本形式：

它的向量化的形式是：

MSE损失函数：

1.1 The Normal Equation

线性回归是有闭式解使得损失函数的值最小的，它的形式如下：

使用numpy测试

1
2
3
4
5
6
7
8
9
import numpy as np
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
X_b = np.c_[np.ones((100,1)), X] # add x0 = 1 to each instance
theta_best = np.linalg.inv(X_b.T.dot(X_b)).dot(X_b.T).dot(y)
>>> theta_best
array([[4.21509616],
        [2.77011339]])

用sklearn测试

1
2
3
4
5
from sklearn.linear_model import LinearRegression
lin_reg = LinearRegression()
lin_reg.fit(X, y)
>>> lin_reg.intercept_, lin_reg.coef_
(array([4.21509616]), array([[2.77011339]]))

1.2 Computational Complexity

闭式解的计算需要对矩阵求逆，其复杂度是和实例的数量以及特征的数量成正比的。

2 Gradient Descent

梯度下降是寻找局部最优的一种常见方法，其思想就是迭代参数使得loss下降。关于梯度下降，因为已经了解，不做过多笔记。使用梯度下降的时候，需要保证所有的特征都有相似的尺度。

2.1 Batch Gradient Descent

对线性回归的MSE求梯度，

这是一个向量化的操作，它对整个训练集X求梯度，所以称为Batch Gradient Descent。
参数更新如下：

算法实现

1
2
3
4
5
6
7
8
9
10
11
eta = 0.1 
n_iterations = 1000
m = 100
theta = np.random.randn(2,1)
for iteration in range(n_iterations):
    gradients = 2/m*X_b.T.dot(X_b.dot(theta)-y)
    theta = theta - eta * gradients
>>> theta
array([4.21509616],
    [2.77011339])

可见针对线性回归问题，使用梯度下降的方法和闭式解相同。值得注意的是，学习率需要合理设置，过高容易越过最优解，而过低则收敛太慢。合理设置迭代次数也极为重要，通常的好做法是设置比较大的iterations，当参数变化极微弱时即可中断操作，可以认为此时达到了局部最优解。

2.2 Stochastic Gradient Descent

Batch Gradient Descent的一个缺点就是它将训练集作为整体进行训练，当训练集太大时，速度会很慢。随机梯度下降则在训练时随机选择一个实例对其计算梯度，然后进行优化，这样速度很快，当然，由于其每次只用一个实例进行训练，它并不能做到每次迭代都使loss减小，并且即便函数到达全局最优，它还是可以继续运算下去，所以它只能得到一个近似的最优解。它的特点就是可以跳过局部最优，但是同时这也就意味着它也能跳过全局最优。一种解决方案是逐渐减小学习率，叫做simulated annealing
实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n_epochs = 50
t0, t1 = 5, 50
def learning_schedule(t):
    return t0 / (t + t1)
theta = np.random.randn(2,1)
for epoch in range(n_epochs):
    for i in range(m):
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients

最后计算得到

1
2
3
>>> theta
array([[4.21076011],
    [2.74856079]])

使用sklearn实现如下：

1
2
3
4
5
from sklearn.linear_model import SGDRegressor
sgd_reg = SGDRegressor(n_iter=50, penalty=None, eta0=0.1)
sgd_reg.fit(X,y.ravel())
>>> sgd_reg.inercept_,sgd_reg.coef_
(array([4.18380366]), array([2.74285299]))

2.3 Mini-batch Gradient Descent

Mini-batch是前两种方式的折中，不过多笔记了。
几种训练方法比较

3 Polynomial Regression

多项式回归

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
m = 100
X = 6 * np.random.rand(m,1) - 3
y = 0.5 * X**2 + X + 2 + np.random.randn(m,1)
#使用sklearn包进行拟合
from sklearn.preprocessing import PolynomialFeatures
poly_features = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly_features.fit_transform(X)
>>> X[0]
array([-0.75275929])
>>> X_poly[0]
array([-0.75275929, 0.56664654])
# 下面进行线性回归
lin_reg = LinearRegression()
lin_reg.fit(X_poly, y)
>>> lin_reg.intercept_,lin_reg.coef_
(array([1.78134581]),array([[0.93366893, 0.56456263]]))

4 Learning Curves

可以通过绘制训练集和验证集的学习曲线来判断模型的拟合情况。
some tricks
1 如果模型在训练集上是欠拟合的，添加更多训练数据并没有用，我们需要做的是使用更复杂的模型或者是利用更多的features。
2 提升一个过拟合模型的性能的一种有效方法是添加更多的训练数据，直到训练误差接近验证误差。
The Bias/Variance Tradeoff
泛化误差的三个主要组成部分：
Bias：来源于错误的假设，比如数据是线性的，假设为二次多项式造成的泛化误差。
Variance：来源于训练过程中，模型对数据中微小变化的敏感性。
Irreducible error：来源于数据的噪声。解决方法只能是数据清洗，如去除outliners等。

5 Regularized Linear Models

介绍线性模型中的一些正则化方法，来抑制过拟合。

5.1 Ridge Regression

在损失函数中添加正则项：

Trick：使用Ridge Regression之前先对数据进行scale是很有必要的，因为该模型对输入数据尺度敏感。对于大多数正则化模型来说都是这样。

Ridge Regression的闭式解

1
2
3
4
5
6
7
8
from sklearn.linear_model import Ridge
# 使用闭式解
ridge_reg = Ridge(alpha=1,  solver='cholesky')
ridge_reg.fit(X,y)
# 使用SGD
sgd_reg = SGDRegressor(penalty='l2')
sgd_reg.fit(X,y.ravel())

5.2 Lasso Regression

Least Absolute Shrinkage and Selection Operator Regression
同样是在loss function添加正则项。

Lasso倾向于使得不重要的特征的权重接近0，也就是说，它能够自动进行特征选择，并且输出为稀疏矩阵。

1
2
from sklearn.linear_model import Lasso
lasso_reg = Lasso(alpha=0.1)

5.3 Elastic Net

对Ridge和Lasso的折中，既惩罚一次项，也惩罚二次项。

1
2
from sklearn.linear_model import ElasticNet
elastic_net = ElasticNet(alpha=0.1, l1_ratio=0.5)

5.4 Early Stopping

训练过程中，验证误差达到某个阈值时停止训练。

6 Logistic Regression

Logistic Regression的作用就是不直接输出预测分数，而是加上一个logistic函数使得输出在0到1之间，作为概率的度量。

6.1 Estimating Probabilities

6.2 Training and Cost Funtion

这个式子没有闭式解， 但是其是凸函数，所以可以用梯度下降求出解。
其偏导数如下：

1
2
log_reg = LogisticRegression()
# 也可对Logistic Regression添加正则项

6.3 Decision Boundaries

6.4 Softmax Regression

使得Logistic Regression支持多分类，也叫作Multinomial Logistic Regression。
算法思路
首先对每类计算score

然后计算每类的概率：

其类别预测方法：

使用Cross Entropy 作为损失函数：

偏导数如下计算：

调包

1
2
softmax_reg = LogisticRegression(multi_class='multinomial', solver='lbfgs',C=10)
softmax_reg.fit(X,y)

参考

1、Hands-On Machine Learning with Scikit-Learn and TensorFlow by Aurélien Géron (O’Reilly). Copyright 2017 Aurélien Géron, 978-1-491-96229-9

展开全文 >>

Linux下安装netCDF4过程记录

netCDF4官方指南

HDF5安装

HDF5网站
INSTALL FILE
1、在HDF5网站上下载hdf5-1.10.3.tar.gz源码
2、在Ubuntu16.04上安装HDF5
使用以下安装脚本

1
2
3
4
5
6
7
tar zxf hdf5-1.10.3.tar.gz
cd hdf5-1.10.3
./configure --prefix=/usr/local/hdf5  --enable-hl --enable-shared
make
make check                # run test suite.
make install
make check-install        # verify installation.

如果遇到安装失败，可能需要sudo make

netCDF-4 C library 安装

netCDF-4 C github repo
Build Instruction
1、下载netcdf-c-4.6.1.tar.gz
2、安装
使用以下脚本

1
2
3
4
5
6
7
8
# Build and install netCDF-4
tar zxf netcdf-c-4.6.1.tar.gz
cd netcdf-c-4.6.1
NCDIR=/usr/local
H5DIR=/usr/local/hdf5
CPPFLAGS=-I${H5DIR}/include LDFLAGS=-L${H5DIR}/lib ./configure --prefix=${NCDIR} --enable-netcdf-4 --enable-shared
sudo make check
sudo make install  # or sudo make install

3、遇到问题：使用git clone下来的源码，没有configure，无法build。

安装netCDF4 python包

1
USE_SETUPCFG=0 HDF5_INCDIR=/usr/include/hdf5/serial HDF5_LIBDIR=/usr/lib/x86_64-linux-gnu/hdf5/serial pip3 install netCDF4

展开全文 >>

Chapter 3. Classification

《 Hands-On Machine Learning with Scikit-Learn and TensorFlow》笔记

MNIST

MNIST数据集介绍及载入

Training a Binary Classifier

使用sklearn包训练二分类器

1
2
3
4
5
6
7
8
y_train_5 = (y_train == 5)
y_test_5 = (y_test == 5)
from sklearn.linear_model import SGDClassifier
sgd_clf = SGDClassifier(random_state=42)
sgd_clf.fit(X_train, y_train_5)
>> sgd_clf.predict([some_digit])
array([True], dtype=bool)

Performance Measures

3.1 利用交叉验证(Cross-Validation)来验证模型

有用函数: sklearn包中的cross_val_score

1
2
from sklearn.model_selection import cross_val_score
cross_val_score(sgd_clf, X_train, y_train_5, cv=3, scoring='accuracy')

3.2 混淆矩阵(Confusion Matrix)

使用函数 cross_val_predict和confusion_matrix计算混淆矩阵

1
2
3
4
5
6
7
from sklearn.model_selection import cross_val_predict
y_train_pred=cross_val_predict(sgd_clf, X_train, y_train_5, cv=3)
from sklearn.metrics import confusion_matrix
cm=confusion_matrix(y_train_5,y_train_pred)
>>> cm
>>> array([[53272, 1307],
    [1077, 4344]])

3.3 准确率和召回率

准确率(Precision)
召回率(Recall)
F1分数(F1 score)

1
2
3
4
5
6
7
>>> from sklearn.metrics import precision_score, recall_score,f1_score
>>> precision_score(y_train_5, y_pred)
0.768
>>> recall_score(y_train_5,y_train_pred)
0.791
>>> f1_score(y_train_5, y_pred)
0.784

F1 score favors classifiers that have similar precision and recall.

3.4 Precision/Recall Tradeoff

分类器在做预测时根据预测的分数来决定时属于正类还是反类,我们需要设定一个分数阈值(threshold)来作为划分,低阈值的选取对应高的recall和低的precision,而高阈值的选取对应了高的precision和低的recall。
实践中我们可以使用sklearn中的decsion_function获得分数，并指定分类阈值。

1
2
3
4
5
6
>>> y_scores = sgd_clf.decision_function([some_digit])
>>> y_scores
array([161855.555])
>>> threshold = 0
>>> y_some_digit_pred = (y_scores > threshold)
array([ True], dtype=bool)

还可以使用precision_recall_curve计算recall、precision曲线。
根据recall、precision曲线，我们就可以按照特定的场景需求来合理选择阈值。

3.5 The ROC Curve

和准确率/召回率曲线类似，其是衡量 true positive rate(TPR) 和false negative rate的关系.

1
2
from sklearn.metrics import roc_curve
fpr, tpr, thresholds = roc_curve(y_train_5, y_scores)

该曲线包围的面积(area under the curve(AUC))越大,说明分类器越好.

1
2
3
>>> from sklearn.metrics import roc_auc_score
>>> roc_auc_score(y_train_5, y_scores)
0.9706

3.5 总结

训练二分类器的一般流程如下:
1、选择合适的metrics作为评价指标
2、 使用交叉验证训练模型
3、取得precision/recall的平衡来满足需求
4、利用ROC curves和ROC AUC scores来比较不同模型的性能

Multiclass classification

一些算法可以直接进行多分类，如随机森林、朴素贝叶斯等，而另外一些算法只能进行二分类，如支持向量机、线性分类器等。
有很多策略可以将二分类算法推广到多分类任务中：
one-versus-all(OvA): 训练N个二分类器，每个二分类器负责预测一个label。
one-versus-one(OvO):训练N*(N-1)个二分类器，每个二分类器负责预测一对label。
对于SVM来说，使用OvO策略更好，对于绝大多数算法，更推荐使用OvA策略。
sklearn包针对多分类任务自动选择OvA策略(SVM例外)。

1
2
3
4
5
6
7
8
9
10
>>> sgd_clf.fit(X_train, y_train)
>>> sgd_clf.predict([some_digit])
array([5.])
>>> some_digit_scores = sgd_clf.decision_function([some_digit])
>>> some_digit_scores
array([[...
]])
>>> np.argmax(some_digit_scores)
5

也可以使用OneVsOneClassifier或者OneVsRestClassifier类自定义策略。

1
2
3
4
5
6
7
>>> from sklearn.multiclass import OneVsOneClassifier
>>> ovo_clf = OneVsOneClassifier(SGDClassifier(random_state=42))
>>> ovo_clf.fit(X_train,y_train)
>>> onv_clf.predict([some_digit])
array([5.])
>>> len(ovo_clf.estimators_)
45

对于随机森林等可以直接进行多分类，不需要使用OvO或者OvA策略。

1
2
3
4
5
6
>>> forest_clf.fit(X_train, y_train)
>>> forest_clf.predict([some_digit])
array([5.])
# 可以使用predict_proba方法得到预测各类的概率
>>> forest_clf.predict_proba([some_digit])
array([[0.1, 0., 0., 0.1, 0., 0.8, ...]])

Error Analysis

找到合适的模型之后，我们想要更进一步的提升，对错误的分析就很有必要。
分析混淆矩阵

1
2
3
4
5
6
>>> y_train_pred = cross_val_predict(sgd_clf, X_train, y_train, cv=3 )
>>> conf_mx = confusion_matrix(y_train, y_train_pred)
>>> conf_mx
array([[5725, 3, 24, 9, 10, 49, 50, 10, 39, 4],
        [2, 6493, 43, ...],
        ...])

对混淆矩阵进行一些可视化的操作之后，我们可以方便看出一些错误原因，并针对这些错误原因做进一步的优化。具体的分析方法根据实际情况而异。

Multilabel Classification

有时我们需要为一个实例输出多个标签，这就需要用到Multilabel Classification。

1
2
3
4
5
6
7
8
9
10
# 简单例子
from sklearn.neighbors import KNeighborsClassifier
y_train_large = (y_train >= 7)
y_train_odd = (y_train % 2 == 1)
y_multilabel = np.c_[y_train_large, y_train_odd]
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_multilabel)
>>> knn_clf.predict([some_digit])
array([[False, True]], dtype=bool)

有多种方法可以验证多标签的分类器，一种方法是对于每个标签计算它的F1分数，然后取平均来评价。

1
2
3
>>> y_train_knn_pred = cross_val_predict(knn_clf, X_train, y_train, cv=3)
>>> f1_score(y_train, y_train_knn_pred, average='macro')
0.9684

以上这种方法是建立在每个标签重要性相同的前提下的，然而实际情况可能并非如此。可以改变average参数来设置各个标签的权重。具体参考sklearn的文档。

Multioutput Classiffication

举例
图片去噪问题，输入是一张含有噪声的图像，输出是去噪了的图像，这算是一个Multioutput Classification问题。

1
2
3
4
5
6
7
8
9
10
noise_train = rnd.randint(0,100,(len(X_train), 784))
noise_test = rnd.randint(0,100,(len(X_test), 784))
X_train_mod = X_train + noise_train
X_test_mod = X_test + noise_test
y_train_mod = X_train
y_test_mod = X_test
knn_clf.fit(X_train_mod, y_train_mod)
clean_digit=knn_clf.predict([X_test_mod[some_index]])
plot_digit(clean_digit)

参考

1、Hands-On Machine Learning with Scikit-Learn and TensorFlow by Aurélien Géron (O’Reilly). Copyright 2017 Aurélien Géron, 978-1-491-96229-9

展开全文 >>

用神经网络解决Titanic问题

使用神经网络解决Titanic问题，主要用两种实现，一种是纯pytorch实现神经网络的搭建，另一种是使用skorch包装好的以pytorch为后端的API实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
import time
import copy
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim import lr_scheduler
import torch.nn.functional
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
import warnings
import torch
torch.manual_seed(0)
warnings.filterwarnings("ignore")
print(torch.__version__)
0.4.1

读入数据文件，这里省去了特征工程的部分，特征采用之前特征工程提取出的特征。

1
2
3
train=pd.read_csv('train_features.csv')
test=pd.read_csv('test_features.csv')
train.head()
1
train.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 13 columns):
PassengerId        891 non-null int64
Pclass             891 non-null int64
Sex                891 non-null int64
Title              891 non-null int64
Family_size        891 non-null int64
Family_Survival    891 non-null float64
FareBin_Code       891 non-null int64
AgeBin_Code        891 non-null int64
Embarked_C         891 non-null int64
Embarked_None      891 non-null int64
Embarked_Q         891 non-null int64
Embarked_S         891 non-null int64
Survived           891 non-null float64
dtypes: float64(2), int64(11)
memory usage: 90.6 KB

1
train.describe()
1
2
3
4
5
6
7
8
9
10
X_train=train.drop(['PassengerId','Survived'],axis=1).as_matrix()
Y_train=train['Survived'].astype(int).as_matrix()
X_test=test.drop(['PassengerId','Survived'],axis=1).as_matrix()
IDtest=test['PassengerId']
# scalar
scaler=MinMaxScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)

使用Pytorch搭建模型

数据载入和处理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class TitanicFeaturesDataset(Dataset):
    def __init__(self,X,y=None,transform=None):
        self.X=X
        self.y=y
        self.transform=transform
    
    def __len__(self):
        return self.X.shape[0]
    
    def __getitem__(self,idx):
        if self.y is not None:
            sample={'X':self.X[idx],'y':self.y[idx]}
        else:
            sample={'X':self.X[idx]}
        if self.transform is not None:
            sample=self.transform(sample)
        return sample
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# transform class
class ToTensor(object):
    def __call__(self,sample):
        if 'y' in sample.keys():
            X,y=sample['X'],sample['y']
            return {
                'X':torch.from_numpy(X.astype(np.float32)),
                'y':torch.squeeze(torch.from_numpy(np.array([y.astype(np.int64)])))
            }
        else:
            X=sample['X']
            return {
                'X':torch.from_numpy(X.astype(np.float32))
            }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# Model class
# 自定义Model需要继承nn.Module
class ClassifierModule(nn.Module):
    def __init__(self,D_in=11,D_out=2,num_units=20,nonlin=F.relu,dropout=0.5):
        super(ClassifierModule,self).__init__()
        self.num_units=num_units
        self.nonlin=nonlin
        self.dropout=nn.Dropout(dropout)
        
        self.linear1=nn.Linear(D_in,num_units)
        self.linear2=nn.Linear(num_units,10)
        self.output=nn.Linear(10,2)
        
    def forward(self,X):
        X=self.nonlin(self.linear1(X))
        X=self.dropout(X)
        X=self.nonlin(self.linear2(X))
        X=self.dropout(X)
        X=self.output(X)
        return X
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
# train model
def train_model(model,criterion,optimiizer,scheduler,dataset_sizes,num_epochs=100,device='cpu'):
    start=time.time()
    best_model_wts=copy.deepcopy(model.state_dict())
    best_acc=0.0
    
    for epoch in range(num_epochs):
        print('Epoch {}/{}'.format(epoch,num_epochs-1))
        print('-'*10)
        
        for phase in ['train','val']:
            if phase == 'train':
                scheduler.step()
                model.train()
            else:
                model.eval()
            running_loss=0.0
            running_corrects=0
            for sample_batches in dataloaders[phase]:
                inputs=sample_batches['X'].to(device)
                labels=sample_batches['y'].to(device)
                
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase=='train'):
                    outputs=model(inputs)
                    _,preds=torch.max(outputs,1)
                    loss=criterion(outputs,labels)
                    
                    if phase=='train':
                        loss.backward()
                        optimizer.step()
                    running_loss+=loss.item()*inputs.size(0)
                    running_corrects+=torch.sum(preds==labels.data)
            epoch_loss=running_loss/dataset_sizes[phase]
            epoch_acc=running_corrects.double()/dataset_sizes[phase]
            print('{} loss: {:.4f} Acc: {:.4f}'.format(phase,epoch_loss,epoch_acc))
            
            if phase=='val' and epoch_acc>best_acc:
                best_acc=epoch_acc
                best_model_wts=copy.deepcopy(model.state_dict())
    time_elapsed=time.time()-start
    print('Trainning complete in {:.0f}m {:.0f}s'.format(
            time_elapsed//60,time_elapsed%60))
    print('Best val Acc: {:4f}'.format(best_acc))
    model.load_state_dict(best_model_wts)
    return model
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# load data and train
train_dataset_len=X_train.shape[0]
train_len=train_dataset_len*4//5
transformed_datasets = {
        'train': TitanicFeaturesDataset(X_train[:train_len],Y_train[:train_len], transform=transforms.Compose([ToTensor()])),
        'val': TitanicFeaturesDataset(X_train[train_len:], Y_train[train_len:], transform=transforms.Compose([ToTensor()])),
        'test':TitanicFeaturesDataset(X_test,transform=transforms.Compose([ToTensor()]))
        }
dataloaders = {x: DataLoader(transformed_datasets[x], batch_size=16,
                                 shuffle=True, num_workers=0)
                   for x in ['train', 'val']}
dataloaders['test']=DataLoader(transformed_datasets['test'],batch_size=16,shuffle=False,num_workers=0)
dataset_sizes = {x: len(transformed_datasets[x]) for x in ['train', 'val','test']}
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
1
2
3
4
5
6
7
model=ClassifierModule()
# 这里就包含了softmax
criterion=nn.CrossEntropyLoss()
optimizer=optim.SGD(model.parameters(),lr=2e-2,momentum=0.9)
exp_lr_scheduler=lr_scheduler.StepLR(optimizer,step_size=7,gamma=0.1)
model=train_model(model,criterion,optimizer,exp_lr_scheduler,dataset_sizes,num_epochs=100,device=device)
Epoch 0/99
----------
train loss: 0.6819 Acc: 0.5674
val loss: 0.6576 Acc: 0.6425
Epoch 1/99
----------
train loss: 0.6624 Acc: 0.6096
val loss: 0.6418 Acc: 0.6425
Epoch 2/99
----------
...
Epoch 97/99
----------
train loss: 0.4965 Acc: 0.7598
val loss: 0.3836 Acc: 0.8603
Epoch 98/99
----------
train loss: 0.4819 Acc: 0.7556
val loss: 0.3836 Acc: 0.8603
Epoch 99/99
----------
train loss: 0.4981 Acc: 0.7626
val loss: 0.3836 Acc: 0.8603
Trainning complete in 0m 9s
Best val Acc: 0.877095

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# save model and reload it
torch.save(model.state_dict(),'pytorch_model.pth')
reloaded_model=ClassifierModule()
reloaded_model.load_state_dict(torch.load('pytorch_model.pth'))
# predicts on  test dataset
reloaded_model.eval()
final_predicts=[]
with torch.no_grad():
    for samples in dataloaders['test']:
        inputs=samples['X'].to(device)
        outputs=reloaded_model(inputs)
        _,preds=torch.max(outputs,1)
        for y_predict in list(preds.numpy()):
            final_predicts.append(y_predict)
final_predicts=np.array(final_predicts).reshape(-1,)
predict_survived_pytorch=pd.Series(final_predicts,name='Survived')
pytorch_result=pd.concat([IDtest,predict_survived_pytorch],axis=1)
pytorch_result.to_csv('pytorch_result.csv',index=False)
pytorch_result.head()

使用skorch搭建模型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from skorch import NeuralNetClassifier
from skorch.dataset import CVSplit
from sklearn.model_selection import GridSearchCV
import skorch
print(skorch.__version__)
class skorchModule(nn.Module):
    def __init__(self,num_units=20):
        super(skorchModule,self).__init__()
        self.net=ClassifierModule(num_units=num_units)
    
    def forward(self,X):
        X=self.net(X)
        X=F.softmax(X,dim=-1)
        return X
        
        
model = NeuralNetClassifier(
        skorchModule,
        max_epochs=200,
        lr=0.02,
        train_split=CVSplit(5),
        #     device='cuda',  # uncomment this to train with CUDA
    )
   
X = X_train.astype(np.float32)
Y = Y_train.astype(np.int64)
params = {
        'lr': [0.02],
        'max_epochs': [200],
        'module__num_units': [20],
}
# 用scoring='neg_log_loss'训练不正确？不知道为啥，只好在Module层加入softmax
gs = GridSearchCV(model, params, refit=True, cv=2, scoring='accuracy')
gs.fit(X, Y)
print(gs.best_score_, gs.best_params_)
gs.estimator.set_params(**gs.best_params_).fit(X, Y)
predict_Survived_skorch = pd.Series(gs.predict(X_test.astype(np.float32)), name='Survived')
skorch_result = pd.concat([IDtest, predict_Survived_skorch], axis=1)
skorch_result.to_csv('skorch_result.csv', index=False)
skorch_result.head()
0.3.0
  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.7777       0.3596        0.7712  0.0215
      ...

  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.6797       0.6704        0.6408  0.0250
      2        0.6756       0.6704        0.6409  0.0250
      3        0.6767       0.6704        0.6409  0.0250
      ...
    200        0.5370       0.7709        0.4915  0.0200
0.7845117845117845 {'lr': 0.02, 'max_epochs': 200, 'module__num_units': 20}
  epoch    train_loss    valid_acc    valid_loss     dur
-------  ------------  -----------  ------------  ------
      1        0.7113       0.6704        0.6715  0.0190
      2        0.7007       0.6704        0.6704  0.0264
    ...
    199        0.5825       0.7989        0.5358  0.0220
    200        0.5838       0.7989        0.5350  0.0240

参考

1、Pytorch data_loading tutorial

2、Pytorch_transfer_learning_tutorial

3、skorch basic usage

4、notebook

展开全文 >>

Kaggle入门赛之Titanic

本文是初次参加Kaggle入门赛Titanic生还预测的一个过程记录，通过这个比赛，主要熟悉了pandas以及sklearn包的使用，对于常见的分类问题有了一定的了解。现将数据分析的过程记录如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import xgboost
from sklearn.preprocessing import OneHotEncoder, LabelEncoder,StandardScaler,MinMaxScaler
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier, ExtraTreesClassifier, VotingClassifier,RandomForestRegressor
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold, learning_curve
from mlxtend.classifier import StackingClassifier

数据分析

1
2
3
4
5
6
train_df=pd.read_csv('data/train.csv')
test_df=pd.read_csv('data/test.csv')
data_all=pd.concat([train_df,test_df],ignore_index=True)
train_len=train_df.shape[0]
print(train_df.shape)
print(test_df.shape)
(891, 12)
(418, 11)

1
data_all.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 12 columns):
Age            1046 non-null float64
Cabin          295 non-null object
Embarked       1307 non-null object
Fare           1308 non-null float64
Name           1309 non-null object
Parch          1309 non-null int64
PassengerId    1309 non-null int64
Pclass         1309 non-null int64
Sex            1309 non-null object
SibSp          1309 non-null int64
Survived       891 non-null float64
Ticket         1309 non-null object
dtypes: float64(3), int64(4), object(5)
memory usage: 122.8+ KB

1
2
3
4
n = data_all.drop(['PassengerId','Survived'], axis=1).loc[:, data_all.isnull().any()].isnull().sum()
print('ALL:', data_all.shape[0])
print('-' * 30)
print(n.sort_values(ascending=False))
ALL: 1309
------------------------------
Cabin       1014
Age          263
Embarked       2
Fare           1
dtype: int64

填充缺失值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
## Cabin缺失较多 考虑将其分为 有值和无值两类 或者直接弃用
# 这里直接弃用
## Fare只缺1个值，用均值或中值填充，这里采用中值填充
data_all['Fare'].fillna(data_all['Fare'].median(),inplace=True)
## Embarked缺失2个值，为object类型，这里考虑添加一组新值，以"None"填充
data_all['Embarked'].fillna('None',inplace=True)
## Age对于预测很重要，这里考虑用机器学习的方法对其进行预测填充，考虑到Age和SibSp,Parch以及Pclass，Fare等因素有关
# 分析Age的影响因素
# 性别可能对age有影响，先将sex转化为数值类型
# convert Sex into categorical value 0 for male and 1 for female
data_all["Sex"] = data_all["Sex"].map({"male": 0, "female":1})
g = sns.heatmap(data_all[["Age","Sex","SibSp","Parch","Pclass","Fare"]].corr(),cmap="BrBG",annot=True)
# 分析出Age与Sex关系较小，而与其它几个属性都有一定关系
# 考虑使用RF模型结合其它几个属性对Age进行预测填充
# 把已有的数值型特征取出来丢进Random Forest Regressor中
age_df = data_all[['Age', 'Fare', 'Parch', 'SibSp', 'Pclass']]
# 乘客分成已知年龄和未知年龄两部分
known_age = age_df[age_df.Age.notnull()].as_matrix()
unknown_age = age_df[age_df.Age.isnull()].as_matrix()
# y即目标年龄
y = known_age[:, 0]
# X即特征属性值
X = known_age[:, 1:]
# fit到RandomForestRegressor之中
rfr = RandomForestRegressor(random_state=0, n_estimators=2000, n_jobs=-1)
rfr.fit(X, y)
# 用得到的模型进行未知年龄结果预测
predictedAges = rfr.predict(unknown_age[:, 1::])
# 用得到的预测结果填补原缺失数据
data_all.loc[(data_all.Age.isnull()), 'Age'] = predictedAges

png

1
2
3
4
# 显示数值类型的统计结果
print('number describe:\n',data_all.drop(['PassengerId','Survived'],axis=1).describe(include=['number']).loc[['min', 'max', 'mean','std','count']].T.sort_values('max'))
# 看出Age的缺失值已经被填充
number describe:
          min       max       mean        std   count
Sex     0.00    1.0000   0.355997   0.478997  1309.0
Pclass  1.00    3.0000   2.294882   0.837836  1309.0
SibSp   0.00    8.0000   0.498854   1.041658  1309.0
Parch   0.00    9.0000   0.385027   0.865560  1309.0
Age     0.17   80.0000  29.876751  13.447012  1309.0
Fare    0.00  512.3292  33.281086  51.741500  1309.0

1
2
3
4
5
# 显示object类型的取值
print('object describe:\n')
n = data_all.select_dtypes(include=object)
for c in n.columns:
    print('{:<14}'.format(c),':',len(data_all[c].unique()),'\n',data_all[c].unique())
object describe:

Cabin          : 187 
 [nan 'C85' 'C123' 'E46' 'G6' 'C103' 'D56' 'A6' 'C23 C25 C27' 'B78' 'D33'
 'B30' 'C52' 'B28' 'C83' 'F33' 'F G73' 'E31' 'A5' 'D10 D12' 'D26' 'C110'
 'B58 B60' 'E101' 'F E69' 'D47' 'B86' 'F2' 'C2' 'E33' 'B19' 'A7' 'C49'
 'F4' 'A32' 'B4' 'B80' 'A31' 'D36' 'D15' 'C93' 'C78' 'D35' 'C87' 'B77'
 'E67' 'B94' 'C125' 'C99' 'C118' 'D7' 'A19' 'B49' 'D' 'C22 C26' 'C106'
 'C65' 'E36' 'C54' 'B57 B59 B63 B66' 'C7' 'E34' 'C32' 'B18' 'C124' 'C91'
 'E40' 'T' 'C128' 'D37' 'B35' 'E50' 'C82' 'B96 B98' 'E10' 'E44' 'A34'
 'C104' 'C111' 'C92' 'E38' 'D21' 'E12' 'E63' 'A14' 'B37' 'C30' 'D20' 'B79'
 'E25' 'D46' 'B73' 'C95' 'B38' 'B39' 'B22' 'C86' 'C70' 'A16' 'C101' 'C68'
 'A10' 'E68' 'B41' 'A20' 'D19' 'D50' 'D9' 'A23' 'B50' 'A26' 'D48' 'E58'
 'C126' 'B71' 'B51 B53 B55' 'D49' 'B5' 'B20' 'F G63' 'C62 C64' 'E24' 'C90'
 'C45' 'E8' 'B101' 'D45' 'C46' 'D30' 'E121' 'D11' 'E77' 'F38' 'B3' 'D6'
 'B82 B84' 'D17' 'A36' 'B102' 'B69' 'E49' 'C47' 'D28' 'E17' 'A24' 'C50'
 'B42' 'C148' 'B45' 'B36' 'A21' 'D34' 'A9' 'C31' 'B61' 'C53' 'D43' 'C130'
 'C132' 'C55 C57' 'C116' 'F' 'A29' 'C6' 'C28' 'C51' 'C97' 'D22' 'B10'
 'E45' 'E52' 'A11' 'B11' 'C80' 'C89' 'F E46' 'B26' 'F E57' 'A18' 'E60'
 'E39 E41' 'B52 B54 B56' 'C39' 'B24' 'D40' 'D38' 'C105']
Embarked       : 4 
 ['S' 'C' 'Q' 'None']
Name           : 1307 
 ['Braund, Mr. Owen Harris'
 'Cumings, Mrs. John Bradley (Florence Briggs Thayer)'
 'Heikkinen, Miss. Laina' ... 'Saether, Mr. Simon Sivertsen'
 'Ware, Mr. Frederick' 'Peter, Master. Michael J']
Ticket         : 929 
 ['A/5 21171' 'PC 17599' 'STON/O2. 3101282' '113803' '373450' '330877'
 '17463' '349909' '347742' '237736' 'PP 9549' '113783' 'A/5. 2151'
    ...
 'A.5. 3236' 'SOTON/O.Q. 3101262' '359309']

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#对object特征分组
#处理Name属性
data_all['Title'] = data_all['Name']
# Cleaning name and extracting Title
for name_string in data_all['Name']:
    data_all['Title'] = data_all['Name'].str.extract('([A-Za-z]+)\.', expand=True)
# Replacing rare titles with more common ones
mapping = {'Mlle': 'Miss', 'Major': 'Mr', 'Col': 'Mr', 'Sir': 'Mr', 'Don': 'Mr', 'Mme': 'Miss',
               'Jonkheer': 'Mr', 'Lady': 'Mrs', 'Capt': 'Mr', 'Countess': 'Mrs', 'Ms': 'Miss', 'Dona': 'Mrs'}
data_all.replace({'Title': mapping}, inplace=True)
g = sns.factorplot(x="Title", y="Survived",  data=data_all.iloc[:train_len,:],
                   size=6, kind="bar", palette="muted")
g.despine(left=True)
g = g.set_ylabels("survival probability")
# 分析得出女人小孩确实生存率更高

png

1
2
# 对Title进行编码
data_all['Title'].replace(['Mr','Miss','Mrs','Master','Rev','Dr'],[0,1,2,3,4,4],inplace=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 家族属性特征提取
# 合并Parch属性和SibSp属性，添加Family_size属性
data_all['Family_size']=data_all['Parch']+data_all['SibSp']+1
g = sns.factorplot(x="Parch", y="Survived",  data=data_all.iloc[:train_len,:],
                   size=6, kind="bar", palette="muted")
g.despine(left=True)
g = g.set_ylabels("survival probability")
g = sns.factorplot(x="SibSp", y="Survived",  data=data_all.iloc[:train_len,:],
                   size=6, kind="bar", palette="muted")
g.despine(left=True)
g = g.set_ylabels("survival probability")
g = sns.factorplot(x="Family_size", y="Survived",  data=data_all.iloc[:train_len,:],
                   size=6, kind="bar", palette="muted")
g.despine(left=True)
g = g.set_ylabels("survival probability")
g = sns.countplot(x="Family_size", hue="Survived", data=data_all.iloc[:train_len,:])

png

png

png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
# 家族属性深挖
data_all['Last_Name'] = data_all['Name'].apply(lambda x: str.split(x, ",")[0])
DEFAULT_SURVIVAL_VALUE = 0.5
data_all['Family_Survival'] = DEFAULT_SURVIVAL_VALUE
for grp, grp_df in data_all[['Survived', 'Name', 'Last_Name', 'Fare', 'Ticket', 'PassengerId',
                                'SibSp', 'Parch', 'Age', 'Cabin']].groupby(['Last_Name', 'Fare']):
    if (len(grp_df) != 1):
        # A Family group is found.
        for ind, row in grp_df.iterrows():
            smax = grp_df.drop(ind)['Survived'].max()
            smin = grp_df.drop(ind)['Survived'].min()
            passID = row['PassengerId']
            if (smax == 1.0):
                data_all.loc[data_all['PassengerId'] == passID, 'Family_Survival'] = 1
            elif (smin == 0.0):
                data_all.loc[data_all['PassengerId'] == passID, 'Family_Survival'] = 0
for _, grp_df in data_all.groupby('Ticket'):
    if (len(grp_df) != 1):
        for ind, row in grp_df.iterrows():
            if (row['Family_Survival'] == 0) | (row['Family_Survival'] == 0.5):
                smax = grp_df.drop(ind)['Survived'].max()
                smin = grp_df.drop(ind)['Survived'].min()
                passID = row['PassengerId']
                if (smax == 1.0):
                    data_all.loc[data_all['PassengerId'] == passID, 'Family_Survival'] = 1
                elif (smin == 0.0):
                    data_all.loc[data_all['PassengerId'] == passID, 'Family_Survival'] = 0
# 查看Family_Survival分布
g = sns.countplot(x="Family_Survival", hue="Survived", data=data_all.iloc[:train_len,:])

png

1
2
3
4
5
# 将连续数值分成bins
# 处理Fare
# 显示Fare的分布 
g = sns.distplot(data_all["Fare"], color="m", label="Skewness : %.2f"%(data_all["Fare"].skew()))
g = g.legend(loc="best")

png

从上面可以看出Fare的分布比较不均匀，对其通过log尺度变换进行处理。

1
2
3
4
# Apply log to Fare to reduce skewness distribution
data_all["Fare"] = data_all["Fare"].map(lambda i: np.log(i) if i > 0 else 0)
g = sns.distplot(data_all["Fare"], color="b", label="Skewness : %.2f"%(data_all["Fare"].skew()))
g = g.legend(loc="best")

png

1
2
3
4
5
6
7
8
# 现在对Fare分成bins
# 这里选择qcut方法，对频率进行等距分箱
n_bins=5
data_all['FareBin'] = pd.qcut(data_all['Fare'], n_bins)
label = LabelEncoder()
data_all['FareBin_Code'] = label.fit_transform(data_all['FareBin'])
g = sns.countplot(x="FareBin_Code",hue='Survived',data=data_all.iloc[:train_len,:])

png

1
2
3
# 同样对年龄进行处理
g = sns.distplot(data_all["Age"], color="m", label="Skewness : %.2f"%(data_all["Age"].skew()))
g = g.legend(loc="best")

png

1
2
3
4
5
6
7
8
# 年龄的分布就比较均匀，不需要做任何预处理
# 这里用cut方法，对年龄选择等距分箱，分成n_bins_age个年龄段
n_bins_age=8
data_all['AgeBin'] = pd.cut(data_all['Age'], n_bins_age)
label = LabelEncoder()
data_all['AgeBin_Code'] = label.fit_transform(data_all['AgeBin'])
g = sns.countplot(x="AgeBin",hue='Survived',data=data_all.iloc[:train_len,:])

png

1
2
# 处理Embarked属性
g = sns.countplot(x="Embarked",data=data_all)

png

1
g = sns.countplot(x="Embarked",hue='Survived',data=data_all.iloc[:train_len,:])

png

对Embarked属性进行dummy操作

1
data_all=pd.get_dummies(data_all,columns=['Embarked'],prefix='Embarked')

剩下Ticket属性看起来比较复杂，先不做任何提取。

下面再继续看目前的data_all的信息。

1
data_all.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1309 entries, 0 to 1308
Data columns (total 23 columns):
Age                1309 non-null float64
Cabin              295 non-null object
Fare               1309 non-null float64
Name               1309 non-null object
Parch              1309 non-null int64
PassengerId        1309 non-null int64
Pclass             1309 non-null int64
Sex                1309 non-null int64
SibSp              1309 non-null int64
Survived           891 non-null float64
Ticket             1309 non-null object
Title              1309 non-null int64
Family_size        1309 non-null int64
Last_Name          1309 non-null object
Family_Survival    1309 non-null float64
FareBin            1309 non-null category
FareBin_Code       1309 non-null int64
AgeBin             1309 non-null category
AgeBin_Code        1309 non-null int64
Embarked_C         1309 non-null uint8
Embarked_None      1309 non-null uint8
Embarked_Q         1309 non-null uint8
Embarked_S         1309 non-null uint8
dtypes: category(2), float64(4), int64(9), object(4), uint8(4)
memory usage: 181.8+ KB

1
2
3
4
5
# 选用部分特征做为最终特征
data_all=data_all[['PassengerId','Pclass','Sex','Title','Family_size','Family_Survival','FareBin_Code','AgeBin_Code',
                  'Embarked_C','Embarked_None','Embarked_Q','Embarked_S','Survived']]
g = sns.heatmap(data_all.iloc[:train_len,:].drop(['PassengerId'],axis=1).corr(),cmap="BrBG",annot=True)

png

Scale以及模型选择

1
2
3
4
X_train_original=data_all.iloc[:train_len,:].drop(['PassengerId','Survived'],axis=1)
Y_train=data_all.iloc[:train_len,:]['Survived'].astype(int)
test_original=data_all.iloc[train_len:,:].drop(['PassengerId','Survived'],axis=1)
testID=data_all.iloc[train_len:,:]['PassengerId']
1
2
3
4
5
6
# nn using skorch 
# 神经网络模型
import torch
from torch import nn
import torch.nn.functional as F
torch.manual_seed(0)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class ClassifierModule(nn.Module):
    def __init__(
            self,
            num_units=20,
            nonlin=F.relu,
            dropout=0.5,
    ):
        super(ClassifierModule, self).__init__()
        self.num_units = num_units
        self.nonlin = nonlin
        self.dropout = dropout
        self.dense0 = nn.Linear(11, num_units)
        self.nonlin = nonlin
        self.dropout = nn.Dropout(dropout)
        self.dense1 = nn.Linear(num_units, 10)
        self.output = nn.Linear(10, 2)
    def forward(self, X, **kwargs):
        X = self.nonlin(self.dense0(X))
        X = self.dropout(X)
        X = F.relu(self.dense1(X))
        X = F.softmax(self.output(X), dim=-1)
        return X
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from skorch import NeuralNetClassifier
from skorch.dataset import CVSplit
net = NeuralNetClassifier(
    ClassifierModule,
    max_epochs=500,
    lr=0.02,
    train_split=CVSplit(5),
#     device='cuda',  # uncomment this to train with CUDA
)
from sklearn.model_selection import GridSearchCV
X=X_train.astype(np.float32)
Y=Y_train.astype(np.int64)
params = {
    'lr': [0.02],
    'max_epochs': [500],
    'module__num_units': [20],
}
gs = GridSearchCV(net, params, refit=True,cv=2, scoring='accuracy')
gs.fit(X, Y)
print(gs.best_score_, gs.best_params_)
gs.estimator.set_params(**gs.best_params_).fit(X,Y)
IDtest=pd.read_csv('data/test.csv')['PassengerId']
test_Survived_nn=pd.Series(gs.predict(test.astype(np.float32)),name='Survived')
nn_results=pd.concat([IDtest,test_Survived_nn],axis=1)
nn_results.to_csv('nn_results.csv',index=False)
nn_results.head()
1
2
3
4
# scalar
scaler=MinMaxScaler()
X_train= scaler.fit_transform(X_train_original)
test= scaler.transform(test_original)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
kfold = StratifiedKFold(n_splits=5)
# Modeling step Test differents algorithms
random_state = 2
classifiers = []
classifiers.append(SVC(random_state=random_state))
classifiers.append(DecisionTreeClassifier(random_state=random_state))
classifiers.append(AdaBoostClassifier(DecisionTreeClassifier(random_state=random_state), random_state=random_state,
                                          learning_rate=0.1))
classifiers.append(RandomForestClassifier(random_state=random_state))
classifiers.append(ExtraTreesClassifier(random_state=random_state))
classifiers.append(GradientBoostingClassifier(random_state=random_state))
classifiers.append(MLPClassifier(random_state=random_state))
classifiers.append(KNeighborsClassifier())
classifiers.append(LogisticRegression(random_state=random_state))
classifiers.append(LinearDiscriminantAnalysis())
cv_results = []
for classifier in classifiers:
    cv_results.append(cross_val_score(classifier, X_train, y=Y_train, scoring="accuracy", cv=kfold))
cv_means = []
cv_std = []
for cv_result in cv_results:
    cv_means.append(cv_result.mean())
    cv_std.append(cv_result.std())
cv_res = pd.DataFrame(
        {"CrossValMeans": cv_means, "CrossValerrors": cv_std, "Algorithm": ["SVC", "DecisionTree", "AdaBoost","RandomForest", "ExtraTrees","GradientBoosting","MultipleLayerPerceptron", "KNeighboors","LogisticRegression","LinearDiscriminantAnalysis"]})
g = sns.barplot("CrossValMeans", "Algorithm", data=cv_res, palette="Set3", orient="h", **{'xerr': cv_std})
g.set_xlabel("Mean Accuracy")
g = g.set_title("Cross validation scores")

png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Adaboost
DTC = DecisionTreeClassifier()
adaDTC = AdaBoostClassifier(DTC, random_state=7)
ada_param_grid = {"base_estimator__criterion": ["entropy"],
                      "base_estimator__splitter": [ "random"],
                      "algorithm": ["SAMME"],
                      "n_estimators": [100],
                      "learning_rate": [0.0001]}
gsadaDTC = GridSearchCV(adaDTC, param_grid=ada_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsadaDTC.fit(X_train, Y_train)
ada_best = gsadaDTC.best_estimator_
print('AdaBoost:')
print(gsadaDTC.best_params_)
print(gsadaDTC.best_score_)
Fitting 5 folds for each of 1 candidates, totalling 5 fits


[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    3.0s finished


AdaBoost:
{'algorithm': 'SAMME', 'base_estimator__criterion': 'entropy', 'base_estimator__splitter': 'random', 'learning_rate': 0.0001, 'n_estimators': 100}
0.8294051627384961

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# ExtraTrees
ExtC = ExtraTreesClassifier()
## Search grid for optimal parameters
ex_param_grid = {"max_depth": [None],
                     "max_features": [0.2,0.3],
                     "min_samples_split": [3,5],
                     "min_samples_leaf": [5,],
                     "bootstrap": [False],
                     "n_estimators": [500],
                     "criterion": ["gini"]}
gsExtC = GridSearchCV(ExtC, param_grid=ex_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsExtC.fit(X_train, Y_train)
print('Extra Tree:')
ExtC_best = gsExtC.best_estimator_
print(gsExtC.best_params_)
# Best score
print(gsExtC.best_score_)
Fitting 5 folds for each of 4 candidates, totalling 20 fits


[Parallel(n_jobs=4)]: Done  20 out of  20 | elapsed:    8.1s finished


Extra Tree:
{'bootstrap': False, 'criterion': 'gini', 'max_depth': None, 'max_features': 0.3, 'min_samples_leaf': 5, 'min_samples_split': 5, 'n_estimators': 500}
0.8462401795735129

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#xgboost
XGBC = xgboost.sklearn.XGBClassifier()
xgbc_param_grid = {
                     "n_estimators": [500],
                    'learning_rate':[0.001],
                    'max_depth':[3],
                    'booster':['gbtree']}
gsXGBC= GridSearchCV(XGBC, param_grid=xgbc_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsXGBC.fit(X_train, Y_train)
print('xgboost:')
XGBC_best = gsXGBC.best_estimator_
print(gsXGBC.best_params_)
print(gsXGBC.best_score_)
Fitting 5 folds for each of 1 candidates, totalling 5 fits


[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    2.5s finished


xgboost:
{'booster': 'gbtree', 'learning_rate': 0.001, 'max_depth': 3, 'n_estimators': 500}
0.8518518518518519

1
2
3
4
5
6
7
8
9
10
11
LR=LogisticRegression()
lr_param_grid = {
       'penalty':['l1'],
        'tol':[1e-4],
        'C':[10]}
gsLR = GridSearchCV(LR, param_grid=lr_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsLR.fit(X_train, Y_train)
print('Logistic Regression:')
LR_best = gsLR.best_estimator_
print(gsLR.best_params_)
print(gsLR.best_score_)
Fitting 5 folds for each of 1 candidates, totalling 5 fits
Logistic Regression:
{'C': 10, 'penalty': 'l1', 'tol': 0.0001}
0.8361391694725028


[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    2.3s finished

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# RFC Parameters tunning
RFC = RandomForestClassifier()
## Search grid for optimal parameters
rf_param_grid = {"max_depth": [None],
                "max_features": ['auto',0.3],
                "min_samples_split": [5],
                "min_samples_leaf": [6],
                "bootstrap": [False],
                "n_estimators": [150],
                "criterion": ["gini"]}
gsRFC = GridSearchCV(RFC, param_grid=rf_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsRFC.fit(X_train, Y_train)
print('Random Forest:')
RFC_best = gsRFC.best_estimator_
print(gsRFC.best_params_)
# Best score
print(gsRFC.best_score_)
Fitting 5 folds for each of 2 candidates, totalling 10 fits


[Parallel(n_jobs=4)]: Done  10 out of  10 | elapsed:    3.1s finished


Random Forest:
{'bootstrap': False, 'criterion': 'gini', 'max_depth': None, 'max_features': 0.3, 'min_samples_leaf': 6, 'min_samples_split': 5, 'n_estimators': 150}
0.8552188552188552

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# Gradient boosting tunning
GBC = GradientBoostingClassifier()
gb_param_grid = {'loss': ["deviance"],
                     'n_estimators': [200],
                     'learning_rate': [0.01],
                     'max_depth': [4],
                     'min_samples_leaf': [100],
                     "max_features": ['auto']
                     }
gsGBC = GridSearchCV(GBC, param_grid=gb_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsGBC.fit(X_train, Y_train)
print('Gradient Boost:')
print(gsGBC.best_params_)
GBC_best = gsGBC.best_estimator_
print(gsGBC.best_score_)
Fitting 5 folds for each of 1 candidates, totalling 5 fits


[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    2.5s finished


Gradient Boost:
{'learning_rate': 0.01, 'loss': 'deviance', 'max_depth': 4, 'max_features': 'auto', 'min_samples_leaf': 100, 'n_estimators': 200}
0.8484848484848485

1
2
3
4
5
6
7
8
9
10
11
12
### SVC classifier
SVMC = SVC(probability=True)
svc_param_grid = {'kernel': ['rbf'],
                      'gamma': [ 1],
                      'C': [0.1]}
gsSVMC = GridSearchCV(SVMC, param_grid=svc_param_grid, cv=kfold, scoring="accuracy", n_jobs=4, verbose=1)
gsSVMC.fit(X_train, Y_train)
print('SVC')
print(gsSVMC.best_params_)
SVMC_best = gsSVMC.best_estimator_
# Best score
print(gsSVMC.best_score_)
Fitting 5 folds for each of 1 candidates, totalling 5 fits


[Parallel(n_jobs=4)]: Done   5 out of   5 | elapsed:    2.5s finished


SVC
{'C': 0.1, 'gamma': 1, 'kernel': 'rbf'}
0.8305274971941639

1
2
3
4
5
6
7
8
9
#Voting
votingC = VotingClassifier(estimators=[('rfc', RFC_best), ('extc', ExtC_best),
                                           ('svc', SVMC_best), ('adac', ada_best), ('gbc', GBC_best),
                                           ('xgbc',XGBC_best),('lr',LR_best)], voting='soft',
                               n_jobs=4)
votingC = votingC.fit(X_train, Y_train)
voting_score=cross_val_score(votingC, X_train, y=Y_train, scoring="accuracy", cv=kfold)
print('voting:',voting_score)
voting: [0.86592179 0.84357542 0.85393258 0.81460674 0.84745763]

1
2
3
4
5
6
#Stacking
stack = StackingClassifier(classifiers=[RFC_best, ExtC_best,SVMC_best,ada_best,GBC_best,LR_best],
                              meta_classifier=XGBC_best)
stack = stack.fit(X_train, Y_train)
stack_score=cross_val_score(stack,X_train, y=Y_train, scoring="accuracy", cv=kfold)
print('stack_score:',stack_score)
stack_score: [0.83240223 0.81564246 0.85393258 0.82022472 0.82485876]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,n_jobs=-1, train_sizes=np.linspace(.1, 1.0, 5)):
        """Generate a simple plot of the test and training learning curve"""
        plt.figure()
        plt.title(title)
        if ylim is not None:
            plt.ylim(*ylim)
        plt.xlabel("Training examples")
        plt.ylabel("Score")
        train_sizes, train_scores, test_scores = learning_curve(
            estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
        train_scores_mean = np.mean(train_scores, axis=1)
        train_scores_std = np.std(train_scores, axis=1)
        test_scores_mean = np.mean(test_scores, axis=1)
        test_scores_std = np.std(test_scores, axis=1)
        plt.grid()
        plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
                         train_scores_mean + train_scores_std, alpha=0.1,
                         color="r")
        plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
                         test_scores_mean + test_scores_std, alpha=0.1, color="g")
        plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
                 label="Training score")
        plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
                 label="Cross-validation score")
        plt.legend(loc="best")
        return plt
g = plot_learning_curve(gsRFC.best_estimator_, "RF mearning curves", X_train, Y_train, cv=kfold)
g = plot_learning_curve(gsExtC.best_estimator_, "ExtraTrees learning curves", X_train, Y_train, cv=kfold)
g = plot_learning_curve(gsSVMC.best_estimator_, "SVC learning curves", X_train, Y_train, cv=kfold)
g = plot_learning_curve(gsadaDTC.best_estimator_, "AdaBoost learning curves", X_train, Y_train, cv=kfold)
g = plot_learning_curve(gsGBC.best_estimator_, "GradientBoosting learning curves", X_train, Y_train, cv=kfold)
g = plot_learning_curve(gsXGBC.best_estimator_,"xgboost learning curves",X_train,Y_train,cv=kfold)
g = plot_learning_curve(gsLR.best_estimator_,"Logistic Regression learning curves",X_train,Y_train,cv=kfold)

png

png

png

png

png

png

png

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
nrows =3
ncols=2
fig, axes = plt.subplots(nrows=nrows, ncols=ncols, sharex="all", figsize=(15, 15))
names_classifiers = [('rfc', RFC_best), ('extc', ExtC_best),
                        ('adac', ada_best), ('gbc', GBC_best),
                        ('xgbc',XGBC_best)]
nclassifier = 0
for row in range(nrows):
    for col in range(ncols):
        if nclassifier>=5:
            break
        name = names_classifiers[nclassifier][0]
        classifier = names_classifiers[nclassifier][1]
        indices = np.argsort(classifier.feature_importances_)[::-1][:40]
        g = sns.barplot(y=X_train_original.columns[indices][:40], x=classifier.feature_importances_[indices][:40],
                            orient='h', ax=axes[row][col])
        g.set_xlabel("Relative importance", fontsize=12)
        g.set_ylabel("Features", fontsize=12)
        g.tick_params(labelsize=9)
        g.set_title(name + " feature importance")
        nclassifier += 1
test_Survived_RFC = pd.Series(RFC_best.predict(test), name="RFC")
test_Survived_ExtC = pd.Series(ExtC_best.predict(test), name="ExtC")
test_Survived_SVMC = pd.Series(SVMC_best.predict(test), name="SVC")
test_Survived_AdaC = pd.Series(ada_best.predict(test), name="Ada")
test_Survived_GBC = pd.Series(GBC_best.predict(test), name="GBC")
test_Survived_XGBC=pd.Series(XGBC_best.predict(test),name='XGBC')
test_Survived_LR=pd.Series(LR_best.predict(test),name='LR')
test_Survived_Voting=pd.Series(votingC.predict(test),name='Voting')
    # Concatenate all classifier results
ensemble_results = pd.concat(
        [test_Survived_RFC, test_Survived_ExtC, test_Survived_AdaC, test_Survived_GBC, test_Survived_SVMC,
         test_Survived_XGBC,test_Survived_LR,test_Survived_Voting], axis=1)
g = sns.heatmap(ensemble_results.corr(), annot=True)

png

1
2
3
4
5
6
7
8
test_Survived = pd.Series(votingC.predict(test), name="Survived")
test_Survived_XGBC_submition=pd.Series(XGBC_best.predict(test),name='Survived')
xgbc_results=pd.concat([IDtest,test_Survived_XGBC_submition],axis=1)
xgbc_results.to_csv('xgbc.csv',index=False)
print(IDtest.shape)
print(test_Survived.shape)
results = pd.concat([IDtest, test_Survived], axis=1)
results.to_csv("ensemble_python_voting.csv", index=False)
(418,)
(418,)

最后提交的voting方法的结果得到了0.81339的分数,还有一定的提升空间，其中超参数调整应该还会带来一定的效果提升。

参考

1、yassineghouzam’s kernel
2、konstantinmasich’s kernel
3、pandas document
4、seaborn tutorial
5、notebook

展开全文 >> 

1
2
3
4
5
6
7
8
st=>start: 开始
e=>end: 结束
op=>operation: 操作
cond=>condition: 确认？
st->op->cond
cond(yes)->e
cond(no)->op

展开全文 >>

mAP详解

mean average precise

1、precise and recall

precise and recall
如上图所示：
precise=true_positive/(true_positive+false_positive)
recall=true_positive/(true_positive+false_negative)
precise表示预测正确的占所有预测的百分比。
recall表示预测的某一类正确的占该类总数的百分比。
2、average precise
根据 precise recall曲线计算得到。
关键在于理解precise recall 曲线怎么得到？
具体详见参考1。
即对每个recall对应的precise取平均。
3、mean average precise
上面average precise是针对每一类的情况。再对所有类的ap取平均即可得到mAP。

参考

1、多标签图像分类任务的评价方法-mAP
2、mean average precision（MAP）在计算机视觉中是如何计算和应用的？

展开全文 >>

深度学习中的Normalization方法

总结深度学习中常用的Normalization方法，包括BatchNormalization,LayerNormalization,GroupNormalization以及LocalResponseNorm。

Batch Normalization

Feature Scaling

是指对不同的feature做归一化，使得其有着相同的scaling。
Feature Scaling
从上图可以看出，输入的两个维度x1,x2相差比较大，如果想要得到比较好的学习效果，需要针对不同维度采用不同learning rate，但是操作起来困难。进行feature scaling可以解决这个问题。
如何做：
如何做scaling

Internal Convariate Shift

We define Internal Covariate Shift as the change in the distribution of network activations due to the change in network parameters during training
减少Internal Convariate Shift有助于训练。
Internal Convariate Shift
对于deeplearning 网络来说，可以对每个layer做feature scaling。
然而如果只是上面提到的简单的feature scaling的话会带来一个问题：
在训练过程中，中间的每一层的参数都是在变化的，那么其每层的output也会随之改变，则mean和std也在不断变化。我们将难以简单计算出mean和std来进行feature scaling。Batch Normalization则可以用来解决这个问题，因为其将normalization加入训练过程中。

Batch Normalization

Batch Normalization

为什么要加gamma，beta参数

gamma，beta参数的加入使得整个BN过程可训练，使得其与普通的预处理归一化操作区别开。??
为了保证模型的表达能力不因为规范化而下降
详解深度学习中的Normalization，不只是BN

forward

针对每一个batch做归一化操作。
training
训练

1
2
3
4
5
6
7
8
9
sample_mean=np.mean(x,axis=0)
sample_var=np.var(x,axis=0)
x_hat=(x-sample_mean)/np.sqrt(sample_var+eps)
out=gamma*x_hat+beta
# move average mean
running_mean=momentum*running_mean+(1-momentum)*sample_mean
# move average var
running_var=momentum*running_var+(1-momentum)*sample_mean

test
存在一个问题：我们无法知道batch的信息，所以没法算mean和std。
解决方法：
1ideal solution: Computing mean and std using the whole training dataset
2practical solution: computing the moving average of mean and std of the batches during training

1
2
temp=(x-running_mean)/np.sqrt(running_var+eps)
out=gamma*temp+beta

backward

Understanding the backward pass through Batch Normalization Layer

benefit

1、BN通过减少Internal Convariate Shift使得我们可以使用更高的learning rate来让训练更快速。
2、BN对解决梯度爆炸和梯度消失有作用，特别是对tanh、sigmoid等激活函数。
原因：因为BN确保了数据都在0附近斜率比较大的地方，不会出现梯度爆炸和消失的问题。
3、使得参数初始化对训练的影响不大
参数初始化
4、BN也有regularization的作用，防止overfitting

参考

1、Why-does-batch-normalization-help
2、Understanding the backward pass through Batch Normalization Layer
3、李宏毅老师讲BN(图片都来自该视频截图)
4、pytorch doc
5、BN论文
6、详解深度学习中的Normalization，不只是BN

Other Normalization

Layer Normalization

Layer Normalization和BN的区别在于：LN是对每个单独的数据做归一化，BN是对mini-batch的数据做归一化。

Group Normalization

GN divides the channels into groups and computes within each group the mean and variance for normalization. GN’s computation is independent of batch sizes, and its accuracy is stable in a wide range of batch sizes.
其可以用于在batch_size较小时对BN的替代。
GN implement

Local Response Normalization

展开全文 >>

C++中的左值和右值以及std::move, std::forward

lvalue and rvalue

在概念上,右值对应于从函数返回的临时对象，而左值对应于可以引用的对象，无论是通过名称还是通过跟随指针或左值引用。一种判断表达式是左值还是右值的方法是：如果能得到其地址，那么它是左值，否则其是右值。
注意:一个表达式的类型和这个表达式本身是左值还是右值无关。

1
2
3
4
5
//一个参数始终是lvalue，即便其类型是一个rvalue reference
class Widget{
public:
    Widget(Widget&& rhs);//rhs是一个左值，但是其有一个右值引用的类型。
}

Effective Modern C++中相关条款笔记总结

Item 23: Understanding std::move and std::forward

要点
1、std::move
move semantic使得编译器将代价昂贵的copy操作替换为相对代价低的move。move semantics使得move-only类型的创建成为可能，比如std::unique_ptr,std::future,std::thread。
实际上std::move并没有移动任何东西。它做的其实是一个类型转换工作。就是将输入转型为rvalue。
2、std::forward
std::forward和std::move类似，比较大的区别就是std::forward是有条件的类型转换，
只有当参数是和rvalue绑定时将其转型为rvalue，否则不做转换。

Item 24：Distinguish universal references from rvalue references

要点
1、判断原则
A、当函数的模板参数有着T&&的形式，并且有推导类型T，或者一个对象被声明为auto&&，那么它就是一个universal reference。
B、如果type的声明的格式并不完全是type&&，或者类型推断没有发生，那么type&&表示的就是rvalue reference。
C、对于universal reference，如果它被rvalue初始化，它就是rvalue，与之对应，如果被lvalue初始化，其就是lvalue。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//实例
void f(Widget&& param);//B rvalue  reference  没有类型推断
Widget&& var1=Widget();//B rvalue reference 没有类型推断
auto&& var2=var1;//A universal references var2有形式auto&&
template<typename T>
void f(std::vector<T>&& param); //B rvalue references param类型不完全是type&&
template<typename T>
void f(T&& param);//universal references param有推导类型T，且形式是T&&
template<typename T>
void f(const T&& param);//universal reference 因
//为type的声明格式并不完全是type&&(多了const)
template<class T, class Allocator = allocator<T>>
class vector{
public:
    void push_back(T&& x)//rvalue reference 
    //因为没有类型推断，当vector被初始化时，T的类型就被确定了。
}
template<class T,class Allocator=allcator<T>>
class vector{
public:
    template<class... Args>
    void emplace_back(Args&&... args);//universal 
    //reference，存在类型推断，因为即
    //便T的类型在vector初始化时确定，但是Args的类型不能确定，需要类型推导。
}

Item 25：Use std::move on rvalue references, std::forward on universal references

要点
1、当将rvalue reference转发给其它函数时，其应该被无条件转型为rvalue，即用std::move，因为它总是被rvalues限制，而将universal referencies转发给其它函数时，应该有条件地转型，即使用std::forward,因为它可能是lvalues。
注意1为什么不在任何情况下都使用std::forward？尽管使用std::forward对于rvalue references也能产生正确的行为，但是这样源代码冗长也容易出错。
注意2对universal references使用std::move会对lvalues造成意外的修改，更应该避免。
2、当一个函数按值返回时，如果是返回一个与 universal reference或者rvalue reference绑定的对象，那么在返回时可以对其施加std::forward或者std::move操作，这样效率更高
注意:即便该对象不支持move操作也没有任何副作用，因为如果不支持的话会自动调用该对象的拷贝构造函数完成copy。

1
2
3
4
5
Matrix 
operator+(Matrix&& lhs,const Matrix& rhs){
    lhs+=rhs;
    return std::move(lhs);
}

3、不要将std::move或者std::forward应用到local object
原因详见P174，和编译器的返回值优化有关。

1
2
3
4
5
Widget makeWidget(){
    Widget w;
    ...
    return std::move(w);//避免这样做
}

Item 26: Avoid overloading on universal references

要点看原书比较清楚(没太看懂。)
1、对通用引用进行重载往往导致其被调用的次数比预期要多很多。
2、完美转发的构造函数特别有问题，因为它们通常比拷贝构造函数更适合非常量lvalue，并且它们可以劫持派生类调用到其基类的拷贝和移动构造函数

Item 27: Familiarize yourself with alternatives to overloading on universal references.

Item 28: Understand reference collapsing

要点
1、

1
2
3
4
5
template<typename T>
void func(T&& param);
/*
根据传入param是lvalue或者rvalue，T的推导类型会有不同。param是lvalue，则T推导为lvalue reference，当param是rvalue，T推导为non-reference。
*/

2、在C++中引用的引用是违法的

1
2
3
int x;
...
auto& & rx=x;//ERROR

3、但是当lvalue传入一个以universal reference为类型的模板时

1
2
3
4
5
6
7
8
9
10
template<typename T>
void func(T&& param);
Widget w;
func(w);//w是一个lvalue，那么T推导为Widget&
//则模板应该被实例化为以下：
void func(Widget& && param);
//实际上这时一种叫做reference collapsing的机制，使得模板的最终实例化如下：
void func(Widget& param);//这与之前所说的以lvalue初始化universal 
//reference，其结果为lvalue  reference一致。

4、reference collapsing规则
在允许reference collapsing的情况下，如果两个reference中，任一个是lvalue reference，则结果是lvalue reference，否则结果是rvalue reference。
实际上，std::forward就是根据这个机制实现的。
5、深入理解universal reference
实际上，universal reference不是一种新引用，它是rvalue reference在以下条件满足时的一种特殊情况：
条件1类型推导区分左值和右值。类型T的左值推导为类型 T&，类型T的右值推导为类型 T。
条件2发生了reference collapsing。
6、reference collapsing发生的情况
情况1模板实例化
情况2auto类型生成
情况3生成、使用typedef 和 使用别名声明
情况4使用decltype

Item 29: Assume that move operations are not present, not cheap, and not used

要点
1、在以下情况下，std::move不会带来任何好处。
No move operations
Move not faster
Move not usable
Source object is lvalue
2、最好假设move操作不存在，不高效，没用过。只有在类型明确或者支持move语义时不需要这个假设。

Item 30: Familiarize yourself with perfect forwarding failure cases

参考

1、Scott Meyers
Effective Modern C++ : 42 Specific Ways to Improve Your Use of C++11 and C++14

展开全文 >>

C++中的智能指针笔记

最近在看opencv的文档时，对cv::Ptr类了解了一些，其与STL中的shared_ptr类似，是一种智能指针，于是又看了《C++标准库》中有关智能指针的章节和《Effective Modern C++》中的有关智能指针的章节，将智能指针所涉及的一些内容总结如下。

STL中智能指针

C++中比较棘手的一个问题就是内存的管理，指针在其中扮演了及其重要的作用，但是同时对指针的不当使用会造成很多问题。自C++11起，STL提供了两大类型的智能指针，使得对指针的操作更加安全。其中shared_ptr类实现了共享式拥有概念，而unique_ptr实现了独占式拥有概念。另外还有weak_ptr等辅助类。所有这些指针类都定义在头文件 < memory>中。

shared_ptr

shared_ptr主要使用一种称为引用计数的方法来管理其所指向的内容。当该指针多指向一个内容时，引用计数加一，少指向一个内容时，引用计数值减1，当引用计数值减到0时，该内容会被自动删除。

shared_ptr的声明和初始化

1、使用构造函数初始化

1
std::shared_ptr<int> pInt(new int(1));

2、新式初始化语法

1
std::shared_ptr<int> pInt{new int(1)};

3、使用make_shared()初始化

1
std::shared_ptr<int> pInt=std::make_shared<int>(1);

4、先声明shared pointer，然后使用reset()方法赋值

1
2
std::shared_ptr<int> pInt;
pInt.reset(new int(1));

注意不能使用赋值符进行初始化

1
std::shared_ptr<int> pInt=new int(1);//ERROR

最常用和可靠的初始化方法是使用make_shared()函数。

析构策略

实际上，我们可以声明特化的deleter，可以通过传递一个lambda作为shared_ptr构造函数的第二实参。

1
2
3
4
std::shared_ptr<int> pInt(new int(1),[](int* p){
    std::cout<<"delete "<<*p<<std::endl;
    delete p;
    });

注意：shared_ptr提供的default deleter 调用的是 delete,而不是delete []，所以即便为array建立一个shared_ptr是可以的，但是却有致命错误，解决方法是为其指定delete []作为析构函数，最好不要这样使用shared_ptr。

1
2
3
4
5
6
7
8
9
std::shared_ptr<int> pArray(new int[10]);//ERROR,能通过编译
//(《C++标准库》一书中这样写，但是实际测试没有出现问题？)
//解决方案
std::shared_ptr<int> pArray(new int[10],[](int* p){
    delete[] p;
    })
//也可以这样
std::shared_ptr<int> pArray(new int[10],std::default_delete<int[]>());

如果析构时不仅仅需要删除内存，还需要 一些其它操作，那么必须指定deleter

shared_ptr陷阱

1、cyclic reference问题
两个对象使用shared_ptr互相指向对方时，使用shared_ptr无法释放相应的资源，因为每个对象的use_count()至少为1。
解决方法:1、使用普通指针，但是这样又得自行管理资源释放，比较麻烦也更容易出问题。2、其中一方的指向使用weak_ptr，可以完美解决该问题。
2、试图访问已被释放的数据
也可通过使用weak_ptr解决。
3、应该确保某对象只被一组shared_ptr拥有

1
2
3
int* p=new int;
shared_ptr<int> sp1(p);
shared_ptr<int> sp2(p);//ERROR 但是可以编译通过 具体在后面有解释

当sp1和sp2丢失p的拥有权时，两者都会试图释放p的资源，即释放资源的操作会执行两次。解决方法是在创建对象和其相应资源的时候直接设立shared_ptr。

1
2
shared_ptr<int> sp1(new int);
shared_ptr<int> sp2(sp1);

weak_ptr

weak_ptr是辅助shared_ptr的类，其用来共享但是不拥有对象。

unique_ptr

概念
unique_ptr实现了独占式拥有概念，其可以确保一个对象和其相应的资源在同一时间只能被一个pointer拥有。unique_ptr是其所指向的对象的唯一拥有者。unique_ptr有着与普通指针相同的接口，不同的是：它不提供pointer算术比如++等操作，但是实际上这省去了一些麻烦。
转移unique_ptr的拥有权

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int* p=new int(1);
unique_ptr<int> up1(p);
unique_ptr<int> up2(p);//ERROR,up1和up2拥有相同对象了。
unique_ptr<int> up3(new int(1));
unique_ptr<int> up4(up3);//ERROR, 不能对unique_ptr进行拷贝和赋值
unique_ptr<int> up5(std::move(up3));//OK 使用move转移所有权是可以的
//同理
unique_ptr<int> up6=new int(1);
unique_ptr<int> up7;
up7=up6;//ERROR
up7=std::move(up6);//可以
up7=nullptr;//给unique_ptr赋值nullptr是可以的，和调用reset()方法相同

源头和去处
函数可以利用unique_ptr的转移所有权的功能将拥有权转给其他函数。
unique_ptr当做当做class内的成员
可以避免资源泄漏。

Effective Modern C++ 中的有关条款

《Effective Modern C++》一书中有几个关于smart pointer的条款。
Item 18: Use std::unique_ptr for exclusive-ownership resource management
要点：详见原书 P118
1、std::unique_ptr是一种足够小，很快并且只支持move的智能指针，其用来管理独占式资源。默认情况下，std::unique_ptr的大小和raw pointer 是一样的，而且对于大多数包括解引用在内的操作，其都和raw pointer一致。
2、默认情况下，其使用delete作为deleter。但是当deleter采用自定义时，std::unique_ptr的大小会变大，其具体大小取决于函数对象的状态。使用lambda表达式作为deleter是比较好的一种选择。
3、std::unique_ptr不能进行复制，否则就违反了其只能拥有一个对象的规则。
4、std::unique_ptr有两种形式: std::unique_ptr,std::unique_ptr。这两种形式所能进行的操作略有不同，对于单对象形式，其没有索引操作，对于数组形式，其没有 解引用操作。
5、从std::unique_ptr转型为std::shared_ptr很方便，在不知道指针的具体用途时最好先用unique_ptr，待需要时再转型为shared_ptr。
题外话要想正确调用继承类的析构函数，基类的析构函数必须是虚函数。

Item 19: Use std::shared_ptr for shared_ownership resource management
要点：详见原书 P125
1、关于引用计数
通常，构造函数增加引用计数；析构函数减少引用计数；复制赋值操作减少左边所指对象的引用计数，增加右边所指对象的引用计数。
2、引用计数会影响性能
主要由以下原因造成：首先，shared_ptr的大小是原始指针的2倍，因为其有1个指针指向所引的对象，1个指针指向引用计数；然后，用于引用计数的内存要动态分配；对于引用计数的增加和减少操作必须是原子性的，这是为了保证其在多线程情况下的安全性。
3、shared_ptr和unique_ptr的区别和联系
A、都支持自定义deleter，但是实现有所不同，对于unique_ptr，deleter的类型是智能指针类型的一部分，而对于shared_ptr,deleter的类型不是其一部分。

1
2
3
4
5
6
7
auto loggingDel =[](Type* pc){
    makeLogEntry(pt);
    delete pt;
}
std::unique_ptr<Type, decltype(loggingDel)> upt(new Type,loggingDel);
std::shared_ptr<Type> spt(new Type,loggingDel);

所以，对于不同类型的deleter的两个shared_ptr，只要它们的对象类型相同，其就可以相互赋值；而对于unique_ptr则不能，因为deleter也是其类型的一部分，这意味着这两个unique_ptr的类型不同，不能相互转移所有权。
B、对于shared_ptr，自定义deleter并不改变shared_ptr的大小，但是对于unique_ptr是有影响的。
C、shared_ptr不支持数组类型。

1
shared_ptr<T[]> sp;//不能编译

4、shared_ptr的实现原理
其使用control block管理引用计数及其他(包括自定义deleter)数据。
shared_ptr原理
我们希望某个对象的control block是在初次有指针指该对象时创建。然而当创建shared_ptr指向某一对象时，我们事先并不能知道是否已有其它shared_ptr指向该对象。于是使用以下规则来进行control block的创建：
std::make_shared总是创建一个control block
当shared_ptr是由unique_ptr转型创建时要建立control block_
当用raw pointer构造shared_ptr时要创建control block

考虑如下语句

1
2
3
auto pt = new Type;
std::shared_ptr<Type> spt1(pt,loggingDel);
std::shared_ptr<Type> spt2(pt,loggingDel);

按照之前的control block创建规则，对于pt指针指向的对象，将会创建2个control block，于是离开作用域时，会尝试对*pt进行两次内存释放操作，这样第二次操作将会造成未定义行为。这是我们不愿意看到的。
从以上例子我们可以得到这样的经验：
避免向shared_ptr的构造函数传递raw pointer
可以采用以下方法

1
2
3
4
//对于自定义deleter的情况
std::shared_ptr<Type> spt1(new Type,loggingDel);
//无自定义deleter时还可使用make_shared
std::make_shared<Type>(t);

5、可使用std::enable_shared_from_this将this指针转型成shared_ptr

Item 20: Use std::weak_ptr for std::shared_ptr like pointers that can dangle
要点：具体看原书P134
std::weak_ptr不会影响引用计数值
std::weak_ptr的行为和shared_ptr相似，但是其不会影响所指对象的引用计数值，也不能被解引用，其是shared_ptr的辅助。

1
2
3
4
auto spt=std::make_shared<Type>();//ref count=1
std::weak_ptr<Type> wpt(spt);// ref count remains 1
spt=nullptr;//ref count=0 and wpt now dangles
if(wpt.expired()){} //test if wpt doesn't point to an object

一个问题就是：在判断weak_ptr仍然指着一个特定对象时，如何访问该对象？这里有几个棘手的问题需要解决：weak_ptr并没有解引用操作，而且即便有解引用操作，在判断是否expired和解引用的语句之间，可能有另一个线程使得最后一个指向该对象的指针失效，使得该对象被destroy，这样解引用操作将会导致未定义行为，即我们无法保证线程安全性。
我们需要的是一个原子性的操作检查weak_ptr是否expired，如果没有，那么访问该指针所指对象，这可以通过从weak_ptr构造一个shared_ptr实现。

1
2
3
4
5
//第一种形式
std::shared_ptr<Type> spt1=wpt.lock();//if wpt's expired,spt1 is nullptr
//第二种形式
std::shared_ptr<Type> spt2(wpt);//if wpt's expired, throw std::bad_weak_ptr

2、weak_ptr的应用场景
A、管理缓存时，需要知道cache什么时候会dangle，这样的场景就需要weak_ptr辅助。(P136)
B、解决shared_ptr的环形引用问题。
3、weak_ptr和shared_ptr
从效率的角度讲，weak_ptr的效率和shared_ptr是一样的。其存储和shared_ptr是一样的 ，其大小和shared_ptr也是一样的，它也要使用control block管理对象。注意：weak_ptr不是不管理引用计数，而是不拥有对象共享关系，所以不会影响所指对象的引用计数，但是其会管理另外的不同功能的引用计数。

Item 21: Prefer std::make_unique and std::make_shared to direct use of new
要点：具体看原书P139
1、使用make函数的优点
make_shared是C++11的标准，make_unique是C++14的标准。
A、使得代码和编译的目标代码更精简

1
2
3
4
5
auto upt1(std::make_unique<Type>());
std::unique_ptr<Type> upt2(new Type);
auto spt1(std::make_shared<Type>());
std::shared_ptr<Type> spt2(new Type);

B、使用make函数使得异常安全(exception safety)
C、make_shared和allocate_shared函数使得编译器生成更小更快的代码(相比使用new创建)

原则是优先使用make函数创建只能指针，但是也有make函数不能使用的情况。
A、比如要自定义deleter时，就只能使用new作为参数创建，而不能使用make函数。
B、一些所指对象的初始化细节使得不能使用make函数创建智能指针。
C、一些自定义了new和delete的对象不方便用make函数创建智能指针。
D、对于比较大的对象，不要使用make函数创建智能指针。

Item 22: When using the Pimpl Idiom, define special member functions in the implementation file
要点：
1、Pimpl Idiom通过类客户和类实现之间减少编译依赖来减少构建时间
2、对于std::unique_ptr pImpl指针，需要在类头文件中声明特殊成员函数，在实现文件中实现。即便是默认函数实现，也需要声明和定义。
3、对于 shared_ptr则没有以上这种限制。主要原因还是在于unique_ptr和shared_ptr中deleter是否是类型的一部分的一个区别。

opencv 中的cv::Ptr

其行为和std::shared_ptr类似。用法也基本相同。

参考

1、Nicolai M. Josuttis
The C++ Standard Library - A Tutorial and Reference, 2nd Edition
Addison Wesley Longman, 2012
2、Scott Meyers
Effective Modern C++ : 42 Specific Ways to Improve Your Use of C++11 and C++14
3、std::shared_ptr
4、std::weak_ptr
5、std::unique_ptr
6、cv::Ptr

展开全文 >>

SSD-Single Shot MultiBox Detector

因为毕设是做关于目标检测的项目，也看了一些目标检测的论文，由于项目对实时性的要求，最后选用了MobilenetV2+SSD作为基础结构，也仔细阅读了SSD的论文，现梳理如下。

亮点

一步完成检测，同时进行边框回归和类别预测，相对于两步完成的网络在时间上会快很多。结合多个feature maps的特征进行预测。

基本结构

基本思想

feature map
在不同尺度的feature map上指定一系列default boxes。具体来说就是，上图的feature map中，对于每个cell，首先生成k个default boxes，对于每个default box,预测其类别和位置，于是共有(4+cls)个参数。每层的k个default boxes的aspect ratio不同，而不同feature maps上的default boxes的scale不同，这样基本就能适配各种状态下的目标。最后将不同feature maps上的结果综合起来进行训练。这样对于一个输入的大小为mxm的feature map，最后的得到的default boxes个数为 mmk(4+cls),为了达到这样的输出维度，用一个深度为k(4+cls)的33，stride=1的卷积核即可得到，但是实际上是分为两个不同的卷积来实现，一个深度为4k的loc层，一个深度为k*cls的conf层。

网络结构

SSD网络结构
SSD的网络结构中包括base部分的特征提取层，以及额外的extra layer用于生成不同尺度的feature map用于default boxes的生成。base部分理论上可以是任何用于classification的卷积网络。在原论文中，作者使用VGG-16作为base网络，feature maps总共有6层，前两层为base 网络中的两个卷积层，后4层feature maps来自extra layers。在6个feature maps上做卷积操作得到综合的输出送入loss层进行回归训练。

实现细节

prior box的生成

实际上就是解决不同level的feature maps上的default boxes如何与原图上的default boxes相对应的问题，也就是根据default box的4个offset参数，如何找到其在原图上的对应坐标。这就是prior box的生成问题。
简单来说就是根据scale以及aspect ratio按照步长生成，步长就相当于feature map中一个像素对应的原图中的像素数，实际上就是原图大小和feature map的比值。论文中生成的坐标格式是[cx,cy,w,h]格式。

匹配策略

在确定default box和 groud truth的对应关系时，采用best jaccard overlap方法，对于jaccard overlap高于一个阈值(0.5)的匹配对，我们都认为它们匹配成功。然后利用这些匹配对计算loss，进行回归。

loss function

loss由loc loss和 conf loss两部分组成，分别表示定位损失和分类损失，具体计算公式在原文中讲的很具体。

参考

SSD论文
ssds.pytorch
SSD阅读笔记
目标检测|SSD原理与实现

展开全文 >>

Pytorch使用问题记录

主要记录使用pytorch过程中的一些问题及解决方法
1、GPU训练网络后，在CPU中使用的问题
1.1、使用load_static_dict API时需要根据是否使用GPU指定map参数。

1
2
3
4
if self.num_gpu == 0:
    map_location = lambda storage, loc: storage
else:
    map_location = None

1.2、在我的一次实验中，多GPU训练后保存的pth模型和单GPU的有点不太一致，使得多GPU的模型不能在CPU上加载。解决方案是，先在多GPU训练，最后几个epoch使用单GPU训练，之后保存单GPU的训练模型。

展开全文 >>

高级数据结构与算法分析 课程要点

week1 AVL Trees, Splay Trees and Amoritized Analysis

AVL Trees

Insert
RR LL LR RL
Delete
no child
only left/right child
left and right children: find smallest node in right child, swap and delete

Splay Trees

Find
每查询一次都将其旋转到根节点。
Delete
Find X —> Remove X —> FindMax(LTree) —> 将右子树作为左子树的右孩子

Amoritized Analysis

Aggregate analysis
Accounting method
Potential method

Week2 Red-Black Trees and B+ Trees

Red-Black Trees

Definition
A red-black tree with N internal nodes has height at most 2ln(N +1).
Insert
3 cases
Delete
delete a leaf node
delete a degree 1 node
delete a degree 2 node
关键是调整颜色：4 cases

B+ Trees

Definition
Insert
Delete

Week3 Inverted File Index

Some definition
Index
Inverted file
Key points
Word Stemming
Stop Words
Accessing a term: Search trees(B-trees,B+ trees, Tries,..) or Hashing?
Distributed indexing: Term-partitioned index and Document-partitioned index
Measures for a search engine: 1-How fast does it index? 2-How fast does it search? 3-Expressiveness of query language
Relevance measurement: Precise Recall

Week4 Leftist Heaps and Skew Heaps

Leftist Heaps

Definition
null path length
A leftist tree with r nodes on the right path must have at least \(b^2-1\) nodes.
Merge
recursive version and iterative version
DeleteMin
delete the root and merge the two subtrees

Skew Heaps

Definition
a simple version of the leftest heaps
Merge
Amortized Analysis for Skew Heaps

Week5 Binomial Queue

Definition
FindMin
Merge
DeleteMin
Implementation
left child and right next sibling
Performing N Inserts on an initially empty binomial queue will take O(N) worst-case time. Hence the average time is constant.

Week6 Backtracking

Week7 Divide and Conquer

Week8 Dynamic Programming

参考

展开全文 >>

Effective Python 编写高质量代码的59个有效方法

条款总览

用Pythonic方式来思考

1、确认自己所用的Python版本
2、遵循PEP 8 风格指南
3、了解bytes、str与unicode的区别
4、用辅助函数来取代复杂的表达式
5、了解切割序列的方法
6、在单次切片操作内，不要同时指定start、end和stride
7、用列表推导取代 map 和 filter
8、不要使用含有两个以上表达式的列表推导
9、用生成器表达式来改写数据量较大的列表推导
列表推导方法：

1
2
value = [len(x) for x in open('/tmp/my_file.txt')]
print(value)

生成器表达式是对列表推导和生成器的一种泛化。

1
2
3
it = (len(x) for x in open('/tmp/my_file.txt'))
print(it)
print(next(it))

输入数据量较大时，列表推导可能会因为占用太多内存而出问题 。有生成器表达式所返回的迭代器，可以逐次产生输入值，从而避免了内存用量问题。把某个生成器表达式所返回的迭代器，放在另一个生成器表达式的for子表达式中，可将二者组合起来。串在一起的生成器表达式执行速度更快。
10、尽量用enumerate取代range
enumerate函数提供了一种精简的写法，可以在遍历迭代器时获知每个元素的索引。尽量用enumerate来改写那种将range与下标访问相结合的序列遍历代码。可以给enumerate提供第二个参数，以指定开始计数时所用的值(默认值是0)
11、用zip函数同时遍历两个迭代器
12、不要在for和while循环后面写else块
13、合理利用try\except\else\finally结构中的每个代码块
无论try块是否发生异常，都可以利用try/finally复合语句中的finally块来执行清理工作。else块可以用来缩减try块中的代码量，并把没有发生异常时所要执行的语句与try/except代码块隔开。顺利运行try块后，若想使得某些操作能在finally块的清理代码之前执行，则可将这些操作写到else块中。

1
2
3
4
5
6
7
8
9
def example():
    try:
        do_something()
    except Error as  e:
        return UNDEFINED
    else:
        do_otherthing()
    finally:
        clean()

函数

14、尽量用异常来表示特殊情况，而不要返回None
15、了解如何在闭包里使用外围作用域中的变量
对于定义在某作用域内的闭包来说，它可以引用这些作用域中的变量。使用默认方式对闭包内的变量赋值，不会影响外围作用域中的同名变量。在Python3中，程序可以在闭包内用nonlocal语句来修饰某个名称，使得该闭包能够修改外围作用域中的同名变量。除了一些比较简单的函数，尽量不要使用nonlocal语句。
16、考虑用生成器来改写直接返回列表的函数
17、在参数上面迭代时，要多加小心
18、用数量可变的位置参数减少视觉杂讯
在def语句中使用args,即可令函数接受数量可变的位置参数。调用函数时，可以采用操作符，把序列中的元素当成位置参数, 传给该函数。对生成器使用操作符，可能导致程序耗尽内存并崩溃。在已经接受 args参数的函数上面继续添加位置参数，可能会产生难以排查的bug。
19、用关键字参数来表示可选的行为
函数参数可以按位置或关键字来指定。只使用位置参数来调用函数，可能会导致这些参数值的含义不够明确，而关键字参数则能够阐明每个参数的意图。给函数添加新的行为时，可以使用带默认值的关键字参数，以便与原有的函数调用代码保持兼容。可选的关键字参数，总是应该以关键字形式来指定，而不应该以位置参数的形式来指定。
20、用None和文档字符串来描述具有动态默认值的参数
参数的默认值，只会在程序加载模块并读到本函数的定义时评估一次，对于{}或[]等动态的值，这可能会导致奇怪的行为。对于以动态值作为实际默认值的关键字参数来说，应该把形式上的默认值写为None，并在函数的文档字符串里描述该默认值所对应的实际行为。
21、用只能以关键字形式指定的参数来确保代码明晰
实现方法：

1
def function(args1,args2,*,args3=default_args,args4=default_args)

关键字参数能够使函数调用的意图更加明确。对于各参数之间很容易混淆的函数，可以声明只能以关键字形式指定的参数，以确保调用者必须通过关键字来指定它们。对于接受多个Boolean标志的函数，更应该这样做。

类与继承

22、尽量用辅助类来维护程序的状态，而不要用字典和元组
不要使用包含其他字典的字典，也不要使用过长的元组。如果容器中包含简单而又不可变的数据，那么可以先使用namedtuple来表示，待稍后有需要时，再修改为完整的类。保留内部状态的字典如果变得比较复杂，那就应该吧这些代码拆解为多个辅助类。
23、简单的接口应该接受函数，而不是类的实例
对于连接各种Python组件的简单接口来说，通常应该给其直接传入函数，而不是先定义某个类，然后再传入该类的实例。Python中的函数和方法都可以像一级类那样引用，因此，它们与其他类型的对象一样，也能够放在表达式里面。通过名为call的特殊方法，可以使得该类的实例能够像普通的Python函数那样得到调用。如果要用函数来保存状态，那就应该定义新的类，并令其实现call方法，而不要定义带状态的闭包。
24、以@classmethod形式的多态去通用地构建对象
Python程序中，每个类只能有一个构造器，也就是init方法。通过@classmethod机制，可以用一种与构造器相仿的方式来构造类的对象。通过类方法多态机制，我们能够以更加通用的方式来构建并拼接具体的子类。
25、用super初始化父类
Python使用标准的方法解析顺序来解决超类初始化次序及钻石继承问题。总是应该使用内置的super函数来初始化父类。

展开全文 >>

Properties in Python

Properties in Python

property 初探

Properties 通常用于把公开的属性变成使用读值方法和设值方法管理的属性，且在不影响客户端代码的前提下实施业务规则。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class LineItem:
    def __init__(self, description, weight, price):
        self.description = description
        self.weight = weight
        self.price = price
    
    def subtotal(self):
        return self.weight * self.price
    
    # 读值方法
    @property
    def weight(self):
        return self.__weight
    
    # 设值方法
    @weight.setter
    def weight(self, value):
        if value > 0:
            self.__weight = value
        else:
            raise ValueError('value must be  > 0')
1
2
walnuts_valid = LineItem('walnuts_valid',10,10)
walnuts_invalid = LineItem('walnuts_invalid', 0, 10.00)
10



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

ValueError                                Traceback (most recent call last)

<ipython-input-9-68054ba7debc> in <module>()
      1 walnuts_valid = LineItem('walnuts_valid',10,10)
      2 print(walnuts_valid.weight)
----> 3 walnuts_invalid = LineItem('walnuts_invalid', 0, 10.00)


<ipython-input-8-2cd43540d5e1> in __init__(self, description, weight, price)
      2     def __init__(self, description, weight, price):
      3         self.description = description
----> 4         self.weight = weight
      5         self.price = price
      6 


<ipython-input-8-2cd43540d5e1> in weight(self, value)
     19             self.__weight = value
     20         else:
---> 21             raise ValueError('value must be  > 0')


ValueError: value must be  > 0

如上所示，我们使用property禁止了用户为 weight 属性提供负值或零。值得注意的是，如果一个属性只有读值方法而没有设值方法，那么该属性就是只读属性，对其赋值的操作是不被允许的。

深入理解 property

虽然内置的property经常用于装饰器，但是其实它是一个类。而Python中，函数和类通常可以互换。property构造方法的完整签名如下：

1
property(fget=None, fset=None, fdel=None, doc=None)

其所有参数均是可选的，如果没有把某个函数传递给某个参数，那么得到的特性对象就不允许执行相应操作。
下面是一个不使用装饰器定义的经典方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class LineItem:
    def __init__(self, description, weight, price):
        self.description = description
        self.weight = weight
        self.price = price
    
    def subtotal(self):
        return self.weight * self.price
    
    # 读值方法
    def get_weight(self):
        return self.__weight
    
    # 设值方法
    def set_weight(self, value):
        if value > 0:
            self.__weight = value
        else:
            raise ValueError('value must be  > 0')
    weight = property(fget=get_weight, fset = set_weight)
1
2
walnuts_valid = LineItem('walnuts_valid',10,10)
walnuts_invalid = LineItem('walnuts_invalid', 0, 10.00)
---------------------------------------------------------------------------

ValueError                                Traceback (most recent call last)

<ipython-input-11-2126031d851a> in <module>()
      1 walnuts_valid = LineItem('walnuts_valid',10,10)
----> 2 walnuts_invalid = LineItem('walnuts_invalid', 0, 10.00)


<ipython-input-10-74ad4ef73232> in __init__(self, description, weight, price)
      2     def __init__(self, description, weight, price):
      3         self.description = description
----> 4         self.weight = weight
      5         self.price = price
      6 


<ipython-input-10-74ad4ef73232> in set_weight(self, value)
     17             self.__weight = value
     18         else:
---> 19             raise ValueError('value must be  > 0')
     20     weight = property(fget=get_weight, fset = set_weight)


ValueError: value must be  > 0

property会覆盖实例属性

特性都是类属性，但是特性管理的其实是实例属性的存取。如果实例和所属的类具有同名数据属性，那么实例属性会覆盖类属性。但是实例属性不会遮盖类特性。新添加的类特性会遮盖现有的实例属性。

为property添加文档

对于经典调用句法，只需要对property函数传入doc参数即可。对于装饰器用法，读值方法的文档字符串作为特性的文档。

特性工厂函数

LineItem类存在一个问题，如果其有多个属性需要做限制，那么我们将需要写若干个读值和设值方法来达到目的，而这些方法实际上都是类似的，显得有些麻烦。而借助特性工厂函数，我们可以不用手动实现这样若干对几乎一致的读值和设值方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def quantity(storage_name):
    def qty_getter(instance):
        return instance.__dict__[storage_name]
    
    def qty_setter(instance, value):
        if value > 0:
            instance.__dict__[storage_name] = value
        else:
            raise ValueError('value must be > 0')
    return property(qty_getter, qty_setter)
class LineItem:
    weight = quantity('weight')
    price = quantity('price')
    def __init__(self, description, weight, price):
        self.description = description
        self.weight = weight
        self.price = price
    def subtotal(self):
        return self.weight * self.price

参考

1、Fluent Python by Luciano Ramalho (O’Reilly). Copyright 2015 Luciano Ramalho, 978-1-491-94600-8
2、廖雪峰Python教程—@property

展开全文 >>

MobileNets论文笔记

MobileNets论文笔记，包括MobileNetV1和MobileNetV2。

MobileNetV1

MobileNet的主要贡献在于损失少量精度的前提下减少计算量和参数数量，使得网络可以在移动设备上高效部署。
其重要的一个结构就是Depthwise Separable Convolution，其将普通卷积分解成depthwise卷积和pointwise卷积，以达到减少计算量和参数的目的。
Depthwise Separable Convolution
关于参数减少计算：
参数减少量计算

实现

网络结构定义
MobilenetV1网络结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# MobilenetV1 base 
Conv = namedtuple('Conv', ['stride', 'depth'])
DepthSepConv = namedtuple('DepthSepConv', ['stride', 'depth'])
MOBILENT_CONV_DEFS = [
    Conv(stride=2, depth=32),
    DepthSepConv(stride=1, depth=64),
    DepthSepConv(stride=2, depth=128),
    DepthSepConv(stride=1, depth=128),
    DepthSepConv(stride=2, depth=256),
    DepthSepConv(stride=1, depth=256),
    DepthSepConv(stride=2, depth=512),
    DepthSepConv(stride=1, depth=512),
    DepthSepConv(stride=1, depth=512),
    DepthSepConv(stride=1, depth=512),
    DepthSepConv(stride=1, depth=512),
    DepthSepConv(stride=1, depth=512),
    DepthSepConv(stride=2, depth=1024),
    DepthSepConv(stride=1, depth=1024)
]

MobileNetV2

MobileNetV2在MobileNetV1的基础上做了一些改进，其实我更感兴趣的是作者提出SSDLite，将MobileNetV2用于目标检测，其精度和速度都超过了YOLOv2。

实现

网络结构
MobilenetV2结构
微结构单元
注意stride=1时有残差结构，stride=2时无残差结构。
Inverted Residual
结构定义

1
2
3
4
5
6
7
8
9
10
11
InvertedResidual = namedtuple('InvertedResidual', ['stride', 'depth', 'num', 't'])
MOBILENET_V2_CONV_DEFS = [
    Conv(stride=2, depth=32),
    InvertedResidual(stride=1, depth=16, num=1, t=1),
    InvertedResidual(stride=2, depth=24, num=2, t=6),
    InvertedResidual(stride=2, depth=32, num=3, t=6),
    InvertedResidual(stride=2, depth=64, num=4, t=6),
    InvertedResidual(stride=1, depth=96, num=3, t=6),
    InvertedResidual(stride=2, depth=160, num=3, t=6),
    InvertedResidual(stride=1, depth=320, num=1, t=6),
]

参考

MobileNetV1 paper
MobileNetV2 paper
MobileNets详解
Mobilenet pytorch实现
tensorflow mobilenet_v1
tensorflow mobilenet_v2

展开全文 >>

Tensorflow Programming -- Eager Execution

Eager Execution

目前使用TensorFlow时，需要编写一个Python程序，首先构建一个表示计算的图，然后调用Session.run()将这个计算图交给C++运行库执行，从这个意义上说，Tensorflow提供了一个声明式编程模型，其计算图的构建和实际的执行是分离的。

计算图的优点

TensorFlow从某种意义上说是一种编程语言和一种用于机器学习模型的编译器，其将机器学习模型作为输入，编码成一个名为Graph的低级表示，然后将其重写为优化的可执行形式，沿途使用类似编译器的优化。这种模式有许多好处：
1、优化可以减少训练模型或运行推理的挂钟时间和内存占用时间
2、计算图作为平台不可知的中间表示，简化了部署。
3、重写图形的能力使得我们可以尝试像自动设备放置和重量量化这样的策略。

优化的

自动缓冲区重用
不断折叠
操作间并行性
计算和内存之间的自动权衡

可部署

图就是模型的中间表示

可重写

尝试自动设备放置或 量化

计算图的缺点

尽管计算图的表示方法有很多优点，但是其缺点也不小。声明式范例导致难以调试的程序，因为在构建计算图之后会报告错误。而且由于计算图执行是由Session管理的，所以不能够使用pdb甚至是打印语句来调试模型。构建图形就像使用汇编语言进行编码-原则上我们可以使用计算图来实现我们所需要的任何机器学习模型，但是这样做可能比较困难。编写一个TensorFlow程序是元编程的一个练习: 使用Python用TensorFlow图形语言编写程序。因此，我们不能使用本地Python控制流结构，而必须依赖它们在TensorFlow中的等价物。而且，不能轻易地将图形构造与自定义数据混合在一起，我们可能想要使用Python类来表示结构化数据，但是无法传递类，无法沿着图的边缘流动。总结下来就是如下缺点：

难以调试

计算图构建之后会报告错误
执行不能用pdb或者打印语句来调试

Un-Pythonic

编写一个Tensorflow程序是元编程的练习
控制流(如 tf.while_loop)与Python不同
不能轻松地将计算图构建与自定义数据结构混合

Eager Execution

我们可以直接从Python执行TensorFlow操作吗？实际上，我们不能将任何给定的计算图打破到它的组件操作并直接从Python中调用它们。
Eager Execution是用于计算的类Numpy库，支持GPU加速和自动分化，以及灵活的机器学习研究和实验平台。
使用Eager的例子：

1
2
3
4
$python
import tensorflow as tf # version >= 1.50
import tensorflow.contrib.eager as tfe
tfe.enable_eager_execution()

Eager Execution的优点

与Python调试工具兼容
提供即时的错误报告
允许使用Python数据结构

例如用于结构化输入。

启用Pythonic控制流程

Eager Execution可以简化代码

我们不再需要担心以下这些问题:
1、placeholders
下面是一个程序，它将一个矩阵与自身相乘。我们首先用一个占位符定义一个计算图，并将矩阵提供给平方。

1
2
3
4
5
6
7
8
9
10
x = tf.placeholder(tf.float32, shape=[1,1])
m = tf.matmul(x, x)
print(m)
# Tensor("MatMul:0",shape=(1, 1),dtype=float32)
with tf.Session() as sess:
    m_out = sess.run(m, feed_dict={x:[[2.0]]})
print(m_out)
# [[4.0]]

而如果使用了Eager Execution，下面三行代码提供了相同的效果。没有Session，没有placeholder和matmul操作，立即得出运算结果。

1
2
3
4
x = [[2.]] # No need for placeholders!
m = tf.matmul(x,x)
print(m) # No sessions!
# tf.Tensor([[4.]], shape=(1,1), dtype=float32)

2、sessions
3、control dependencies
4、”lazy loading”
Eager Execution还有利于避免元编程的一些缺点。例如，以下的代码就是在程序中间快速破解分析Tensor X的代码。循环的每一次迭代都是将操作添加到计算图的内存中表示。在这种情况下，每次调用session.run()都会执行random_uniform操作，所以这里的代码片段并没有打印Tensor的一致快照。

1
2
3
4
5
x = tf.random_uniform([2, 2])
with tf.Session() as sess:
    for i in range(x.shape[0]):
        for j in range(x.shape[1]):
            print(sess.run(x[i,j]))

而当在Eager Execution的情况下，没有一个计算图的概念或者一个操作的重复执行，所以最明显的做法是很好的。

1
2
3
4
x = tf.random_uniform([2,2])
for i in range(x.shape[0]):
    for j in range(x.shape[1]):
        print(x[i,j])

5、{name, variable, op} scopes

Tensors和NumPy数组的行为相似

1
2
3
4
5
6
7
x = tf.constant([1.0, 2.0, 3.0])
# Tensors are backed by Numpy arrays
assert type(x.numpy()) == np.ndarray
squared = np.square(x) # Tensors are compatible with Numpy functions
# Tensors are iterable 
for i in x:
    print(i)

梯度

自动梯度求解已经加入到eager execution中。当启用eager execution时，执行的操作将在一个”tape”中进行追踪，以回放计算梯度。如果熟悉autograd包的话，这个API非常相似。

1
2
3
4
5
6
7
def square(x):
    return x**2
grad = tfe.gradients_function(square)
print(square(3.)) # tf.Tensor(9., shape=(), dtype=float32)
print(grad(3.)) # tf.Tensor(6., shape=(), dtype=float32)

1
2
3
4
5
6
7
8
9
x = tfe.Variable(2.0)
def loss(y):
    return (y - x ** 2) ** 2
grad = tfe.implicit_gradients(loss)
print(loss(7.)) # tf.Tensor(9., shape=(), dtype=float32)
print(grad(7.)) # [(<tf.Tensor: -24.0, shape=(), dtype=float32>, 
                #    <tf.Variable 'Variable:0' shape=()                
                #     dtype=float32, numpy=2.0>)]

即便eager execution没被允许，计算梯度的API依然有效。
tfe.gradients_function()
tfe.value_and_gradients_function()
tfe.implicit_gradients()
tfe.implicit_value_and_gradients()
详情可参考：
eager execution document

Linear Regression in Eager

A Collection of Operations

TensorFlow = Operation Kernels + Execution
Graph construction: 使用Session来执行操作的组合
Eager execution: 用Python执行操作的组合。
观察TensorFlow的一种方式是作为一系列操作：数学，线性代数，图像处理，Tensorboard可视化的总结生成等以及执行构成它们的计算的手段。Session提供了一种方法来执行这些操作，在执行的时候，Python是执行组合的方法，但是底层的操作保持不变，结果，API表面的大部分也保持不变。
不管eager execution是否被允许，大多数TensorFlow API都可以工作，但是当eager exectution允许时，有一些特殊情况需要注意：
1、在eager execution模式下最好使用tfe.Variable
2、管理好自己的变量存储，变量集合是不被允许的。
3、使用 tf.contrib.summary
4、使用tfe.Iterator 进行数据迭代
5、最好使用面向对象的层(比如 tf.layers.Dense)
6、使用tfe.py_func 代替 tf.py_func

什么情况下使用eager execution?

作为研究人员希望一个灵活的框架

python控制流和数据结构使得实验成为可能

需要开发一个新的模型

即时的错误报告简化了调试

刚接触TensorFlow

eager execution使得我们方便在Python REPL中学习TF API。

参考

04_eager_execution slides
04_eager_execution notes

展开全文 >>

Effective Java -- Classes and Interfaces

Effective Java Items about Classes and Interfaces

类和接口是Java的核心，其也是Java的基本抽象单元。Java提供了许多强大的基本元素，供程序员用来设计类和接口。以下一些指导原则可以帮助我们更好地利用这些元素设计出更加有用、健壮和灵活的类和接口。

Item 15: Minimize the accessibility of classes and members

使类和成员的可访问性最小化。我们始终应该尽可能地降低可访问性。你在仔细地设计了一个最小的公有API之后，应该防止把任何散乱的类、接口和成员变成API的一部分。除了公有静态final域的特殊情形之外，公有类都不应该包含公有域。并且要确保公有静态final所引用的对象都是不可变得。

Item 16: In public classes, use accessor methods, not public fields

在公有类中使用访问方法而非公有域。公有类永远都不应该暴露可变的域，虽然还是有问题，但是让公有类暴露不可变的域其危害比较小。但是，有时候会需要用包级私有的或者私有的嵌套来暴露域，无论这个类是可变的还是不可变的。

Item 17: Minimize mutability

使可变性最小化。不可变的类比可变类更加易于设计、实现和使用。它们不容易出错，且更加安全。为了使类成为不可变，要遵循以下五条规则:
1、不要提供任何会修改对象状态的方法。
2、保证类不会被扩展。一般做法是使这个类成为final的。
3、使所有的域都是final的。
4、使所有的域都成为私有的。
5、确保对于任何可变组件的互斥访问。

不可变对象本质上是线程安全的，它们不要求同步。不可变类可以被自由地共享。永远也不需要对不可变类进行保护性拷贝。不仅可以共享不可变对象，甚至也可以共享它们的内部信息。不可变对象为其他对象提供了大量的构件，无论是可变的还是不可变的。不可变类真正唯一的缺点是，对于每个不同的值都需要一个单独的对象。
为了确保不可变类不被子类化。除了使得类成为final的方法之外，还可以让类的所有构造器都变成私有的或者包级私有的，并添加公有的静态工厂来代替公有的构造器。

Item 18: Favor composition over inheritance

复合优先于继承。继承的功能非常强大，但是也存在诸多问题，因为它违背了封装原则。只有当子类和超类之间确实存在子类型关系时，使用继承才是恰当的。即便如此，如果子类和超类处在不同的包中，并且超类并不是为了继承而设计的，那么继承将会导致脆弱性。为了避免这种脆弱性，可以用复合和转发机制来代替继承，尤其是当存在适当的接口可以实现包装类的时候。包装类不仅比子类更加健壮，而且功能也更加强大。

Item 19: Design and document for inheritance or else prohibit it

要么为继承而设计，并提供说明文档，要么就禁止继承。

Item 20: Prefer interfaces to abstract classes

Item 21: Design interfaces for posterity

Item 22: Use interfaces only to define types

Item 23: Prefer class hierarchies to tagged classes

Item 24: Favor static member classes over nonstatic

Item 25: Limit source files to a single top-level class

展开全文 >>

Thinking in Java Notes -- Interfaces and Inner Classes

Interfaces

抽象类和抽象方法

包含抽象方法的类叫做抽象类，如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。如果从一个抽象类继承，并想创建该新类的对象，那么就必须为基类中的所有抽象方法提供方法定义。

接口

interface关键字使得抽象的概念更向前迈进一步。interface关键字产生一个完全抽象的类，其根本没有提供任何具体实现。接口可以包含域，但是这些域隐式地是static和final的。接口中定义的方法必须是public的，否则，其就只能得到默认的包访问权限。

完全解耦

将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，因此代码也就更具有可复用性。？

用接口实现多重继承

使用接口的核心原因是：为了能够向上转型为多个基类型以及由此带来的灵活性。第二个原因与使用抽象基类相同：防止客户端程序员创建该类的对象，并确保这仅仅是建立一个接口。如何在接口和抽象类之间进行选择？如果要创建不带任何方法定义和成员变量的基类，那么就应该选择接口而不是抽象类。如果知道某事物应该成为一个基类，那么第一选择是使它成为一个接口。

通过继承来扩展接口

通过继承可以容易地在接口中添加新的方法声明，还可以通过继承在新接口中组合数个接口。注意在打算组合的不同接口中使用相同的方法名通常会造成代码可读性的混乱，需要尽量避免这种情况。

适配接口

接口最吸引人的原因之一是允许同一个接口有多个不同的具体实现。简单的情况中，它的体现形式通常是一个接受接口类型的方法，而该接口的实现和向该方法传递的对象则取决于方法的使用者。

接口中的域

接口中的任何域都自动是static和final的。

嵌套接口

接口与工厂

接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂方法设计模式。

Inner Classess

将一个类的定义放在另一个类的定义内部，这就是内部类。

创建内部类

如果想从外部类的非静态方法之外的任意位置创建某个内部类的对象，那么必须像在main()方法中 那样，具体地指明这个对象的类型: OuterClassName.InnerClassName。

链接到外部类

当生成一个内部类的对象时，此对象与制造它的外围对象之间就有了一种联系，所以它能访问其外围对象的所有成员，而不需要任何特殊条件。此外，内部类 还拥有其外围类的所有元素的访问权。

使用.this与.new

内部类与向上转型

在方法和作用域内的内部类

匿名内部类

嵌套类

为什么需要内部类?

…?
不太看得懂，剩下的以后再补充

展开全文 >>

Thinking in Java Notes -- Basic

第1章 对象导论

第2章 一切都是对象

1、理解static关键词。当声明一个事物是static时，就意味着这个域或方法不会与包含它的那个类的任何对象实例关联在一起。

第3章 操作符

1、注意 == 操作符和equals()方法的区别。
2、移位操作符<<和>>，对于<<左移操作符，低位补0即可，对于>>右移操作符，采用“符号扩展”，符号为正，在高位插入0，符号为负则在高位插入1。Java中增加了一种有别于其它语言的“无符号”右移操作符>>>，无论正负都在高位插入0。

第4章 控制执行流程

第5章 初始化与清理

1、只能根据参数列表区分重载方法，而不能根据返回值的类型区分重载方法。
2、JVM垃圾回收机制。需要之后深入理解。
3、成员初始化。Java尽力保证，所有变量在使用前都能得到恰当的初始化。对于方法的局部变量，Java以编译时错误的形式来贯彻这种保证。如果类的数据成员是基本类型，那么可以不用初始化，其保证会有一个默认的初始值。在类里定义一个对象引用时，如果不将其初始化，此引用就会获得一个特殊值null。注意初始化时出现的“向前引用”的错误。
4、初始化顺序：类的内部，变量定义的先后顺序决定了初始化的顺序。
5、静态数据的初始化：无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。初始化的顺序是先静态对象（如果它们还没有因为前面的对象创建过程而被初始化），而后是“非静态对象”。
6、对象的创建过程大概如下：
假设有个名为Dog的类。
a、即便没有显式地使用static关键字，构造器实际上也是静态方法，因此，当首次创建类型为Dog的对象时(构造器可以看做static方法)，或者Dog类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件。
b、然后载入Dog.class，有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
c、当用new Dog() 创建对象的时候，首先将在堆上为Dog对象分配足够的存储空间。
d、这块存储空间会被清零，这就自动地将Dog对象中的所有基本类型数据都设置成了默认值，而引用则被设置成了null。
e、执行所有出现于字段定义处的初始化动作。
f、执行构造器。

第6章 访问权限控制

1、关键字
private
protected：继承访问权限。
public：接口访问权限。
默认访问权限：包访问权限。

第7章 复用类

1、可以通过组合语法，继承语法，代理，结合使用组合和继承等方法实现类的复用。
2、@Override 的使用，当想要覆写某个方法时，可以选择添加这个注解，在不小心重载并非覆写了该方法时，编译器会生成错误信息。
3、在组合和继承之间做合适选择。一般来说，is-a关系用继承表达，has-a关系用组合表达。究竟改用组合还是用继承，一个比较清晰的判断方法就是看是否需要从新类向基类进行向上转型，如果必须向上转型，那么继承是必要的；如果不需要，则应该慎重考虑是否需要继承。
4、final关键字：包括final参数，final方法， final类的意义。

第8章 多态

1、面向对象的语言的特征：数据抽象，继承和多态。
2、前期绑定和后期绑定：Java中除了static方法和final方法(private方法属于final方法)之外，其他所有的方法都是后期绑定。实际上将方法声明为final的一个重要原因之一是防止他人覆盖该方法，另一个更为重要的原因则是有效关闭动态绑定。
3、缺陷：试图覆盖私有方法。实际上试图在继承类中覆盖基类的私有方法是不对的，如果使用了@Override注解，那么编译会报错，而如果没有使用该注解，那么实际上我们试图要覆盖的那个方法是全新的方法，甚至因为private的权限，这也不是重载。事实上只有非private方法才能被覆盖。
4、复杂对象调用构造器按照下面的顺序：a、在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零；b、调用基类构造器；c、按声明顺序调用成员的初始化方法；d、调用导出类构造器的主体。

展开全文 >>

资料和文章备份


一些资料的备份。

cs20si 2017 notes and slides

1、Overview Of Tensorflow

notes_01
slides_01

2、Operations

notes_02
slides_02

3、Linear and Logistic Regression

notes_03
slides_03

4、Structure Your Tensorflow Model

notes_04
slides_04

5、Manage Experiments and Process Data

notes_05
slides_05

Computer Vision

Object Detection

展开全文 >>

How to Manage Your Experiments in TensorFlow


主要介绍TensorFlow提供的一系列用来管理实验的优秀的工具。包括tf.train.Saver类，
TensorFlow的随机种子和NumPy的随机状态，并可视化我们的训练过程。

tf.train.Saver()

tf.train.Saver()类使得我们能够用二进制文件保存计算图的变量。这样使得我们可以在若干步训练过后保存参数并随时重新加载参数进行训练。

1
2
tf.train.Saver.save(sess, save_path, global_step=None, lastest_filename=None,
                meta_graph_suffix='meta', write_meta_graph=True, write_state=True)

例如我们想每训练1000步保存一次参数，我们可以这样做：

1
2
3
4
5
6
7
saver = tf.train.Saver()
with tf.Session() as sess:
    for step in range(trianing_steps):
        sess.run([optimizer])
        if (step + 1) % 1000 == 0：
            saver.save(sess, 'checkpoint_directory/model_name',
            global_step=model.global_step)

在TensorFlow术语中，保存图形变量的步骤称为检查点。由于我们将创建多个检查点，因此将模型所经历的训练步骤的数量附加到名为global_step的变量中会很有帮助。 在TensorFlow程序中看到这是一个非常常见的变量。 我们首先需要创建它，将其初始化为0，并将其设置为不可训练，因为我们不希望TensorFlow对其进行优化。

1
self.global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')

我们需要将global_step作为参数传递到optimizer中，使得它能够每训练一步加一。

1
self.optimizer = tf.train.GradientDescentOptimizer(self.lr).minimize(self.loss, global_step=self.global_step)

为了在名为“checkpoints”的文件夹保存检查点，我们这样操作：

1
saver.save(sess, 'checkpoints/skip-gram', global_step=model.global_step)

于是整个word2vec的训练过程大概如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
self.global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step')
self.optimizer = tf.train.GradientDescentOptimizer(self.lr).minimize(self.loss,global_step=self.global_step)
saver = tf.train.Saver()
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    average_loss = 0.0
    writer = tf.summary.FileWriter('./improved_graph',sess.graph)
    for index in range(num_train_steps):
        batch = batch.gen_next()
        loss_batch, _ = sess.run([model.loss,model.optimizer],
            feed_dict={model.center_words: batch[0],
                      model.target_words: batch[1]})
        average_loss += loss_batch
        if (index + 1) % 1000 == 0:
            saver.save(sess, 'checkpoints/skip-gram',global_step=model.global_step)

这时检查点文件都在文件夹checkpoints中。
如果想要恢复某个检查点，可以用以下语句：

1
saver.restore(sess, 'checkpoints/skip-gram-1000')

值得注意的是，我们只能恢复已经存在的checkpoints文件，所以在恢复时，需要先检查文件的有效性，可以这样做：

1
2
3
ckpt = tf.train.get_checkpoint_state(os.path.dirname('checkpoints/checkpoint'))
if ckpt and ckpt.model_checkpoint_path:
    saver.restore(sess, ckept.model_checkpoint_path)

默认情况下，saver.save()保存图中的所有变量，而且也是推荐这么做的。但是，但是也可以通过以下方法只保存部分变量的值：

1
2
3
4
5
6
7
8
9
10
11
v1 = tf.Variable(..., name='v1')
v2 = tf.Variable(..., name='v2')
# pass the variables as a dict:
saver = tf.train.Saver({'v1': v1, 'v2': v2})
# pass them as a list
saver =tf.train.Saver([v1,v2])
# passing a list is equivalent to passing a dict with the variable op names 
saver = tf.train.Saver({v.op.name: v for v in [v1, v2]})

注意：savers只是保存了变量的值，并没有保存整个计算图，所以我们需要自己创建计算图，然后载入变量。检查点文件指定了从变量到tensor的映射方式。人们通常不只是保存上一次迭代的参数，还保存迄今为止效果最好的参数，以便可以根据最佳参数评估模型。

tf.summary

我们可以使用Tensorboard可视化训练数据，包括loss, average loss, accuracy等。可以将它们可视化为点，直方图，甚至是图像。所以我们建立一个新的name scope来管理所有这类操作。

1
2
3
4
5
6
7
8
def _create_summaries(self):
    with tf.name_scope('summaries'):
        tf.summary.scalar('loss', self.loss)
        tf.summary.scalar('accuracy', self.accuracy)
        tf.summary.histogram('histogram loss', self.loss)
        # because you have several summaries, you should merge them all
        # into one op to make it easier to manage
        self.summary_op = tf.summary.merge_all()

然后用 sess.run()来执行。

1
loss_batch, _, summary = sess.run([model.loss, model.optimizer, model.summary_op], feed_dict=feed_dict)

接着我们需要用用于可视化计算图的FileWriter对象来将这些summary写入文件。

1
writer.add_summary(summary, global_step=step)

然后我们就可以得到一些可视化结果。
值得注意的是，如果我们将summary数据保存在graph文件夹的不同子文件夹，就可以对不同超参数的训练结果进行比较。
我们也可以使用tf.summary.image将结果可视化为图片。

1
tf.summary.image(name, tensor, max_output=3, collections=None)

Control Randomization

我们往往必须控制随机化过程才能为实验获得稳定的结果。NumPy以随机种子和随机状态获得随机数。但是TensorFlow不允许我们以numpy的方式获得随机状态，但它确实可以让我们通过以下两种方式获得稳定的随机结果：

在操作级别设置随机种子。 所有的随机张量都允许你在初始化时传入种子值。

1
my_var = tf.Variable(tf.trucated_normal((-1.0,1.0), stddev=0.1, seed=0))

注意每个新会话都会重新开始随机状态。例如：

1
2
3
4
c = tf.random_uniform([], -10, 10, seed=2)
with tf.Session() as sess:
    print(sess.run(c)) # >> 3.57492
    print(sess.run(c)) # >> -5.97319

1
2
3
4
5
6
7
c = tf.random_uniform([], -10, 10, seed=2)
with tf.Session() as sess:
    print(sess.run(c)) # >> 3.57493
with tf.Session() as sess:
    print(sess.run(c)) # >> 3.57493

随着操作级别的随机种子，每个操作保持自己的种子。

1
2
3
4
5
6
c = tf.random_uniform([], -10, 10, seed=2)
d = tf.random_uniform([], -10, 10, seed=2)
with tf.Session() as sess:
    print(sess.run(c)) # >> 3.57493
    print(sess.run(d)) # >> 3.57493

在计算图级别用tf.Graph.seed设置随机种子

1
tf.set_random_seed(seed)

如果你不关心图中每个操作的随机化，而只是希望能够在另一个图上复制结果（以便其他人可以在你自己的图上复制你的结果），你可以使用tf.set_random_seed。设置当前的TensorFlow随机种子只影响当前的默认图形。
例如，有两个模型 a.py 和 b.py，它们有相同的代码。

1
2
3
4
5
6
7
8
9
import tensorflow as tf
tf.set_random_seed(2)
c = tf.random_uniform([], -10, 10)
d = tf.random_uniform([], -10, 10)
with tf.Session() as sess:
    print(sess.run(c))
    print(sess.run(d))

当没有设置图级别的随机种子时，两个代码文件会运行得到不同的结果。而如果设置了，则会得到相同的结果。

Reading Data in Tensorflow

将数据加载到TensorFlow图中有两种主要的方法：一种是通过我们熟悉的feed_dict，另一种是通过读者使我们直接从文件中读取张量。当然，第三种方法是使用常量加载数据，但是这会造成图严重臃肿且无法运行。为了明白为什么我们需要比feed_dict更多的东西，我们需要看看feed_dict是如何工作的。Feed_dict将首先将数据从存储系统发送到客户端，然后从客户端发送到工作进程。这会导致数据变慢，特别是如果客户端与工作进程不在同一台机器上。TensorFlow有readers可以直接将数据加载到工作进程中。当我们不在分布式系统或者当我们的数据集很小的时候，这种改进将不会被注意到，但是它仍然值得研究。 TensorFlow有几个内置读卡器来满足您的阅读需求。

1
2
3
4
5
6
7
8
9
10
11
12
tf.TextLineReader
# Outputs the lines of a file delimited by newlines
# E.g. text files, CSV files
tf.FixedLengthRecordReader
# Outputs the entire file when all files have same fixed lengths
# E.g. each MNIST file has 28 x 28 pixels, CIFAR-10 32 x 32 x 3
tf.WholeFileReader
# Outputs the entire file content
tf.TFRecordReader
# Reads samples from TensorFlow's own binary format (TFRecord)
tf.ReaderBase
# Allows you to create your own readers

从队列读取数据。

1
2
3
filename_queue = tf.train.string_input_producer(['file0.csv', 'file1.csv'])
reader = tf.TextLineReader()
key , value = reader.read(filename_queue)

Threads 和 Queues

我们可以使用tf.Coordinator 和 tf.QueueRunner 来管理队列。

1
2
3
4
with tf.Session() as sess:
    # start populating the filename queue
    coord = tf.train.Coordinator()
    threads = tf.train.start_queue_runners(coord=coord)

参考

notes_05
slides_05

展开全文 >>

Effective Java -- Methods Common to All Objects

Effective Java Items about Methods Common to All Objects

设计Object类的目的是为了扩展，它所有的非final方法(equals, hashCode, toString, clone, finalize)都有着明确的通用约定，它们都被设计成要被覆盖的。任何一个类在覆盖这些方法时都要遵守一些通用规定。

Item 10: Obey the general contract when overriding equals

equals方法实现了等价关系，主要要满足以下条件：自反性，对称性，传递性，一致性，非空性。为了高效编写符合要求的equals方法，书中总结了以下方法：
1、使用==操作符检查参数是否是这个对象的引用。
2、使用instanceof操作符检查“参数是否为正确的类型”。
3、把参数转换成正确的类型。
4、对于该类中的每个“关键”域,检查参数中的域是否与该对象中对应的域相匹配。
5、编写好equals方法之后，再仔细检查是否满足之前的几个条件。
6、覆盖equals时要同时覆盖hashCode
7、不要企图让equals方法过于智能。
8、不要将equals声明中的Object对象替换为其他的类型。

Item 11: Always override hashCode when you override equals

每个覆盖了equals方法的类中，也必须同时覆盖hashCode方法。

Item 12: Always override toString

遵守toString的约定并不像遵守equals和hashCode的约定那么重要，但是提供好的toString实现可以使得类使用起来更为舒适。

Item 13: Override clone judiciously

Item 14: Consider implementing Comparable

展开全文 >>

Structure Your Tensorflow Model Notes


之前已经介绍了使用tensorflow构建线性回归以及用逻辑回归来进行MNIST手写字母识别,这些都属于比较简单的网络结构。当我们需要构建更为复杂的结构时，就需要好好计划编码结构，不然代码混乱不说而且难于调试。这里主要介绍如何高效结构化模型，以word2vec作为例子说明。
关于word2vec的理论知识可以参考cs224n的课件。主要介绍利用tensorflow搭建skip-gram模型。原理可参考：
Word2Vec Tutorial—The Skip-Gram Model

如何结构化Tensorflow模型

tensorflow中模型的结构

第一步，构建计算图

1、为输入和输出定义placeholders
2、定义权重weights
3、定义inference model
4、定义损失函数
5、定义优化器

第二步，计算

1、初次初始化所有模型变量
2、输入训练数据，可能还会涉及随机化数据样本的顺序。
3、对训练数据执行推理模型，从而计算每个训练输入以当前模型参数的输出结果。
4、计算损失
5、调整模型参数使得模型的损失最大或者最小。

Word2Vec, skip-gram model实例

第一步，构建计算图

1、为输入和输出定义placeholders
输入是中心词，输出是目标(上下文)词，我们直接输入这些词的索引而不是one-hot向量，例如：如果中心词是单词表中的第1001个单词，我们输入数字1001。每个样本输入都是一个标量，所以我们以形状[BATCH_SIZE]的占位符定义批量大小为BATCH_SIZE的输入。同样，输出也是用同样的方法定义。

1
2
center_words = tf.placeholder(tf.int32, shape=[BATCH_SIZE])
target_words = tf.placeholder(tf.int32, shape=[BATCH_SIZE])

2、定义权重weights
每行对应一个词的表示向量。如果用一个词表示一个大小为EMBED_SIZE的向量，那么嵌入矩阵的形状为[VOCAB_SIZE,EMBED_SIZE]。我们将嵌入矩阵初始化为随机分布的值。

1
embed_matrix = tf.Variable(tf.random_uniform([VOCAB_SIZE,EMBED_SIZE],-1.0,1.0))

3、定义推理模型
我们的目标是得到词汇表中单词的向量表示，embed_matrix的维度是[VOCAB_SIZE x EMBED_SIZE]，embedding矩阵的每一行和该索引出的单词的矢量表示相对应。为了得到批次中所有中心词的表示，我们得到所有相应行的切片嵌入矩阵。Tensorflow为我们提供了一个简单的API：tf.nn.embedding_lookup()。

1
tf.nn.embedding_lookup(parmas, ids, partition_strategy='mod', name=None, validate_indices=True, max_norm=None)

于是为了得到输入中心词的嵌入矩阵表示，我们这样操作:

1
embed = tf.nn.embedding_lookup(embed_matrix, center_words)

4、定义损失函数
对于NCE损失，我们需要隐藏层的权重和偏置来计算。

1
2
3
4
5
6
7
8
nce_weight = tf.Variable(tf.truncated_normal([VOCAB_SIZE, EMBED_SIZE],stddev=1.0/EMBED_SIZE**0.5))
nce_bias = tf.Variable(tf.zeros([VOCAB_SIZE]))
loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weight,
                                     biases=nce_bias,
                                     labels=target_words,
                                     inputs=embed,
                                     num_sampled=NUM_SAMPLED,
                                     num_classes=VOCAB_SIZE))

5、定义优化器
我们使用梯度下降法。

1
optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE).minimize(loss)

第二步，执行 计算

1
2
3
4
5
6
7
8
9
10
11
with tf.Session() as sess:
    sess.run(tf.global_variable_initializer())
    average_loss = 0.0
    for index in range(NUM_TRAIN_STEPS):
        batch = batch_gen.next()
        loss_batch, _=sess.run([loss, optimizer],
                                feed_dict={center_words: batch[0], target_words: batch[1]})
        average_loss +=loss_batch
        if (index + 1) % 200 == 0:
            print('Average loss at step {}: {:5.1f}'.format(index+1,
                                                    average_loss/(index+1)))

Name Scope

给出张量的名称，在Tensorboard中查看

这看起来可读性并不强，节点到处都是。Tensorboard并不知道哪些节点之间关联性比较强并将它们组合在一起。当构建更为复杂的模型时，这看起来会更混乱。实际上我们可以同过name scope的方法指定节点之间的关联关系，这样有着相同name scope的节点会被放置在一起。

1
2
3
with tf.name_scope(name_of_that_scope):
    # declare op_1
    # declare op_2

这样我们就可以将之前的代码再规范一下：

1
2
3
4
5
6
7
8
9
10
11
with tf.name_scope('data'):
    center_words = tf.placeholder(tf.int32, shape=[BATCH_SIZE], name='center_words')
    target_words = tf.placeholder(tf.in32, shape=[BATCH_SIZE, 1], name='target_words')
with tf.name_scope(embed):
    embed_matrix = tf.Variable(tf.random_uniform([VOCAB_SIZE, EMBED_SIZE], -1.0, 1.0), name='embed_matrx')
with tf.name_scope('loss'):
    embed = tf.nn.embedding_lookup(embed_matrix, center_words, name='embed')
    nce_weights = tf.Variable(tf.truncated_normal([VOCAB_SIZE, EMBED_SIZE],
            stddev=1.0 / math.sqrt(EMBED_SIZE)), name='nce_weights')
    nce_bias = tf.Variable(tf.zeros([VOCAB_SIZE]), name='nce_bias')
    loss = tf.reduce_mean(tf.nn.nce_loss(weights=nce_weights, biases=nce_bias, labels=target_words, inputs=embbed, num_sampled=NUM_SAMPLED, num_classes=VOCAB_SIZE), name='loss')

这样Tensorboard中的图看起来更加直观了，鼠标点击相应的块会出现该块的具体内容。

Tensorboard中有两种类型的边界，一种是实线一种是虚线，实线代表data flow边，而虚线代表控制依赖的边。
此外，为了让代码的复用性更强，我们可以将模型写成一个类，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class  SkipGramModel:
    def __init__(self, params):
        pass
    def _create_placeholder(self)
        pass
    def _create_embedding(self)
        pass
    def _create_loss(self)
        pass
    def _create_optimizer(self)
        pass

为什么要学习梯度？

从以上例子可以看出 ，我们在构建模型的时候并没有计算梯度，而是Tensorflow自动帮我们求解的，那么我们为什么还要学习梯度呢？因为Tensorflow虽然帮我们计算了梯度，但是它并没有告诉我们函数是否会受到梯度爆炸或者消失的影响，所以我们仍然需要了解梯度下降的工作原理。

参考

notes_04
slides_04
Visualizing MNIST

展开全文 >>

Linear and Logistic Regression in Tensorflow Notes

线性回归和逻辑回归

之前已经在cs231n的笔记中介绍过基本的线性回归和逻辑回归模型，现在需要用tensorflow实现。

线性回归

代码

notes_03

如何判断一个模型是正确的？

使用相关系数R的平方

R-squared

在测试集上运行

用虚拟数据测试模型

部分代码分析

1
2
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)
sess.run(optimizer, feed_dict={X: x, Y: y})

有两个疑问？
1、为什么train_op在tf.Session.run()的提取列表中？
2、Tensorflow怎么知道要更新哪些变量？
实际上，我们可以将任何Tensorflow的操作作为tf.Session.run()的提取变量。Tensorflow会执行计算图中这些操作所依赖的部分。在以上例子中，train_op的目的是使loss最小，而loss依赖于w和b的值。

从图中可以看出，节点GrandientDescentOptimizer依赖于节点weights，bias和gradients。

优化

GradientDescentOptimizer意味着我们的更新策略是梯度下降。Tensorflow已经为我们做了自动微分，然后更新w和b的值使得loss最小。默认情况下，optimizer训练目标函数所依赖的变量中的所有可训练变量，如果这里面有一些你不想训练的变量，可以将在定义参数时其参数trainable设置为False。一个具体的例子是变量global_step，这个变量是用来记录你运行模型多少次数的变量，其不应该为可训练的。

1
2
3
4
global_step = tf.Variable(0,trainable=False, dtype=tf.int32)
learning_rate = 0.01 * 0.99 ** tf.cast(global_step, tf.float32)
increment_step = global_step.assign_add(1)
optimizer = tf.GradientDescentOptimizer(learning_rate) # learning rate 可以是一个tensor

tf.Variable的完整定义是：

1
2
3
tf.Variable(initial_value=None, trainable=True, collections=None,
    validate_shape=True, caching_device=None, name=None, variable_def=None,
    dtype=None, expected_shape=None, import_scope=None)

我们甚至可以让optimizer计算特定变量的梯度，也可以修改由optimizer计算出的梯度。
如下所示是一些例子：

1
2
3
4
5
6
7
8
optimizer = GradientDescentOptimizer(learning_rate=0.1)
# 计算一系列变量的梯度
grads_and_vars = opt.compute_gradients(loss, <list of variables>)
# grads_and_vars 是由元组(gradient, valriable)
#组成的列表。可以对其中的gradient项做一些操作。
substracted_grads_and_vars = [(gv[0] - 1.0, gv[1]) for gv in grads_and_vars]
# 让optimizer应用减过1的梯度。
optimizer.apply_gradients(subtracted_grads_and_vars)

更多关于梯度计算

优化器类会自动计算graph的梯度，但创建新的优化器或专家用户可以调用下面的低级函数。

1
tf.gradients(ys, xs, grad_ys=None, name='gradients', colocate_gradients_with_ops=False, gate_gradients=False, aggregation_method=None)

当只训练一个模型的一个部分时，这种方法很有用。例如我们可以使用tf.gradient()计算中间层loss的梯度G，然后我们使用优化器来最小化中间层输出M和M + G之间的差异，
只更新网络的下半部分。

优化器种类

各种优化器的比较

cs231n的笔记中有介绍。也可参考：
Optimizing Gradient Descent

逻辑回归

用逻辑回归解决MNIST字符识别的一个例子

理解one-hot encodiing

参考

slides_03
notes_03
cs20si: tensorflow for research 学习笔记3

展开全文 >>

Tensorflow Programming--Basic

Tensorflow基本操作

1
2
3
4
5
import tensorflow as tf
a = tf.add(3,5)
sess = tf.Session()
print(sess.run(a))
sess.close()

或者这样写更好：

1
2
3
4
import tensorflow as tf
a = tf.add(3,5)
with tf.Session() as sess:
    print(sess.run(a))

Session对象封装了Operation对象的执行环境和Tensor对象的验证。

更复杂的图的例子

1
2
3
4
5
6
7
8
x = 2
y = 3
add_op = tf.add(x,y)
mul_op = tf.mul(x,y)
useless = tf.mul(x,add_op)
pow_op = tf.pow(add_op,mul_op)
with tf.Session() as sess:
    z, not_useless = sess.run([op3,useless])

API: tf.Session.run(fetches, feed_dict=None,options=None,rum_metadata=None)
将所有你想要的值的变量传递给一个列表。
Tensorflow支持多GPU计算，可以将构建的图分成几个大块并在多个GPU或者CPU或者其他设备上进行并行计算。

指定特定GPU的方法：

1
2
3
4
5
6
with tf.device('/gpu:2'):
    a = tf.constant([1.0,2.0,3.0,4.0,5.0,6.0],name='a')
    b = tf.constant([1.0,2.0,3.0,4.0,5.0,6.0],name='b')
    c = tf.matmul(a,b)
    with tf.Session(config=tf.ConfigProto(log_device_placement=True)) as sess:
        print(sess.run())

tf.Graph()

向一个图中添加操作，并将图设置为默认：

1
2
3
4
5
6
7
g = tf.Graph()
with g.as_default():
    x = tf.add(3,5)
sess = tf.Session(graph=g)
with tf.Session() as sess:
    sess.run(x)

使用一下语句得到默认的图：

1
g = tf.get_default_graph()

注意不要将默认图和用户自定义的图混合。

使用图的优点

1、节约计算资源，每次运算仅仅只需运行与结果有关的子图
2、可以将图分成小块进行自动微分
3、方便部署在多个设备上
4、很多机器学习算法都能够被可视化为图的结构

Tensorboard简单使用

Tensorboard用于可视化训练过程中的一些数据

1
2
3
4
5
6
7
8
9
import tensorflow as tf
a = tf.constant(2)
b = tf.constant(3)
x = tf.add(a,b)
with tf.Session() as sess:
    # 利用tensorboard记录
    writer = tf.summary.FileWriter('./graphs',sess.graph)
    print(sess.run(x))
writer.close()

注意是在建立图之后，运行Session之前进行summary操作。
采用以下命令查看Tensorboard可视化结果：

$ python [yourprogram].py
$ tensorboard —logdir=’./graph’ —port 6006
然后在相应浏览器地址打开即可看到可视化结果。

为了让可视化结果更清晰，可给操作和节点命名。
如下所示

1
2
3
4
5
6
7
import tensorflow as tf
a = tf.constant(2, name='a')
b = tf.constant(3, name='b')
x = tf.add(a, b, name='add')
writer = tf.summary.FileWriter('./graphs',sess.graph)
with tf.Session() as sess:
    print(sess.run(x))

总之，Tensorboard是一个十分强大的工具，特别是对于分析复杂的网络结构以及观察网络训练过程特别有用。

常用API

1、tf.constant(value, dtype=None, shape=None, name=’Const’,verify_shape=False)
2、tf.zeros(shape, dtype=tf.float32, name=None)
3、tf.zeros_like(input_tensor, dtype=None, name=None, optimize=True)
4、tf.ones(shape, dtype=tf.float32, name=None)
5、tf.ones_like(input_tensor, dtype=None, name=None, optimize=True)
6、tf.fill(dims, value, name=None)
7、tf.linspace(start, stop, num, name=None)
8、tf.range(start, limit=None, delta=1, dtype=None, name=’range’)
9、tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)
10、tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None,name=None)
10、tf.random_uniform(shape, minval=0, maxval=None, dtype=tf.float32, seed=None,name=None)
11、tf.random_shuffle(value, seed=None, name=None)
12、tf.random_crop(value, size, seed=None, name=None)
13、tf.multinomial(logits, num_samples, seed=None, name=None)
14、tf.random_gamma(shape, alpha, beta=None, dtype=tf.float32, seed=None, name=None)
15、tf.set_random_seed(seed)

运算操作

Tensorflow数据类型

Tensorflow需要python的原生数据类型，如int，float， string等。

Tensorflow和Numpy中的数据类型比较

1、tf.int3 == np.int32 #true
2、可将numpy数据类型传递给Tensorflow的操作

1
tf.ones([2,2],np.float32) # =>[[1.0,1.0],[1.0,1.0]]

3、对于语句 tf.Session.run(fetches), 如果 fetch是一个Tensor数据，那么输出将会是一个numpy数组。

使用原则

1、不要使用Python原生类型作为张量，因为TensorFlow必须推断Python
类型。
2、使用numpy类型时需要小心，以后numpy和tensorflow可能不兼容。

constants的弊端

Constants是存储在图的定义中的。当constants比较大时，加载图会很耗费资源。
为了解决这个问题, 一个使用原则是：只对原始类型使用constants，其他需要更多内存的数据可以使用variables或者readers表示。

variables

一些例子

1
2
3
4
a = tf.Variable(2, name='scalar')
b = tf.Variable([2,3], name='vector')
c = tf.Variable([[0,1],[2,3]], name='matrix')
W = tf.Variable(tf.zeros([784,10]))

一个简单的问题：为什么tf.constant中constant是小写，而tf.Variable中Variable是大写？因为tf.Variable是一个类，tf.constant是一个操作符。遵循python的命名习惯。

如果tf.Variable有一些运算符：

1
2
3
4
5
x = tf.Variable(...)
x.initializer #init op 
x.value() # read op
x.assign(...) # write op
x.assign_add(...) # and more

variables初始化

最简单的方法是一次初始化所有变量

1
2
3
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

初始化部分变量

1
2
3
init_ab = tf.variables_initializer([a,b], name='init_ab')
with tf.Session() as sess:
    sess.run(init_ab)

初始化单个变量

1
2
3
W = tf.Variable(tf.zeros([784,10]))
with tf.Session() as sess:
    sess.run(W.initializer)

tf.Variable.assign()

1
2
3
4
5
W = tf.Variable(10)
W.assign(100)
with tf.Session() as sess:
    sess.run(W.initializer)
    print(W.eval()) # >>10

因为 W.assign(100) 只是创建了一个赋值操作，这个操作要被运行才能起作用，如下所示。并且我们并不需要初始化变量，因为assign_op已经为我们做了这个操作。实际上，初始化操作是赋值操作将变量的初始值赋给变量本身。

1
2
3
4
5
6
W = tf.Variable(10)
assign_op = W.assign(100)
with tf.Session() as sess:
    sess.run(W.initializer)
    sess.run(assign_op)
print(W.eval())  # >>100

1
2
3
4
5
6
7
my_var = tf.Variable(2, name='my_var')
my_var_times_two = my_var.assign(2 * my_var)
with tf.Session() as sess:
    sess.run(my_var.initializer)
    sess.run(my_var_times_two) # >>4
    sess.run(my_var_times_two) # >>8
    sess.run(my_var_times_two) # >>16

以上例子中，每运行一次，my_var都执行乘2操作。

assign_add() 和 assign_sub()

1
2
3
4
5
my_var = tf.Variable(10)
with tf.Session() as sess:
    sess.run(my_var.initializer)
    sess.run(my_var.assign_add(10)) # >>20
    sess.run(my_var.assign_sub(2)) # >>18

assign_add()和assign_sub()操作都不能帮我们初始化变量，因为这两个操作都需要参数的初始值。

每个session都拥有它自己的变量的拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
W = tf.Variable(10)
sess1 = tf.Session()
sess2 = tf.Session()
sess1.run(W.initializer)
sess2.run(W.initializer)
print(sess1.run(W.assign_add(10))) # >>20
print(sess2.run(W.assign_sub(2))) # >>8
print(sess1.run(W.assign_add(100))) # >>120
print(sess2.run(W.assign_sub(50))) # >>-42
sess1.close()
sess2.close()

用一个变量初始化另一个变量

下面这种方法比较常见，但是不够安全。

1
2
W = tf.Variable(tf.truncated_normal([700,10]))
U = tf.Variable(2 * W)

下面这种方法保证了保证了在用W初始化U之前，W的值已经被初始化,所以更加安全。

1
2
W = tf.Variable(tf.truncated_normal([700,10]))
U = tf.Variable(2 * W.initialized_value())

Session 和 InteractiveSesssion

InteractiveSession 和 Session的唯一区别就是InteractiveSession使其成为默认设置。

1
2
3
4
5
6
7
sess = tf.InteractiveSession()
a = tf.constant(5.0)
b = tf.constant(6.0)
c = a * b
# 我们可以只使用'c.eval（）'而不指定上下文'sess'
print(c.eval())
sess.close()

Control Dependencies

API: tf.Graph.control_dependencies(control_inputs)
用来定义哪个操作先被执行。

1
2
3
4
5
# graph g 有 5个操作：a, b ,c ,d ,e
with g.control_dependencies([a,b,c]):
    # 操作d 和 操作e 只在 a,b,c都执行过了之后再执行。
    d = ...
    e = ...

Placeholder

一个tensorflow写的程序通常有两个部分：
1、构建图 2、使用会话执行图中的操作
也就是说我们可以在不知道需要的计算参数的具体数值的前提下构建图。
我们可以在不知道x和y的具体数值的前提下定义函数 f(x,y) = x*2 +y，x和y只是具体数值的占位符。我们可以构建好计算图之后再对变量赋值进行计算。
API: tf.placeholder(dtype, shape=None, name=None)

1
2
3
4
5
a = tf.placeholder(tf.float32, shape=[3])
b = tf.constant([5,5,5],tf.float32)
c = a + b
with tf.Session() as sess:
    print(sess.run(c)) # 因为a并没有任何具体数值，所以会出错。

我们需要使用dictionary将值提供给占位符。
如下所示：

1
2
3
with tf.Session() as sess:
    print(sess.run(c,{a: [1,2,3]}))
# >> [6,7,8]

也可以给占位符多次赋值，如下所示：

1
2
3
with tf.Session() as sess:
    for a_value in list_of_values_for_a:
        print(sess.run(c, {a: a_value}))

其实我们可以通过feed_dict给任何feedable的张量，占位符只是一些必须被feed的量的一种表示。
可以通过 tf.Graph.is_feedable(tensor)判断张量能否被feed。

Feeding values to TF ops

1
2
3
4
5
a = tf.add(2, 5)
b = tf.mul(a, 3)
with tf.Session() as sess:
    replace_dict={a: 15}
    sess.run(b,feed_dict= replace_dict) # returns 45

Lazy Loading

lazy loading的意思是尽量推迟创建或者初始化对象的时间，直到其需要的时候再创建或者初始化。

非lazy loading

1
2
3
4
5
6
7
8
9
x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')
z = tf.add(x, y)
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./my_graph',sess.graph)
    for _ in range(10):
        sess.run(z)
    writer.close()

lazy loading

1
2
3
4
5
6
7
8
x = tf.Variable(10, name='x')
y = tf.Variable(20, name='y')
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    writer = tf.summary.FileWriter('./my_graph',sess.graph)
    for _ in range(10):
        sess.run(tf.add(x,y))
    writer.close()

lazy loading和非lazy loading得到的结果是一样的。但是它们的区别在哪儿呢？
以上例子中普通的加载方法 add操作只执行一次，而lazy loading的方法add操作要执行10次，当操作更复杂时，lazy loading的弊端就显现出来了。这是tensorflow最常见的一个non-bug bugs。
解决方法：
1、从计算/运行操作单独定义操作
2、使用Python属性来确保函数在第一次被调用时也被加载。？？具体怎么实现
Structuring Your Tensorflow Models

参考

Tensorflow Ops Slides
Tensorflow Ops Notes

展开全文 >>

一些讲解设计模式的链接

一些讲解设计模式的链接

设计模式

1、单例模式

主要关注点

1、懒汉模式与饿汉模式的区别
2、如何保证线程安全

Java设计模式(一)——单例模式
Java Singleton Pattern

2、建造者模式

应用场合

1、构造器有多个参数时可以考虑使用Builder模式。
2、当创建复杂对象的算法应该独立于该对象的组成部分及他们的装配方式时。
3、创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。

Java设计模式（二）——建造者模式
Builder Pattern in Java
effective java creating and destroying objects

3、工厂模式

主要关注点

1、工厂方法模式相比简单工厂模式的优势
2、工厂方法模式的组成结构包括：抽象工厂、具体工厂、抽象产品、具体产品。
3、工厂方法模式和抽象工厂模式的区别

Java 设计模式——工厂模式
Factory Design Pattern in Java
Abstract Factory Design Pattern in Java

4、原型模式

关注点

1、原型模式组成部分：原型、原型注册表、客户。
2、浅度复制和深度复制的区别

Java设计模式（五）——原型模式
Prototype Design Pattern in Java

5、适配器模式

关注点

1、类适配器和对象适配器的区别：建议尽量使用对象适配器的实现方式，多用合成/聚合、少用继承。
2、适配器模式的优缺点
3、缺省适配模式

Java设计模式（六）——适配器模式
Adapter Design Pattern in Java

展开全文 >>

Effective Java-- Creating and Destroying Objects

Effective Java Items about Creating and Destroying Objects

Effective Java 书籍的这一章节主要讲了一些关于何时及如何创建对象，何时及如何避免创建对象，如何确保对象能够适时地被销毁及如何管理对象销毁之前必须进行的各种清理动作的建议。

Item1: Consider static factory methods instead of constructors

静态工厂方法相比构造器方法的几大优势如下：
1、静态工厂方法有名称，使得产生的客户端代码更容易阅读。
2、使用工厂方法不必在每次调用它们的时候都创建一个新对象。
3、静态工厂方法可以返回原返回类型的任何子类型的对象。这使得在选择返回的对象的类时有了更大的灵活性。
4、创建参数化类型实例的时候，静态工厂方法使得代码更加简洁。
然而静态工厂方法也有以下缺点需要注意：
1、类如果不含有public或者protected的构造器，其就不能被子类化。
2、静态工厂方法相对其他的静态方法实际上并没有任何区别。这使得对于提供了静态工厂方法而不是构造器的类来说，要想查明如何实例化一个类比较困难。
关于静态工厂方法可参考：
Java 设计模式——工厂模式

Item2: Consider a builder when faced with many constructor parameters

如果类的构造器或者静态工厂中具有多个参数，设计这种类时，Builder模式就是种不错的选择，特别是当大多数参数都是可以选择的时候。与使用传统的重叠构造器模式相比，使用Builder模式的客户端代码将更易于阅读和编写，构建器也更加安全。
关于Builder模式可参考：
Java设计模式（二）——建造者模式
Builder Pattern in Java
effective java creating and destroying objects

Item3: Enforce the singleton property with a private constructor or an enum

可以利用私有属性或者枚举类型来强化单例属性。其中单元素的枚举类型已经成为实现单例模式的最佳方法，需要注意的是，当单例类必须继承自一个非枚举类型时，不能使用这种方法。
有关单例模式可参考：
Java设计模式(一)——单例模式
Java Singleton Pattern

Item4: Enforce noninstantiability with a private constructor

对于一些只包含静态方法和静态域的类，我们不希望其被实例化，可以通过私有构造方法使得其不能被实例化。当然这种方法也有一定副作用，其使得一个类不能被子类化。因为子类需要调用超类的构造函数，而超类的构造函数却是私有的，并不能被子类调用。

Item5: Prefer dependency injection to hardwiring resources

不要使用单例或静态的实用类来实现一个类，该类依赖于一个或多个底层资源，这些资源的行为会影响类的行为，并且不让类直接创建这些资源。相反，将资源或工厂传递给构造方法(或静态工厂或builder模式)。这种称为依赖注入的实践将极大地增强类的灵活性、可重用性和可测试性。

Item6: Avoid creating unnecessary objects

可以通过以下一些方法来避免创建不必要的对象：
1、重用不可变对象而不是每次需要的时候创建一个相同功能的新对象。
2、对于同时提供了静态工厂方法和构造器的不可变类，通常可以使用静态工厂方法而不是构造器并以此来避免创建不必要的对象。
3、也可以重用那些已知不会被修改的可变对象。
4、优先使用基本类型而不是装箱基本类型，要当心无意识的自动装箱。
5、避免创建不必要的对象并不是意味着“创建对象的代价很昂贵，而我们要尽可能避免创建对象”。事实上，针对小对象的创建和回收是非常廉价的。有时候，可以通过创建附加的对象从而使得程序更清晰简洁。

Item7: Eliminate obsolete object references

过期引用指的是永远也不会再被解除的引用。在Java这类支持垃圾回收的语言中，如果一个对象引用被无意识地保留起来了，那么垃圾回收机制不仅不会处理这个对象，而且连被这个对象所引用的其它对象也不会被处理。这样即便只有少量的几个对象引用被无意识保留下来，也会有许多对象被排除在垃圾回收机制之外，对性能造成潜在的重大影响。那如何解决这类问题？只需要在知道对象引用过期时，及时清空引用。只要是自己管理内存，就应该时时警惕内存泄漏问题。
内存泄漏的常见来源有：无意识的对象保持；缓存；监听器和其他回调。

Item8: Avoid finalizers and cleaners

终结方法是不可预测的，常常是危险而且不必要的。Java9已经弃用了终结方法，但是许多Java库中还用着这种方法。Java9中用Cleaners代替了终结方法。Cleaners比终结方法稍安全，但是仍然不可预测，慢和不必要。
Finalizers和cleaners的缺点之一是它们不能保证被及时执行。注重时间的任务不应该由终结方法和清理方法来完成。不但不能保证终结方法和清理方法能够及时执行，甚至其能不能执行也不会有保证。所以，永远不能依赖终结方法和清理方法来更新持久状态。
使用终结方法和清理方法会有严重的性能损失。显式的终结方法通常与try-finally 结构结合起来使用，以确保及时终止。重要的准则是：除非是作为安全网，或者是为了终止非关键的本地资源，否则请不要使用终结方法和清理方法。

Item9: Prefer try-with-resources to try-finally

操作一些必须被关闭的资源时，最好使用try-with-resources块而不是try-finally代码块，这样代码更短更清晰，而且生成的异常更有用。try-with-resources块使得正确编写操作必须关闭的资源的代码更加容易。

参考

Effective Java, Third Edition -Bloch-2017
林本托的博客

展开全文 >>

Useful Links

综合

Stackoverflow
VirtualBox安装增强功能包实现资源共享
清华大学开源软件镜像站

Linux

wsl-tutorial
ssh into wsl
ss科学上网

Programming Language

C++

cppreference
google cpp guide

python

Python Extension Packages for Windows

Java

JavaSE API

SQL

windows安装mysql-5.7压缩版详细教程

Machine Learning

Deep Learning

cs231n spring2017
tensorflow
pytorch
Awesome Deep Vision
tensorflow model

Computer Vision

Object Detection

Handong1587 Object Detection
Awesome Object Detection

OpenCV

Ubuntu 14.04 安装 OpenCV-3.2.0
Photoshop图像处理算法

Courses

CS131 Computer Vision: Foundations and Applications
CS 20: Tensorflow for Deep Learning Research
CS179 GPU Programming

Github Repo

ssds.pytorch
浙江大学课程攻略共享计划

展开全文 >>

Effective Java-- Lambdas and Streams

Lambdas in Java

Introduce

Lambada Expressions

lambda表达式的固定格式如下： parameter -> expression body
一个lambda表达式有如下特点：可不声明参数类型，编译器会自动推导；单个参数无需加括号，多个参数必须加括号；单条语句无需加花括号；return关键词可省略。
参考：
Lambda Expressions

Method References

方法引用有助于按照名称指向方法。其使用“::”符号描述方法引用。方法引用可以用来指出以下类型的方法：静态方法;实例方法；使用new运算符的构造器方法。
大多数引用的是静态方法，但是也有一些其它情况，主要有以下几种类型的方法引用：

参考：
Method References

Functional Interfaces

functional interfaces有着一个特定的功能展示的作用。例如：使用单个方法 compareTo 的 Comparable接口来用于比较。
参考：
Function Interfaces

Effective Java Items about Lambdas

Item42: Prefer lambdas to anonymous classes

在支持lambda之前，Java中一般用匿名函数来实现函数对象这样的功能。比如：

1
2
3
4
5
6
7
8
9
10
11
12
// Anonymous class instance as a function object
//List<String> words=new ArrayList<>();
//words.add("JDIFA");
//words.add("fjiafja8fjiasfjias");
//words.add("jiaffjiafjiasf");
//words.add("jifaif3");
words.sort(new Comparator<String>() {
    @Override
    public int compare(String s1,String s2) {
        return Integer.compare(s1.length(),s2.length());
    }
});
而用lambda表达式可以这样写比较简洁：

1
words.sort((s1,s2)->Integer.compare(s1.length(),s2.length()));

使用lambda表达式时，一般会省略参数的类型，因为编译器会进行自动推导类型。当编译器不能推导出类型时，需要我们显式指定。一个重要的原则就是：为了让lambda表达式更简洁，尽量省略参数类型。有时需要对返回值进行类型转换或者对整个lambda表达式进行类型转换，但是这比较少见。
和方法及类不同，lambda缺少名称和文档，如果一个运算不是很容易理解或者行数太多，那么就不要使用lambda表达式。
总而言之，目前而言，lambda表达式是表示小型函数对象的最佳方法。除非必须要创建非函数接口的类型实例，否则不要使用匿名类。

Item43: Prefer method references to lambdas

lambda表达式相较于匿名类的主要优势就是其更简洁。然而Java提供了一种比lambda表达式更为简洁的生成函数对象的方法：方法引用(method references)。使用方法引用通常会生成更短更清晰的代码。但是也有例外的情况，使用的时候可以根据具体情况选择使用lambda还是方法引用。
一般而言，方法引用提供了一种比lambda表达式更为简洁的方法。总的使用原则就是：方法引用更为简洁时就使用它，否则使用lambda。

Item44: Favor the use of standard functional interfaces

Java有了lambda之后，我们在设计API的时候就有必要随时考虑lambda。既能接受functional interface类型作为输入也要能将其作为输出。通常情况下，最好使用java.util.function.Function中的标准接口，但是极少数情况下可能还是需要我们自己设计functional interfaces。
主要有如下一些使用原则：
1、优先使用标准functional interface
2、java.util.function中有43种接口类型，比较常用的有以下6种：

3、多数标准functional interfaces只提供了对于基本类型的支持。不要试图用包装的基本类型来替代基本类型的functional interfaces。
4、使用 @FunctionalInterface注解来定义函数接口。

Streams in Java

Introduce

Streams

streams表示来自源的一系列对象，其支持聚合操作，有以下特征：
1、元素序列：stream以顺序的方式提供一组特定类型的元素。其按需获取或者计算元素。其从不存储元素。
2、源：其将Collection, Array或者IO资源作为输入。
3、聚合操作：其支持聚合操作，如filter, map, limit, reduce, find, match等。
4、流水线：大多数stream操作本身返回stream，以使得其操作可以流水线话。collect()方法是在流水线操作结束时通常存在的终端操作，用于标记流的结束。
5、自动迭代：stream通过所提供的源元素在内部执行迭代，与需要显式迭代的集合相反。

示例

可以用stream()或者parallelStream()方法生成Stream。

1
2
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd","", "jkl");
List<String> filtered = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.toList());

更多示例可参考：
Streams

Effective Java Items about Streams

Item45: Use streams judiciously

Stream API用起来非常流畅，其就是设计来将一连串的方法调用连成一个管道作为一条语句。使用得当的话，streams能将程序变得更短更清晰，而使用不当会导致程序 很难阅读和理解。
总的来说，有些任务用stream的方法完成较好，有些任务用iteration的方式完成较好。许多任务可以用两种方式的组合来更好地完成。对于两种方式之间的选择，并没有特定的方法，还是需要根据实际情况决定。如果不能确定用哪种方式更好，索性两种方式都试一下并比较再做决定。
更多具体例子可参考书籍 Effective Java 3rd edition

Item46: Prefer side-effect-free functions in streams

stream的本质是无副作用的函数对象，这适用于传递给stream的所有许多函数对象和相关的对象。每个终端操作只能用于报告由stream执行的计算的结果，而不执行计算。为了正确使用stream，我们必须熟悉collectors。最重要的收集器工厂是toList, toSet, toMap, groupingBy和joining。
一些使用原则：
1、forEach操作应该被用于报告stream的计算结果而不是执行计算。
2、为了使得使用stream的代码更具可读性，比较明智的做法是静态导入Collectors。

1
import static java.util.stream.Collectors.*;

Item47: Prefer Collections to Streams as a return type

Item48: Use caution when making streams parallel

参考

Stream详解

展开全文 >>

一些Java编码规范条款

记录一些Java编码条款，方便查看

Effective Java（3rd Edition）中的编码条款

Create and Destroying Objects

Item1: Consider static factory methods instead of constructors
Item2: Consider a builder when faced with many constructors
Item3: Enforce the singleton property with a private constructor or an enum type
Item4: Enforce noninstantiability with a private constructor
Item5: Prefer dependency injection to hardwiring resources
Item6: Avoid creating unnecessary objects
Item7: Eliminate absolete object references
Item8: Avoid finalizers and cleaners
Item9: Prefer try-with-resources to try-finally

Mothods Common to All Objects

Item10: Obey the general construct when overriding equals
Item11: Always override hashCode when you override equals
Item12: Always override toString
Item13: Override clone judiciously
Item14: Consider implementing Comparable

Classes and Interfaces

Item15: Minimize the accessibility of classes and members
Item16: In public classes, use accessor methods, not public fields
Item17: Minimize mutability
Item18: Favor composition over inheritance
Item19: Design and document for inheritance or else prohibit it
Item20: Prefer interfaces to abstract classes
Item21: Design interfaces for posterity
Item22: Use interfaces only to define types
Item23: Prefer class hierarchies to tagged classes
Item24: Favor static member classes over nonstatic
Item25: Limit source fields to a single top-level class

Generics

Item26: Don’t use raw types
Item27: Eliminate unchecked warnings
Item28: Prefer lists to arrays
Item29: Favor generic types
Item30: Favor generic methods
Item31: Use bounded wildcards to increase API flexibility
Item32: Combine generics and varargs judiciously
Item33: Consider typesafe heterogeneous containers

Enums and Annotations

Item34: Use enums instead of int constants
Item35: Use instance fields instead of ordinals
Item36: Use EnumSet instead of bit fields
Item37: Use EnumMap instead of ordinal indexing
Item38: Emulate extensible enums with interfaces
Item39: Prefer annotations to naming patterns
Item40: Consistently use the Override annotation
Item41: Use marker interfaces to define types

Lambdas and Streams

Item42: Prefer lambdas to anonymous classes
Item43: Prefer method reference to lambdas
Item44: Favor the use of standard functional interfaces
Item45: Use streams judiciously
Item46: Prefer side-effect-free functions in streams
Item47: Prefer Collections to Stream as a return type
Item48: Use caution when making streams parallel

Methods

Item49: Check parameters for validity
Item50: Make defensive copies when needed
Item51: Design method signatures carefully
Item52: Use overloading judiciously
Item53: Use varargs
Item54: Return empty collections or arrays, not nulls
Item55: Return optionals judiciously
Item56: Write doc comments for all exposed API elements

General Programming

Item57: Minimize the scope of local variables
Item58: Prefer for-each loops to traditional for loops
Item59: Know and use the libraries
Item60: Avoid float and double if exact answers are required
Item61: Prefer primitive types to boxed primitives
Item62: Avoid strings where other types are more appropriate
Item63: Beware the performance of string concatenation
Item64: Refer to objects by their interfaces
Item65: Prefer interfaces to reflection
Item66: Use native methods judiciously
Item67: Optimize judiciously
Item68: Adhere to generally accepted naming conventions

Exceptions

Item69: Use exceptions only for exceptional conditions
Item70: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors
Item71: Avoid unnecessary use of checked exceptions
Item72: Favor the use of standard exceptions
Item73: Throw exceptions appropriate to the abstraction
Item74: Document all exceptions thrown by each method
Item75: Include failure-capture information in detail messages
Item76: Strive for failure atomicity
Item77: Don’t ignore exceptions

Concurrency

Item78: Synchronize access to shared mutable data
Item79: Avoid excessive synchronization
Item80: Prefer executors, tasks, and streams to threads
Item81: Prefer concurrency utilities to wait and notify
Item82: Document thread safety
Item83: Use lazy initialization judiciously
Item84: Don’t depend on the thread scheduler

Serialization

Item85: Prefer alternatives to Java serialization
Item86: Implement Serializable with great caution
Item87: Consider using a custom serialized form
Item88: Write readObject methods defensively
Item89: For instance control, prefer enum types to readResolve
Item90: Consider serialization proxies instead of serialized instances

参考

Effective Java, Third Edition

展开全文 >>

Java语言程序设计-第10版notes

Java语言程序设计第10版notes

第1章 计算机、程序和Java概述

部分章节小结

1、编程错误可以分为三类：语法错误、运行时错误和逻辑错误。编译器报告的错误称为语法错误或者编译错误；运行时错误指引起程序非正常结束的错误；而当一个程序没有按照预期的方式执行时，产生逻辑错误 。

第2章 基本程序设计

部分章节小结

1、拓宽类型不需要显式转换，缩窄类型必须显式完成。

1
2
3
4
5
6
//拓宽类型转换
int i=9;
double d=i;
//缩窄类型转换
double d=9.0;
int i=(int)d;

2、计算机科学中，1970年1月1日午夜零点为UNIX时间戳。

第3章 选择

部分章节小结

1、除开赋值操作符的所有二元操作符都是左结合的，赋值操作符是右结合的。(此处的结合指的是结合律)

1
2
3
4
5
6
//以下两个表达等价
a-b+c-d
((a-b)+c)-d
//以下两个表达等价
a=b+=c=5
a=(b+=(c=5))

第4章 数学函数、字符和字符串

部分章节小结

1、字符 ‘ ‘ 、\t、 \f、 \r 和 \n 都称为空白字符。
2、字符可以基于它们的Unicode码使用关系操作符进行比较。

第6章 方法

部分章节小结

1、程序模块化和可重用性是软件工程的中心目标之一。
2、方法可以重载，这意味着两个方法可以拥有相同的方法名，只要它们的参数列表不同即可。
3、方法抽象是把方法的应用和实现分离，用户可以在不知道方法是如何实现的情况下使用方法。方法的实现细节封装在方法内，对调用该方法的用户隐藏。这称为信息隐藏或封装。
4、方法抽象将程序模块化为整齐、层次分明的形式。将程序写成简洁的方法构成的集合会比其他方式更容易编写、调试、维护和修改。这种编写风格也会提高方法的可重用性。
5、当实现一个大型程序时，可以使用自顶向下或者自底向上的编码方法。不要一次性编写完整个程序。这种方式似乎浪费了更多的编码时间(因为要反复编译和运行这个程序)，但实际上，它会节省时间并使得调试更为容易。

第7章 一维数组

部分章节小结

1、创建数组时推荐使用 elementType[] arrayRefVar风格
2、不同于基本数据类型变量的声明，声明数组变量并不会给数组分配任何空间。数组变量不是基本数据类型变量。数组变量包含的是对数组的引用。
3、将数组参数传递给方法时，实际上传递的是数组的引用；更准确地说，被调用的方法可以修改调用者的原始数组的元素。
4、数组初始化语法：
elementType[] arrayRefVar={value0,value1,…,valuek};

第9章 对象和类

部分章节小结

1、类是一种数据类型。可以用它声明对象引用变量。对象引用变量中似乎存放了一个对象，但是事实上，它包含的只是对该对象的引用。严格来说，对象引用变量和对象是不同的，但是大多数情况下，它们的区别是可以忽略的。
2、所有传递给方法的参数都是值传递的，对于基本类型的参数，传递的是实际值；而如果参数是引用数据类型，则传递的是对象的引用。

第10章 面向对象思考

部分章节小结

1、面向过程范式重在设计方法。面向对象范式将数据和方法耦合在对象中。使用面向对象范式的软件设计重在对象和对象的操作。面向对象方法结合了面向过程范式的功能以及将数据和操作集成在对象中的特点。
2、许多Java方法要求使用对象作为参数。Java提供了一个便捷的方法，将基本数据类型合并或包装到一个对象中。
3、Java可以根据上下文自动地将基本类型值转换到对应的包装对象，反之亦然。

第11章 继承和多态

部分章节小结

1、构造方法可以调用重载的构造方法或者它的父类的构造方法。这种调用必须是构造方法的第一条语句。如果没有显示地调用它们中的任何一个，编译器就会把super()作为构造方法的第一条语句，它调用的是父类的无参构造方法。
2、实例方法只有在可访问时才能重写。这样，私有方法是不能重写的，因为它是不能在类本身之外访问的。如果子类中定义的方法在父类中是私有的，那么这两个方法是完全没有关系的。
3、Java中的每个类都继承自java.lang.Object类。
4、如果一个方法的参数类型是父类,可以向该方法的参数传递任何子类的对象。这称为多态。
5、因为子类的实例总是它的父类的实例。所以，总是可以将一个子类的实例转化成一个父类的变量。当把父类实例转换成它的子类变量时，必须使用转换记号(子类名)进行显式转换，向编译器表明你的意图。
6、当从引用变量调用实例方法时，该变量的实际类型在运行时决定使用该方法的哪个实现。这称为动态绑定。

第12章 异常处理和文本IO

部分章节小结

1、Java异常是扩展自java.lang.Throwable的类的实例。Java本身提供大量预定义的异常类，当然也可以通过扩展Exception类来定义自己的异常类。
2、异常发生在一个方法的执行过程中。RuntimeException和Error都是免检异常，所有其他的异常都是必检的。
3、声明异常的关键字是throws,而抛出异常的关键字是throw。
4、如果调用声明了必检异常的方法，必须将该方法调用放在try语句中。在方法执行过程中出现异常时，catch块会捕获并处理异常。
5、如果一个异常没有被当前方法捕获，则该异常被传给调用者。这个过程不断重复直到异常被捕获或者传递给main方法。
6、在catch块中，异常的指定顺序是非常重要的。如果在指定一个类的异常对象之前，指定了这个异常类的父类的异常对象，就会导致一个编译错误。
7、当方法中发生异常时，如果异常没有被捕获，方法将会立刻退出。如果想在方法退出前执行一些任务，可以在方法中捕获这个异常，然后再重新抛给它的调用者。
8、任何情况下都会执行finally块中的代码，不管try块中是否出现了异常，或者出现后是否捕获了该异常。

第13章 抽象类和接口

部分章节小结

1、抽象类和常规类一样，都有数据和方法，但是不能用new操作符创建抽象类的实例。
2、非抽象类中不能包含抽象方法。如果抽象类的子类中没有实现所有被继承的父类抽象方法，就必须将该子类也定义为抽象类。
3、包含抽象方法的类必须是抽象类。但是抽象类可以不包含抽象的方法。
4、即使父类是具体的，子类也可以是抽象的。
5、接口是一种与类相似的结构，只包含常量和抽象方法。接口在许多方面与抽象类很相近，但抽象类除了包含常量和抽象方法外，还可以包含变量和具体方法。
6、在 Java 中，接口被认为是一种特殊的类。就像常规类一样，每个接口都被编译为独立的字节码文件。
7、接口java.lang.Comparable定义了compareTo方法。Java类库中的许多类都实现了 Comparable。
8、接口 java.lang.Cloneable 是一个标记接口。实现Cloneable接口的类的对象是可克隆的。
9、个类仅能继承一个父类，但一个类却可以实现一个或多个接口。
10、一个接口可以继承一个或多个接口。

第19章 泛型

部分章节小结

1、泛型具有参数化类型的能力。可以定义使用泛型类型的类或方法，编译器会用具体类型来替代泛型类型。
2、泛型的主要优势是能够在编译时而不是运行时检测错误。
3、泛型类或者方法允许指定这个类或者方法可以带有的对象类型。如果试图使用带有不兼容对象的类或者方法，编译器会检测出这个错误。
4、定义在类、接口或者静态方法中的泛型称为形式泛型类型，随后可以用一个实际具体类型来替换它。替换泛型类型的过程称为泛型实例化。
5、不使用类型参数的泛型类称为原始类型，例如ArrayList。使用原始类型是为了向后兼容Java较早的版本。
6、通配泛型类型有三种形式：?、? extends T 和 ? super T,这里的T代表一个泛型类型。第一种形式?称为非受限通配，它和 ? extends Object是一样的。第二种形式 ? extends T 称为受限通配，代表T 或者T的一个子类型。第三种类型 ? super T 称为下限通配，表示T或者T的一个父类型。
7、使用称为类型消除的方法来实现泛型。编译器使用泛型类型信息来编译代码，但是随后消除它。因此，泛型信息在运行时是不可用的。这个方法能够使泛型代码向后兼容使用原始类型的遗留代码。
8、不能使用泛型类型参数来创建实例。
9、不能使用泛型类型参数来创建数组。
10、不能再静态环境中使用类的泛型类型参数。
11、在异常类中不能使用泛型类型参数。

第30章 多线程和并行程序设计

部分章节小结

1、每个任务都是Runnable接口的实例。线程就是一个便于任务执行的对象。可以通过实现Runnable接口来定义任务类，通过使用Thread构造方法包住一个任务来创建线程。
2、一个线程对象被创建后，可以使用start()方法启动线程，可以使用sleep(long)方法将线程转入休眠状态，以便其它线程获得运行的机会。
3、线程对象从来不会直接调用run方法。到了执行某个线程的时候，Java虚拟机调用run方法。类必须覆盖run方法，告诉系统线程运行时将会做什么。
4、为了避免线程破坏共享资源，可以使用同步的方法或块。同步方法在执行前需要获得一个锁。当同步方法是实例方法时，锁是 在调用方法的对象上；当同步方法是静态(类)方法时，锁是在方法所在的类上。
5、在执行方法中某个代码块时，可以使用同步语句获得任何对象上的锁，而不仅是this对象上的锁。这个代码称为同步块。
6、可以使用显式锁和条件，以及对象的内置监视器来便于进程之间的通信。
7、Java集合框架提供的阻塞队列(ArrayBlockingQueue,LinkedBlockingQueue,PriorityBlockingQueue)自动地同步对队列的访问。
8、可以使用信号量来限制访问共享资源的并行任务数量。
9、如果两个或更多的线程获取多个对象上的锁时，每个线程都有一个对象上的锁并等待另一个对象上的锁，这时就有可能发生死锁现象。使用资源排序技术可以避免死锁。
10、JDK7的Fork/Join框架被设计用于开发并行程序。可以定义一个继承自RecursiveAction或者RecursiveTask的任务类，在ForkJoinPool中并行执行任务类，并在所有任务执行完后得到整体的解答。

第31章 网络

部分章节小结

1、Java支持流套接字和数据报套接字。流套接字用TCP(传输控制协议)来进行数据传输，而数据报套接字用UDP(用户数据报协议)。由于TCP协议检测丢失的传输并且重新提交它们，所以，传输是无损和可靠的。相反地，UDP不能保证传输是无损的。
2、要创建一个服务器，必须先使用语句new ServerSocket(port)获取一个服务器套接字。在创建服务器套接字后，可以启动服务器，使用服务器套接字上的accept()方法监听连接请求。客户端使用new Socket(serverName,port)来创建一个客户端套接字，用于向服务器发送连接请求。
3、当服务器与客户端的连接建立后，流套接字通信与输入输出流通信非常相似。可以通过套接字上的getInputStream() 方法获得一个输入流，通过getOutputStream()方法获得一个输出流。
4、一个服务器经常同时与多个客户端协同工作。通过为每个连接创建一个线程，可以利用线程同时处理服务器的多个客户端。

参考

Java语言程序设计（基础篇 原书第10版）
Java语言程序设计（进阶篇 原书第10版）

展开全文 >>

YOLO Object Detection

YOLO

论文链接

YOLO9000:Better, Faster, Stronger
Fast YOLO: A Fast You Only Look Once System for Real-time Embedded Object Detection in Video
You Only Look Once:Unified, Real-Time Object Detection
YOLOv3

分析

YOLO

YOLO论文解读

YOLO9000(YOLOv2)

YOLO9000论文解读

Better

传统YOLO缺陷

Significant number of localization errors compared to Fast-RCNN
Low recall compared to region proposal-based mothods

YOLOv2相对YOLO的改进

Batch Normalization

adding batch normalization on all of the convolutional layers in YOLO
2% improvement in mAP
then we can remove dropout without overfitting

High Resolution Classifier

increase of almost 4% mAP

Convolutional With Anchor Boxes

remove fully connected layers from YOLO and use anchor boxes to predict bounding boxes.
eliminate one pooling layer to make the output of the network’s convolutional layers higher resolution.
shrink the network to operate on 416x416 input images instead of 448x448。这样使得输出的feature map大小为13x13,代替原来的14x14使得中心只有一个。

和YOLO相比的性能

mAP: 69.5->69.2
recall: 81%->88%

Dimension Clusters

使用k-means自动挑选box的尺寸代替原来YOLO方案的手动挑选尺寸。

Direct Location Prediction

YOLO使用anchor boxes的过程中会遇到模型不稳定的问题。通过改变预测box位置的方法改进。
Using dimension clusters along with directly predicting the bounding box center location improves YOLO by almost 5% over the version with anchor boxes.

Fine-Grained Features

This gives a modest 1% performance increase.

Multi-Scale Training

由于模型只有卷积层和池化层，我们可以随意调整大小。 Every 10 batches our network randomly chooses new image dimensions。

Further Experiments

The path from YOLO to YOLOv2

Faster

Stronger

YOLOv3

展开全文 >>

cs179notes_1

useful links

cs179
cuda c programming guide

lecture1

CPU(Central Processing Unit)

传统上，应用程序使用CPU作为主服务器计算，它有如下特点：
•通用功能
•建立技术
•通常配备8个或更少的强大的核心
•对于并发进程是最佳的，但不是大规模的并行计算

GPU(Graphics Processing Unit)

为并行化问题设计的相对较新的技术。
•最初专为图形创建
•成为更有能力的一般计算

为什么要用GPU?(GPU的优势)

举例，对于两个数组相加的操作。在CPU上这样实现：

串行实现

1
2
3
4
5
float *C=malloc(N*sizeof(float));
for(int i=0;i<N;++i){
    C[i]=A[i]+B[i];
}
return C;

更好一点可以使用并行实现。

1
2
3
4
5
6
7
8
9
10
11
(allocate memory for C)
Create # of threads equal to number of cores on processor
(around 2, 4, perhaps 8)
(Indicate portions of A, B, C to each thread...)
...
In each thread,
For (i from beginning region of thread)
C[i] <- A[i] + B[i]
//lots of waiting involved for memory reads, writes, ...
Wait for threads to synchronize...
This is slightly faster – 2-8x (slightly more with other tricks)

但是这带来一些问题：能用多少个线程？如何扩展程序性能？实际上，在CPU上允许的最大线程数量比较少。

GPU与CPU在上下文切换上的差异

CPU与GPU架构的一个主要区别就是CPU与GPU映射寄存器的方式。CPU通过使用寄存器重命名和栈来执行多线程。为了运行一个新任务，CPU需要进行上下文切换，当前所有寄存器的状态保存到栈上，然后从栈中恢复当前需要执行的新线程上次的执行状态。而这些操作通常要花费上百个CPU时钟周期，所以如果在CPU中开启过多的线程，时间几乎都将花在上下文切换过程中寄存器内容的换进换出上。
然而，GPU却恰恰相反，GPU利用多线程隐藏了内存获取与指令执行带来的延迟，因此，在GPU上开启过少的线程反而会因为等待内存事务而使得GPU处于闲置状态。另外，GPU也不实用寄存器重命名的机制，而是致力于为每一个线程都分配真实的寄存器，因此，当需要上下文切换时，所需要的操作就是将指向当前寄存器组的选择器(或者指针)更新，以指向下一个执行的线程束的寄存器组，因此几乎就是零开销。

在GPU上可以这样实现

1
2
3
4
5
6
7
8
(allocate memory for A, B, C on GPU)
Create the “kernel” – each thread will perform one (or a few)
additions
Specify the following kernel operation:
For all i‘s (indices) assigned to this thread:
C[i] <- A[i] + B[i]
Start ~20000 (!) threads
Wait for threads to synchronize...

GPU的优势在于：强调并行性意味着我们有很多核心。这允许我们同时运行多个线程而没有上下文切换。

GPU的计算步骤

• Setup inputs on the host (CPU-accessible memory)
• Allocate memory for outputs on the host
• Allocate memory for inputs on the GPU
• Allocate memory for outputs on the GPU
• Copy inputs from host to GPU
• Start GPU kernel
• Copy output from GPU to host

值得注意的是：数据的复制过程可以是异步的。

编程举例

内核代码
1
2
3
4
__global__ void cudaAddVectorsKernel(float* a,float* b,float* c){
    unsigned int index=blockIdx.x*blockDim.x+threadIdx.x;
    c[index]=a[index]+b[index];
}
CPU上调用内核的代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void cudaAddVectors(const float* a,const float* b,float* c,size){
    float* dev_a;
    float* dev_b;
    float* dev_c;
    cudaMalloc((void**) &dev_a,size*sizeof(float));
    cudaMemcpy(dev_a,a,size*sizeof(float),cudaMemcpyHostToDevice);
    cudaMalloc((void**) &dev_b,size*sizeof(float));
    cudaMemcpy(dev_b,b,size*sizeof(float),cudaMemcpyHostToDevice);
    cudaMalloc((void**) &dev_c,size*sizeof(float));
    const unsigned int threadsPerBlock=512;
    const unsigned int blocks=ceil(size/float(threadsPerBlock));
    cudaAddVectorsKernel<<<blocks,threadsPerBlock>>>(dev_a,dev_b,dev_c);
    cudaMemcpy(c,dev_c,size*sizeof(float),cudaMemcpyDeviceToHost);
    cudaFree(dev_a);
    cudaFree(dev_b);
    cudaFree(dev_c);
}

GPU的历史

lecture2 More Basics

线程组织形式(Thread Organization)

关键词

线程(Thread)
块(Block)
网格(Grid)
流形多处理器(Streaming Multiprocessor)
Warp
Warp Divergence

GPU内部构造

把Device Memory(也叫Global Memory)当做GPU里的RAM。它比实际的RAM快速，而且还可以更快。
GPU有着许多SMs,其中每一个SM有多个处理器，但是只有一个指令单元(instruction unit)。SM中的一个处理器组在一定时间内必须运行完全相同的指令。
当内核被调用时，一个任务被分为多个线程，每个线程控制整个任务的某个部分。这些线程被分成一个个网格块(a Grid of Blocks)。Grids和Blocks都有三个维度。然而我们经常使用一个维度的Grids和Blocks。

每个block的最大线程数量是512或者1024，具体取决于机器型号。每个Grid的Block数目通常是65525个。当超过了这些限制之后会使得GPU出现问题。

每个block和一个SM对应。在SM内部，block被分成线程的Warps。每个Warp包含32个线程，这里面的每个线程在同一时刻必须执行完全相同的指令(因为这里只有一个指令单元)。一个SM中的Warps是并行的。如果想要在一个Warp中的线程运行不同的指令，这两个任务将会按照顺序执行，这种现象叫做Warp Divergence。

lecture3

并行问题

非并行问题

并不是所有的问题都是并行问题。GPU用来计算并行问题，对于非并行问题，直接用CPU计算。

lecture4 GPU Memory Systems

NVIDIA Architecture Names

cuda-gpus

延迟和吞吐量(Latency and Throughput)

延迟是由硬件的物理速度造成的延迟。
CPU有着低延迟低吞吐量。CPU clock 3GHz,main memory latency:~100ns,arithmetic instruction latency:~1+ns

GPU有着高延迟和高吞吐量。GPU clock 1GHz,main memory latency:~300+ns,arithmetic instruction latency:~10+ns。这些参数针对 Kepler GPUs(例如GTX 700)。对于 Fermi,吞吐量大概是其两倍。

计算和IO吞吐量(Compute and IO Throughput)

IO往往是吞吐量的性能瓶颈，所以需要好的IO策略。如果象牙超过900GFLOPS,则需要执行多个FLOP共享内存负载。

缓存(Cache)

缓存是位于更大的内存池和处理器之间的一块内存,它通常在硬件级别实现，具有比它更大的内存池更快的访问速度。当请求内存时，请求的内存附近的额外内存被读入一个缓存，读取的数量是缓存和内存池特定的。始终缓存在一起的内存区域称为缓存行，这使未来访问可能在缓存中找到。这种访问被称为缓存命中并允许更快的访问，如果在在缓存中找不到访问，则称为缓存未命中（显然没有性能增益）。

GPU内存

Registers

寄存器是处理器直接使用的一块内存。我们希望尽可能使用最快的内存，寄存器的速度大概是共享内存的10倍。每个SM中有着数以万计的寄存器。通常每个线程最多可以有32或者64个32位的寄存器。在内核中声明的大多数堆栈变量都存储在寄存器中。存储在堆栈中的静态索引数组有时被放入寄存器中。

Local Memory

本地内存是堆栈中不能被寄存器容纳的所有内容。本地内存的范围只是线程，本地内存存储在全局内存中，比寄存器慢得多。

Global Memory

Global Memory是独立于GPU内核的硬件(包含SM，高速缓存，等)。GPU上绝大部分内存都是全局内存，如果数据不适合全局内存，则将以块处理它使得它适合全局内存。GPU有着0.5-24GB的全局内存，现在的设备大多在2GB左右。全局内存的延时在Kepler上大约300ns,在Fermi上大约600ns。
全局内存的IO是GPU上的IO中最慢的(当然对主机内存的通信IO更慢)。由于这个原因，我们希望能够尽可能少访问全局内存。与GPU硬件搭配得很好的访问模式被称为合并内存访问。合并内存访问能够最大限度减少读入的缓存行数量。GPU高速缓存线是128字节并对齐。内存合并在现实中其实复杂得多。

Shared Memory

共享内存是SM中非常快的内存。和L1级缓存的硬件相同，大概5ns的延迟。最大容量为48KB，是用户可配置的。共享内存的范围是block。
共享内存的分配可以通过静态和动态两种方式进行。

静态方式

shared float data[1024];
在内核中定义，在主机代码中不用做任何处理。

动态方式

Host:
kernel<<>>(args);
Device:
extern shared float s[];
定义多个动态大小的变量可以参考
using shared memory cuda cc

案例分析

任务：计算字节频率计数
输入：长度为n的字节数组
输出：存储每个数字出现次数的长度为256的数组

简单方法：在全局内存建立输出，n个全局存储空间。
聪明方法：在共享内存中构建输出，并复制到全局内存中，最终需要256个全局存储空间。

计算强度(Computational Intensity)

计算强度是必须在单个数据点（FLOPs / IO）上完成的操作数的一种表示。通常和复杂度的大O表示方法一致。
如果计算强度大于1，那么相同的数据不止用来计算一次。实践中我们需要尽可能多的共享负载和尽可能少的全局负载。

内核中的常见模式

1、将数据从全局内存拷贝到共享内存
2、__syncthreads()
3、运行计算，并递增地将运行结果存储在共享内存中，如果必要还需进行线程同步。
4、将输出从共享内存拷贝到全局内存。

Bank Conflicts

共享内存被设置为32个bank,如果将共享内存划分为4个字节长的元素，则元素i的位置将在第i%32个bank。当同一个Warp中的两个线程访问同一个bank中的不同元素时将发生bank conflicts。这种冲突将导致串行存储器访问而不是并行访问。在GPU编程中串行任何内容都对性能不利。

Register spilling

It costs:
1 extra load
1 extra store
2 extra pairs of consecutive dependent instructions

L1 Cache

Fermi-caches local& global memory
Kepler,Maxwell -only caches local momory
same hardware as shared momory
configurale size(16,32,48KB)
each SM has its own L1 cache

L2 Cache

caches all global and local memory accesses
about 1MB in size
shared by all SMs

Constant Memory

常量内存是具有特殊缓存的全局内存，用于不能编译成程序的常量，运行内核之前必须从主机设置常量，用户为64KB，编译器为64KB,内核参数通过常量内存传递。
用法：
在全局范围内(内核之外，程序的顶层)：
constant in foo[1024];
主机代码：
cudaMemcpyToSymbol(foo,h_src,sizeof(int)*1024);

Texture Memory

对于通用计算来说，复杂而且只有很小的用处
有用的特点：
●通过“CUDA阵列”进行缓存的二维或三维数据位置,进入特殊的纹理缓存。
●在1D，2D或3D阵列上进行快速插补
●将整数转换为“单位”浮点数
用例：
(1)通过纹理缓存和CUDA数组读取输入数据来利用空间缓存,这是最常见的用例。
(2)通过纹理缓存和CUDA数组读取输入数据来利用。
(3)利用数字纹理功能。
(4)与OpenGL和一般计算机图形学的交互。

Read-Only Cache(CC 3.5)

许多CUDA程序不使用纹理，但是我们应该利用纹理缓存硬件。CC>=3.5 使得使用纹理缓存更加容易。许多const限制变量将自动通过纹理缓存加载(也称为只读缓存)。也可以使用__ldg内部函数强制加载缓存。其和常量内存不同，因为不需要静态索引。

lecture5 GPU Compute Programming

Warp调度

warp调度程序找到一个准备好执行下一个指令和可执行的warp核心，然后开始执行
GK110：每个SM中有4个调度程序，2个调度程序每个时钟最多4次启动指令，并在每个经纱中启动最多2条指令。

GK110(Kepler) numbers

max threads/SM=2048(64warps)
max threads/block=1024(32warps)
32bit registers /SM=64KB
max shared memory /SM=48KB
值得注意的是：在一个SM上同时运行的块的数量取决于该资源的需求块。

占用率

occupancy=warps per SM / max warps per SM
max warps /SM depends only on GPU
warps /SM depends on warps /block, registers/block, shared momory/block。

同步

在CPU上，可以使用锁，信号量，条件变量等来解决同步问题。在GPU上，这些解决方案引入了太多的内存和处理开销。其实我们有更简单的解决方案更适合并行程序。我们使用__syncthreads()函数来同步块内的线程◦但是只能在块级别运行，因为SMs是彼此分开的，所以做不到比这更好。类似于C/C++中的barrier()函数。

lecture6 同步、共享内存、矩阵转置

同步

并行的理想状态：线程之间无资源共享，无通讯。许多只需要一点点共享资源的算法仍然能够通过大规模的并行计算来实现。

需要同步的例子

1、并行BFS
2、计算列表之和
3、向GPU的共享内存载入数据

__syncthreads()

作用是同步一个block中的所有线程。值得注意的是：共享内存是在每个block之内共享。Every block that is launched will have to allocate shared memory for its own itself on its resident SM。__synchthreads()方法对于内核共享内存很有用。

原子指令：动机

一个原子指令作为一个基本单元，不能被打断。序列化访问。
CUDA上的原子指令：
atomic{Add, Sub, Exch, Min, Max, Inc, Dec, CAS, And, Or, Xor}
Syntax: atomicAdd(float* address, float val)
在全局内存和共享内存都起作用。

使用建议

做更多的便宜操作和做更少的复杂操作。
举例：计算列表的和。
Naive方法：每个线程以原子方式递增每个数字到全局内存中的累加器。
更聪明的方法是：
.每个线程在寄存器中计算自己那部分的和。
.利用warp shuffle来计算跨越warp的和。
.每个warp以原子方式递增和到全局内存中的累加器。
.将原子操作的数量减少32倍。(32为每个warp的线程数)。

warp-synchronous programming

怎样能够使得warp中的各个线程同步呢？实际上，warp中的各个线程已经是同步的。这样可以减少__syncthreads()方法的调用次数。

Warp shuffle

从warp中的另一个线程读取寄存器的值。
int __shfl(int val,int srcLane, int width=warpSize)
对于计算整个warp的和极其有用。First avalible on Kepler(no Fermi, only CC>=3.0)

展开全文 >>

常用软件安装及配置

1、cmder安装及配置
cmder安装及配置教程
2、Virtual Box安装
virtual box 安装教程
3、腾讯视频qlv格式转mp4
打开缓存文件夹，管理员方式运行cmd，到tdl文件目录下，输入 copy/b *.tdl videoname.mp4 即可得到mp4格式视频文件。
4、tensorboard不能正常使用
tensorboard —logdir=”dir” —host=127.0.0.1 即可正常使用
5、ssh into wsl
使用ssh登录本机wsl。

6、使用LaTex添加公式到Hexo博客里
配置链接

展开全文 >>

常用卷积神经网络结构


主要介绍几种当前常见的卷积网络结构。包括AlexNet,VGGNet,GoogleNet,ResNet等。

AlexNet

AlexNet结构获得了2012年ILSVRC的冠军。其主要结构如下,这是cs231n的课件做的一个总结：

VGGNet

VGGNet是2014年ILSVRC的分类第二名，和AlexNet相比的改进是滤波器的尺寸更小，只用3x3的滤波器；还有就是更深的网络结果。具体如下；

用3x3的滤波器的原因：3个3x3的卷积层的组合的effective of field和一个7x7的卷积层是一致的。并且还有以下两个优点：1、网络更深，引入更多非线性；
2、引入更少的参数，对于每层C个通道的结构，3层3x3的参数个数为 333CC=27CC,而1个7x7的参数为77CC=49C*C。
下面是对参数的一个分析,可见占用内存最多的层是在前面的卷积层，而拥有参数最多的层在最后的全连接层：

GoogleNet

GoogleNet结构获得2014年ILSVRC的分类第一名。它具有更深的网络结构，达到22层，但是采用了更高效的计算。

它的最大的一个亮点是采用Inception module的结构。

从前一层开始并行计算4种不同类型和参数的网络层，在depth上叠加得到输出。但是这带来一个比较大的问题就是计算量太大，因为卷积层和池化层都会保留depth,所以每个并行的层都会带来整个输出的depth的增加。这个问题的一个解决方法就是使用更小深度的1x1的卷积层来减少深度。


最后得到的优化的Inception module结构如下：

于是整个GoogleNet就以多个Inception小模块为基础搭建而成。GoogleNet还有另外一个亮点是摒弃了计算量巨大的FC层。

ResNet

ResNet结构获得了2015年ILSVRC的第一名。它的最大亮点就是采用了残差学习的新思想。它将输入的结果加到通过普通网络层的输出上形成新的输出。这样使得训练很深的网络结构变得有效。

这个方法解决了之前的一个很大的问题，事实上，在这之前，如果我们将网络层数增加到特别深的情况下，其性能是会变差的，但是并不是由过拟合造成的，而是因为太深的网络结构难以优化。
而这个残差网络就能很好解决难以优化的问题。

这样一来整个网络结构就如下所示：

对于比较深的网络，还应采用类似GoogleNet的1x1的”bottleneck” layer来提高网络的计算效率。

代码实现

主要是基于tensorflow的一些实现。
tensorflow models

参考

cs231n spring2017 lecture9 slides
cvpr2017_tutorial_kaiminghe
AlexNet
GoogleNet
VGGNet
ResNet

展开全文 >>

Python使用问题

整理一些使用Python过程中遇到的问题和解决方法。

Python3

cPickle

python3中没有cPickle模块，和pickle合并了，所以在python3中使用pickle。在使用load的过程中，需要指定encoding,否则可能会出现问题。

ubuntu下为python3.5安装pip3.5

1、下载setuptools,easy_install安装包
wget https://bootstrap.pypa.io/ez_setup.py
2、安装easy_install-3.5
python3.5 ez_setup.py
3、安装pip3.5
easy_install-3.5 pip
4、升级pip3.5版本
pip3.5 install —upgrade pip
5、注意：遇到失败情况时可能是由于没有权限，可以尝试在命令前加sudo

在linux下可以通过设置PYTHONPATH的方法指定python工程目录

命令如下：也可在 ~/.bashrc 中 添加以下命令达到永久指定的效果
export PYTHONPATH=”${PYTHONPATH}:/my/other/path”
遇到不能为root添加PYTHONPATH的情况，用了一下方法解决：
sudo visudo(which open the /etc/sudoers file in a safe way)
然后添加：
Default env_keep+=”PYTHONPATH”
保存之后生效

UnicodeDecodeError: ‘utf-8’ codec can’t decode byte 0xff in position 0: invalid start byte

image_data = tf.gfile.FastGFile(filenames[i], ‘r’).read()
我使用的是python3,后来在python2下就没有出现这个问题。

在windows下编译pyc文件时，运行setup.py文件提示找不到cl.exe文件。

解决方法是打开vs自带的Command Prompt工具运行setup.py文件

pycharm切换python版本

settings->project->project interpreter

使用cx_Freeze 打包python程序成exe文件

期间遇到了一些坑，最后顺利解决。主要就是在要打包的脚本文件夹内编写以下脚本，并执行

1
2
3
4
5
6
7
8
9
10
11
12
13
# setup.py
import sys
from cx_Freeze import setup, Executable
import os
os.environ['TCL_LIBRARY'] = r'C:\Users\ThinkPad\AppData\Local\Programs\Python\Python36\tcl\tcl8.6'
os.environ['TK_LIBRARY'] = r'C:\Users\ThinkPad\AppData\Local\Programs\Python\Python36\tcl\tk8.6'
Base=None
setup(name = 'labelme',
      version = '0.0.1',
      executables = [Executable('app.py',base=Base)],
      options = {'build_exe': {'includes': ['atexit']}})

然后 python setup.py build 运行此脚本即可在 build 找到打包好的程序。
注意python的根目录应该是包含此脚本的文件夹。之前因为不是这样导致打包的程序不能正确运行。
这样打包出来的程序运行起来会有黑框，如果不想要那个黑框，可以把Base=None改为
Base=’Win32GUI’

python3 中的一些编码问题一定要注意

with open(filename, ‘w’) as f
with open(filename, ‘wb’) as f
b64encode(imageData.encode(‘utf-8’))
b64encode(imageData).encode(‘ascii’)

opencv读图片Premature end of JPEG file？

主要是由于图片不完整造成的，可以用以下脚本检验图片是否有效。

1
2
3
4
5
6
7
8
9
10
from PIL import Image
def check_pic(path):
    try:
        Image.open(path).load() 
    except:
        print 'ERROR: %s' % path
        return False
    else:
        return True

知乎回答

pyconfig.h can’t find

解决方法：sudo apt-get install python-dev (或者python3.5-dev等相应版本)

import win32file 时出现 dll缺失，系统找不到指定文件问题

解决方法：site-package文件夹中pywin32_system32文件中的dll文件复制到C/windows/system32文件夹中。

展开全文 >>

Trainning-Nerual-Networks


主要介绍训练神经网络的一些技巧，是对cs231n spring 2017 课程 lecture 6、7两节内容的一个整理。

激活函数

激活函数的作用就是引入一个非线性变换，起到一个激活作用。常见的激活函数有sigmoid,tanh,ReLU,Leaky ReLU等。下面分别介绍。

sigmoid

sigmoid的表达式是 σ(x)=1/(1+exp(-x))。其图像如下图所示：它有两个明显的缺点使得现在已经不适用了：
1、当x过大或者过小时，曲线趋于饱和，使得梯度很小，可能导致很少数据被激活。而且这也给参数初始化造成困难，参数初始化过大或者过小都不好。
2、它不过原点，一般来说我们希望激活函数能过原点。当然，这相比第一个缺点来说，负面影响会小一点。

tanh

tanh其实就是将sigmoid函数变换到以0为中心，它和sigmoid函数一样有着饱和的问题，不过有所改进的是它没有sigmoid函数的第二个缺点。其表达式是：tanh(x)=2σ(2x)-1,图像如下所示：

ReLU

过去几年比价流行的激活函数是ReLU,其表达式非常简单:f(x)=max(0,x),图像如图所示：

相比之前的激活函数，ReLU函数有以下特点：
优点：计算简单快速，实现容易。而且没有趋于饱和的问题。
缺点：由于在x小于0时，其数值是0，这可能造成有些神经元会在训练过程中由于参数更新使得永久不能被激活。如果学习率设置得比较高，最后可能会有高达40%的神经元不会被激活。

Leaky ReLU

为了解决ReLU函数部分神经元不能起作用的问题，在x小于0的部分引入一个比较小的斜率(一般设置为0.01)。这在有些场合是比ReLU函数表现好的。

Maxout

另一种激活函数形式是这样的:

它是对ReLU和LeakyReLU的推广，它有着ReLU函数的优点，却不存在ReLU函数的缺点。不过相对而言，其参数个数会翻倍。

使用建议

优先选用ReLU,如果效果不好，可以尝试Leaky ReLU或者Maxout，也可以尝试tanh(但是它的效果在绝大多数情况会比ReLU/Maxout差)。sigmoid就千万别用了，已经被时代抛弃~

数据预处理

主要有3中常用的数据预处理方法，对于数据矩阵X,大小是[NxD],N是数据数量，D是维度。

Mean subtraction

这是最常用的一种方法。就是做一个减去平均值的处理。在python中这样实现：
X-=np.mean(X,axis=0)

Normalization

做法是把数据维度规范化，一种做法是将所有数据除以标准差：X/=np.std(X,axis=0)；另一种做法是规范化使得最大值为1，最小值为-1。
下图中左边是原始数据，中间是做Mean subtraction处理，右边是做Normalization(具体方法是除以标准差的做法)处理。

PCA and Whitening

PCA(主成分分析)和Whtening的做法都是先利用Mean subtraction方法将数据零对称，然后计算协方差矩阵，将协方差矩阵进行特征值分解之后再进一步处理。
它们相同的步骤是：

1
2
3
4
5
6
# Assume input data matrix X of size [N x D]
X -= np.mean(X, axis = 0) # zero-center the data (important)
cov = np.dot(X.T, X) / X.shape[0] # get the data covariance matrix
U,S,V = np.linalg.svd(cov)
Xrot = np.dot(X, U) # decorrelate the data

之后，PCA的处理是用主成分代替整个数据已达到降维的目的，可以以最小的精度损失代价换取较快的计算。

1
Xrot_reduced = np.dot(X, U[:,:100]) # Xrot_reduced becomes [N x 100]

而Whitening的处理方式是：

1
2
3
# whiten the data:
# divide by the eigenvalues (which are square roots of the singular values)
Xwhite = Xrot / np.sqrt(S + 1e-5)

值得注意的是：我们在实现的过程中为了防止除零，在分母加了一个小常数，这样带来了一个问题就是它放大了噪声的影响。这个问题可以通过将这个常数增大来减轻。下图中左边是原始数据，中间和右边分别是PCA和Whitening的处理结果。

具体例子

下面是对CIFAR-10中的一些数据进行预处理结果。

实际使用

实际上在卷积网络中，是不使用PCA和Whitening作为预处理的。而Mean subtraction和Normalization通常是必须要做的。另外值得注意的一点是：预处理步骤中的一些统计信息的计算，比如求均值等，只能在训练集上计算，然后应用到测试集上。

权重初始化

训练神经网络的一个很重要的步骤是参数的初始化工作，理想的初始权重是满足高斯分布。主要有以下几种初始化的方法，下面将分别讨论。

陷阱：全部初始化为0

如果全部初始化为0的话，那么每个神经元都会有相同的输出，这样在反向传播的过程中它们也会有相同的梯度，最后就会执行相同的参数更新。那么最终的优化后的参数也会全部都是一样的，很明显这样的网络是没有价值的。所以这种初始化方式是错误的。

随机小数初始化

另一种方式就是随机小数初始化，W=0.01*np.random.randn(D,H)。但是事实上这种初始化方式并没有更好的表现。因为如果一个神经网络层具有很小的权重，那么计算出的梯度也会逐渐。考虑一个10层的网络结果，有500个神经元，tanh作为激活函数。实验中出现，随着层数增加，最后就会出现绝大多数参数为0的情况，这又遇到了和全初始化为零一样的问题。有一种设想是改变随机数前面的系数从0.01改为1，这样在实践中又会造成几乎所有神经元的饱和，其值不是-1就是1，而梯度都为0。

用sqrt(N)校正

初始化为W=np.random.randn(n)/sqrt(n)，这在以tanh为激活函数的时候有比较好的效果，但是在以ReLU为激活函数的时候效果就不太好了。其实目前在实践中最推荐的初始化方式是W=np.random.randn(n)/sqrt(2/n),激活函数为ReLU。

偏置量的初始化

最常用的方式就是将偏置初始化为0，当然也有做法将偏置统一初始化为一个小数，比如0.01。

Batch Normalization

参考
batch normalization 论文
quaro
参考1
论文笔记：Batch Normalization
视频讲解

Regularization(正则化)

正则化的目的就是防止过拟合。主要有以下几种方式。

L2 regularization

这是一种比较常用的正则化方法，对每个权重的平方都进行正则化惩罚，常常设置为0.5λWW，λ是一个超参数，前面加一个0.5的系数是为了方便反向传播的时候求导为λW。

L1 regularization

L1 regularization 也是常用的正则化方法，也可以同时使用这两种方法，设置惩罚项为
λ1abs(W)+λ2W*W。

Max norm constraints

正则化的另一种形式是强制每个神经元的权重向量的绝对上限，并使用预测的梯度下降来强制约束。这种方法的好处就是即便学习率设置得很高，网络也不会出现问题，因为参数更新受到极大限制。

Dropout

这是一种比较新的防止过拟合的正则化的方法。通过每次执行参数更新时随机抛弃每一层的一定数量的神经元来达到防止过拟合的目的。决定神经元是否激活的概率p是一个超参数。具体实现的时候需要注意只是在训练的时候需要执行dropout，在测试的时候并不dropout,所以测试时还需要做一个尺度变换，乘上一个p。但是实践中是在训练时执行一次Inverted dropout，而在测试中不做任何处理。

偏置正则化

偏置的正则化是不常见的，因为它们不通过乘法相互作用与数据交互，对于最终的输出没有什么影响。然而，在实际应用中（通过适当的数据预处理），正则化偏差很少会导致性能显着降低。

实践技巧

实践中常用的是L2 regularization，其系数λ通过交叉验证来设置。也可以将其和dropout相结合，dropout的概率p一般设置为0.5。

Loss Function

loss function就是对ground truth和我们的预测结果之间差异的度量，我们在训练中做的事情就是使得其最小化。我们需要针对不同的场景选择适合的loss function以达到我们的目的。

Classfication

在分类任务中，我们常用的loss function有 SVM loss：
其形式如下：

实际应用中也有使用它的平方项达到较好效果的例子。
另外一种常见的是Softmax loss,如下所示：

实际上当分类任务中标签太多时，更推荐使用Hierarchical Softmax loss的计算方法，具体细节见
参考

Attribute classfication

上面介绍的loss function都是针对一个物品只有一个标签的情况，对于一个物体有多个标签的情况，我们需要用另外一种度量方法。解决这种的一个比较好的方法是独立地为每个单独的属性构建一个二进制分类器。例如，每个类别的二进制分类器将独立采用以下形式：

其中y(ij)的值取决于第i个物体是否属于类别j,如果是，其值为1，否则为-1。
这种损失的替代方案是独立地为每个属性训练逻辑回归分类器。二元逻辑回归分类器只有两个类（0,1），并且将类1的概率计算为：

这可以最终简化得到

这种方法看起来麻烦，实际上它的梯度计算非常简单，为：

Regression

这类任务需要预测一个东西的准确值，比如预测房价等。常常使用L1 loss或者L2 loss。实际上，L2 loss相比softmax loss更难优化。除非绝对必要，否则不要使用回归任务，如果能够将这类任务转化为分类任务，那是再好不过的。

Gradient Checks

梯度检查实际就是将analytic gradient 和 numerical gradient 进行比价，用numerical gradient检查 analytic gradient是否计算正确。这个过程很关键，而且容易出错，这里介绍一点处理的技巧。
1、Use teh centered formula

2、Use relative error for the comparison
比较两种梯度时，比较绝对误差是没有任何意义的，实践中是比较相对误差。

通常情况下这个error>1e-2说明梯度有问题，需要检查；1e-2>error>1e-4,勉强能够接受;1e-4>error，在一般情况下算是比较好的;如果error<1e-7,那么肯定是正确的了。但是这个误差与网络层数也有关系，网络越深，很明显这个误差会越大，比如对于一个10层的网络，这个error在1e-2的量级也许都是可以接受的，但是对于只有一层的网络这显然太高。所以还要根据实际情况尽心考虑。
3、Use double precision
进行梯度检查时应该使用double,用float精度不够。
4、Stick around active range of floating point
在运算过程中将中间数据浮点数控制在有效范围，太小的数据可能会造成一些数值问题(1e-10甚至更小的数据是没有意义的)。遇到这样的中间结果时，需要暂时进行一个缩放将数值扩大到一个适当的范围，比如到1e0量级。
5、Kinks in the objective
对于某些激活函数，比如ReLU,会出现梯度不连续的问题，在执行梯度检查的时候需要格外注意，否则可能造成意外的结果。
6、Use only few datapoints
解决上述问题的一个方法就是使用更少的数据点，这样既可以有效避免上述问题，还可以使得梯度检查更加快速，效率更高。
7、Be careful with the step size h
h并不是越小越好，如果h太小的话反而可能会造成一些数值问题。
8、Gradcheck during a “characteristic” mode of operation
9、Don’t let the regularization overwhelm the data
10、Remember to turn off dropout/augmentations
11、Check only few dimensions

sanity checks

在开始进行训练之前，需要先对网络进行一些简单的健壮性检查。

Look for correct loss at chance performance

当进行参数初始化时，我们需要保证初始的loss达到我们的预期。所以需要我们单独检查loss(这时要忽略正则化项)。如果loss和我们的预期不符，这时需要检查是否初始化存在问题等。

#

增加正则化项的权重会增加loss，也可以一次为标准进行检查。

Overfitting a tiny subset of data

正式开始训练之前，可以用较小的数据集进行训练，看看能不能使得loss为0(注意这时不要考虑正则化项)。如果不能使得loss为0，那么这个网络应该是存在问题的。当然即便能够使得loss为0，也不代表网络是正确的，不排除有其他bug的情况。

监视学习过程

在训练神经网络时应该监视多种有用的数量。这些图是进入训练过程的窗口，应该被用来获得有关不同超级参数设置的直观性，以及如何改变它们以提高学习效率。下面的图的x轴总是以epoch为单位，其测量在期望的训练期间每个示例已经看到多少次（例如，一个时期意味着每个示例已经被看到一次),优选的是epoch而不是迭代次数，因为迭代次数取决于批量大小的任意设置。

loss function

我们训练的目的就是使得loss最小化，所以loss是最需要跟踪的一个参数。如下图所示：损失曲线通常会出现摆动，这和batch size有关，如果batch size是1，那么这个摆动会很厉害，如果batch size是整个数据集，那么将不会出现摆动。

Train/Val accuracy

训练分类器时跟踪的第二个重要数量是验证/训练准确性。这让我们更直观了解到过拟合现象。过拟合简单来说就是在训练集上表现好，但是在测试集上表现差的现象。从下图可以直观看出。

Ratio of weights:updates

最后一个需要关心的参数是更新幅度与整个值的幅度的比例。这个幅度最好在1e-3左右，如果这个值太小，说明学习率设置太低，反之则太高。我们需要对此作出调整。代码如下所示：

1
2
3
4
5
6
# assume parameter vector W and its gradient vector dW
param_scale = np.linalg.norm(W.ravel())
update = -learning_rate*dW # simple SGD update
update_scale = np.linalg.norm(update.ravel())
W += update # the actual update
print update_scale / param_scale # want ~1e-3

Activation/Gradient distributions per layer

初始化不正确可能会减慢甚至完全停止学习过程。幸运的是，这个问题可以比较容易地诊断出来。 一种方法是绘制网络的所有层的激活/梯度直方图。直观地看，看到任何奇怪的分布并不是一个好兆头。 如果是tanh神经元，我们希望在[-1,1]的全范围内看到神经元激活的分布，而不是看到所有神经元输出零，或者所有神经元在-1或1完全饱和。

First-layer Visulization

处理图像问题时，绘制第一层的特征还是很有用的，可以以此为根据判断参数好坏。

参数更新

当通过反向传播计算出analytic gradient后，我们可以以此进行参数更新。具体的更新方法下面将详细介绍。

Vanilla updata

最简单常用的参数更新方式，直接沿着负梯度的方向更新：

1
x+=-learning_rate*dx

Momentum update

动态更新是另一种在深度网络上几乎总是具有更好的融合速率的方法。其实现如下：

1
2
3
4
v=mu*v-learning_rate*dx
x+=v
#其中v初始化为0，mu是一个超参数，典型的设置为0.9或者0.99。通过动量更新，参数矢
#量将在具有一致梯度的任何方向上建立速度。

Nesterov Momentum

Nesterov动量是一个稍微不同的动态更新的版本，最近越来越受欢迎。对凸函数有较强的理论收敛保证，实际上也比标准动量略好。其通常实现如下：

1
2
3
v_prev = v # back this up
v = mu * v - learning_rate * dx # velocity update stays the same
x += -mu * v_prev + (1 + mu) * v # position update changes form

Adagrad

1
2
3
# Assume the gradient dx and parameter vector x
cache += dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)

RMSprop

1
2
cache = decay_rate * cache + (1 - decay_rate) * dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)

Adam

1
2
3
4
5
6
7
8
9
10
11
12
13
m = beta1*m + (1-beta1)*dx
v = beta2*v + (1-beta2)*(dx**2)
x += - learning_rate * m / (np.sqrt(v) + eps)
``` 
通常设置eps=1e-8,beta1=0.9,beta2=0.999。
还有一种包括偏置的形式：
``` Python
# t is your iteration counter going from 1 to infinity
m = beta1*m + (1-beta1)*dx
mt = m / (1-beta1**t)
v = beta2*v + (1-beta2)*(dx**2)
vt = v / (1-beta2**t)
x += - learning_rate * mt / (np.sqrt(vt) + eps)

实践技巧

推荐的参数更新方式是SGD+Nesterov Momentum或者Adam。

超参数优化

训练神经网络之前需要许多超参数的设置。最常见的超参数有：
初始学习率，learning rate decay schedule(such as decay constant),正则化的一些参数(比如L2的系数，dropout的比例)。
在选择超参数时需要注意以下一些一些事情：
1、Prefer one validation fold to cross-validation:虽然常说需要用交叉验证的方式确定超参数，但是实际上只需要一个验证集就足够了。
2、Hyperparameter ranges:常常在log的尺度上搜索超参数，例如 learning_rate=10**uniform(-6,1)。但是对于一些特殊参数，比如dropout的比例，不需要也不能这样，通常的做法是：dropout=uniform(0,1)。
3、Prefer random search to grid search：实践证明，随机搜索的效率会比网格搜索的效率高。
4、Careful with best values on border：当我们确定的超参数在我们搜索的范围边界上时，我们要特别注意，有可能这个超参数并不是最好的，我们这时需要在这个边界上扩大搜索范围再进行超参数搜索。
5、Stage your search from coarse to fine：一种比较好的实践方式是先在一个大范围内搜索超参数，只需要一个epoch，可以排除一些明显不合适的超参数，这样缩小范围后再进行超参数的确定。
6、Bayesian Hyperparameter Optimization

评估

模型组合(Model Ensembles)

通过一些模型的组合可能对网络效果有额外的一点提高。下面是一些模型组合的方法。
1、Same model,different initializaitons：先用交叉验证的方法确定超参数，然后用不同的初始化参数进行训练。
2、Top models discovered during cross-validation:用交叉验证的方法确定最好的几个参数。
3、Different checkpoints of a single model
4、Running average of parameters during training

参考

cs231n lecture6 slides
cs231n lecture7 slides
cs231n neural network notes 1
cs231n neural network notes 2
cs231n neural network notes 3

展开全文 >>

Convolutional-Neural-Networks

主要介绍神经网络和卷积神经网络的一些东西。

神经网络(Neural Networks)

之前的线性score function 是 f=Wx，现在扩展到2层的神经网络的表示是：f=W2max(0,W1x)。类似的，如果扩展到3层网络可以这样表示：f=W3max(0,W2max(0,W1*x))。

一个简单的2层神经网络可以这样实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import numpy as n p
form numpy.random import randn
N,D_in,H,D_out=64,1000,100,10
x,y=randn(N,D_in),randn(N,D_out)
w1,w2=randn(D_in,H),randn(H,D_out)
for t in range(2000):
    h=1/(1+np.exp(-x.dot(W1)))
    y_pred=h.dot(W2)
    loss=np.square(y_pred-y).sum()
    print(t,loss)
    grad_y_pred=2.0*(y_pred-y)
    grad_w2=h.T.dot(grad_y_pred)
    grad_h=grad_y_pred.dot(W2.T)
    grad_w1=x.T.dot(grad_h*h*(1-h))
    w1-=1e-4*grad_w1
    w2-=1e-4*grad_w2

神经网络的结构

一个完整的神经网络应该包括1个输入层，若干隐藏层，1个输出层。

总结

1、神经网络中把每一层的神经元做一个全连接。
2、对于每一层的计算都可以用高效的矢量计算来实现。
3、神经网络和真正的神经是不一样的，只是在某种程度上有些相似性。

卷积神经网络(Convolutional Neural Networks)

结构介绍

卷积神经网络有着神经网络所有的特征：每一层由神经元组成，我们可以学习它的W和b;每一个神经元有一个输入，进行一个点积运算之后，可以紧接着一个非线性的操作；整个网络最后也是运算一个score function，输出scores;在最后一层全连接层仍然会计算一个损失函数；以及神经网络的一些其它性质和技巧在卷积神经网络中依然适用。

但是卷积神经网络和普通神经网络相比有以下区别：
卷积神经网络明确假设输入是图片，这允许我们将某些属性编码到架构中，使得前向网络能够更为有效地实现，并且大大减少了网络中的参数数量。

通常的神经网络接受一个输入（通常是一个一维向量），并通过中间的隐藏层对其进行一些变换，每一层隐藏层包含多个神经元，其中每一个神经元都和上一层的各个神经元全连接。同一层的神经元之间是相互独立，并不存在任何连接。最后一层全连接层叫做输出层，在分类问题中它就代表每个类的分数。

普通的神经网络不能直接对图片操作，而是将图像矩阵拉伸成一维向量，比如对于32x32x3的图片，这样对于一个神经元就会有3072个权重。对于更大的图片，权重的数量将会更多。关键的问题是，这样的神经元会有很多，这样的话参数的数量将会增长很快。这样使得全连接有些浪费，并且参数过多很容易造成过拟合。

对于卷积神经网络来说，每一层的神经元包括三个维度(width,height,depth),这样，每一层的神经元就只和前面一层的很小一部分区域有联系，这区别于普通神经网络的全连接层。另外，对于之前的CIFAR-10的例子，最后输出层的输出结果是一个1x1x10的矩阵。
如下图所示：左边是普通的神经网络，右边是一个卷积神经网络。卷积神经网络的每一层都有一个简单的API把一个形状的3维体积通过一个可微函数转换为另一个形状的3维体积。

卷积网络的层的种类

正如上面所说，一个简单的卷积神经网络由一系列层组成，每一层通过一个可微函数将一个三维体积转换成另一个不同形状的三维体积。主要使用一下三种类型的层来构建卷积神经网络：卷积层，池化层以及全连接层，把这三种类型的层组合在一起就可以构建一个完整的卷积神经网络。

举例

对于CIFAR-10这个数据集的分类问题，我们可以构建这样一个卷积神经网络：
[INPUT-CONV-RELU-POOL-FC]。具体分析如下：
1、INPUT[32x32x3],即输入一张原始图片，大小为32x32,通道数为3
2、CONV(卷积层)计算连接到局部输入的神经元的输出，每次计算权重和局部输入的卷积，如果我们用12个滤波器的话，最后的输出将会是[32x32x12]。
3、RELU层就将执行一次激活函数，不改变输入大小，依然是[32x32x12]。
4、POOL层将在空间维度上进行一次下采样(downsample)，然后输出维数为[16x16x12]
5、FC层将计算一个得分函数(score function)，输出体积为[1x1x10]。这一层的神经元将和前一层的所有体积相关联。
这样，通过一层层的运算，卷积神经网络将输入的原始图像转换为得分向量。值得一提的是：其中有些层的操作是由参数的，而有些层的操作是没有参数的。比如CONV/FC层就包括神经元的W和b参数，而RELU/POOL层的操作则是不变的，不需要任何参数。COVN/FC层的参数将通过梯度下降的算法进行优化以便达到良好的识别效果。

总结

1、卷积神经网络的结构就是实现简单的从一个形状到另一个形状的转换。
2、它由不同类型的层组成，目前最常用的就是卷积层，池化层，激活层以及全连接层。
3、每层可以有参数(比如CONV、FC)也可以没有参数(比如RELU、POOL)，每层可以有超参数(比如CONV、FC、POOL)也可以没有超参数(比如RELU)。

结构细节

卷积层

卷积层是一个卷积神经网络的核心，大部分的运算量都集中在卷积层。

不考虑神经元的分析

卷积层的参数包括一系列可以学习的滤波器。每个滤波器在空间上是小块的，但是在深度上是和输入一致的。例如，一个典型的在第一个卷积层的滤波器的尺寸是[5x5x3]。在前向计算的过程中，我们用滤波器的大小在输入体积上面滑动，然后在每个位置计算滤波器和其覆盖的输入部分的点积之和作为这个位置的计算结果。整个过程下来，我们将产生一个二维的激活图，其中每个点的结果表示输入的体积对于滤波器在该位置的响应。更直观地说，网络将学习当他们看到某种类型的视觉特征（例如某一方向的边缘或第一层上的一些颜色的斑点）或最终在网络的较高层上的整个蜂窝或轮状图案时激活的过滤器。 现在，我们将在每个CONV层中拥有一整套滤波器（例如12个滤波器），并且它们中的每一个将产生单独的二维激活图。 我们将沿深度维度堆叠这些激活图，并产生输出量。

从神经元角度的分析

输出结果中的每个元素也可理解为神经元的输出，其只在输入中看到一个小区域，并和其左右的神经元在空间上共享参数。现在分别讨论神经元之间的联系，空间上的排布以及参数共享的一些细节。

局部联系

当处理诸如图像的高维输入时，将神经元连接到前一层的所有神经元是不切实际的。但是我们可以将每个神经元连接到前一层的局部区域。这种连通性的空间范围是神经元的超参数，称为接受场(receptive filed)，等价于滤波器大小。这里需要再一次强调我们处理空间尺寸和深度时的不一致性。这种连接在空间是局部的，但是在深度上是全连接的。

例1

假设输入尺寸是[32x32x3],滤波器大小是[5x5],这样的话每个神经元将对应于一个[5x5x3]的区域，这样就有553=75(再加1个偏置b)的weights。

例2

如果输入尺寸是[16x16x20],滤波器大小是[3x3],那么卷积层中的每个神经元将有3320=180(再加上1个偏置b)的weights和输入体积相关联。

空间分布

上面阐述了一层卷积层中的每个神经元和输入的体积之间的联系。但是没有说明在输出体积中有多少个神经元以及它们之间是怎么排布的。有以下三个超参数会影响神经元的空间分布：分别是depth,stride和zero-padding。下面分别讨论细节。

depth

depth和我们期望的滤波器的种类有关，每个滤波器会学习到输入中的一些不同特征。
例如，如果第一卷积层作为原始图像的输入，则沿着深度维度的不同神经元可以在存在各种定向边缘或颜色的斑点的情况下激活。我们将参考一组神经元，它们都是与输入的相同区域作为深度列。

stride

stride是指计算卷积时跳过的像素点数，如果是依次计算的话，则stride是1。stride越大，在相同输入情况下，输出的空间尺寸会越小。

zero-padding

有时为了运算方便，会对输入图像进行边界的零填充，零填充的尺寸大小也是一个超参数。通过控制零填充的大小，我们可以方便控制输出体积的大小。

计算输出体积大小

了解了以上性质之后，我们可以计算输出的体积大小，假设输入体积大小是W，滤波器大小是F，stride大小是S,zero-padding大小是P，然后就可以计算出输出尺寸V是：
V=(W-F+2*P)/S+1。比如W=5，S=1，P=1，F=3，那么V=5，如果改变S=2，那么V=3。如下图所示：

一些注意事项
zero-padding的正确设置

当S为1时，一种常见的做法是设置P=（F-1)/2，这样使得V=W。使得输入和输出在空间大小上保持一致。

strides的限制

不合适的设置S可能使得产生无效的结果。比如W=10，P=0，F=3，如果S=2，那么V=(W-F+2*P)/S+1=4.5将不是一个整数。如果出现这样的情况，我们将采用改变P或者裁剪输入等方法来避免这个问题。

实际操作的一个例子

Krizhevsky et al.

2012年ImageNet比赛的冠军的一个例子。输入图像是[227x227x3],F=11,S=4,P=0,计算得到V=(227-11)/4+1=55。而depth=96。最后得到的输出是[55x55x96]。这就表示输出体积中的555596个神经元之一都和输入中的[11x11x3]大小的区域相关联。

参数共享

参数共享的目的是为了控制卷积层中参数的数目。考虑上面的那个例子。在第一层卷积层中有555596=290400个神经元，每个神经元都有11113=363个weights和1个bias，这样的话，在第一层中将会有290400364=105705600个参数，显然，这个数目太大了。
事实证明，我们可以通过一个合理的假设大大减少参数数量：如果一个特征在某些空间位置（x，y）上计算有用，那么在不同的位置（x2,y2）计算也是有用的。换句话说，将深度的单个二维切片表示为深度切片（例如，尺寸[55×55×96]的体积具有96个深度切片，每个尺寸[55x55]），我们将限制每个深度切片中的神经元使用相同的权重和偏差。使用此参数共享方案，我们的示例中的第一个Conv Layer现在将只有96个唯一的权重集（每个深度片一个），总共96 11 11 3 = 34,848个唯一权重或34,944个参数（ +96偏置）。或者，每个深度切片中的所有55 * 55个神经元现在将使用相同的参数。在反向传播中的实践中，体积中的每个神经元将计算其权重的梯度，但是这些梯度将在每个深度切片上相加，并且仅更新每个切片的单个权重集合。
注意，如果单个深度切片中的所有神经元都使用相同的权重向量，则CONV层的前向可以在每个深度切片中计算为神经元权重与输入核的卷积（因此名称为卷积层）。 这就是为什么通常将权重集合称为与输入进行卷积的滤波器。
请注意，有时参数共享假设可能没有意义。 特别是当ConvNet的输入图像具有某些特定的居中结构时，我们期望在图像的一侧学习完全不同的特征。 一个实际的例子是当输入是一张位于图像中心的脸，我们可能会期望在不同的空间位置学习眼睛或头发的特征。在这种情况下，通常放松参数共享方案，简单地使用本地连接层(Locally-Connected Layer)。

利用大矩阵乘法实现卷积层

注意，卷积运算基本上在输入的滤波器和局部区域之间执行点积。 CONV层的常见实现模式是利用这一事实，并将卷积层的正向传递作为一个大矩阵乘法如下实现：
1、在通常称为im2col的操作中，输入图像中的局部区域被拉伸成列。 例如，如果输入是[227x227x3],并且要在步幅4中与11x11x3滤波器进行卷积，则我们将在输入中取出[11x11x3]个像素块，并将每个块拉伸为大小为11 11 3 =363.在步长4的输入中迭代该过程给出沿宽度和高度的（227-11）/ 4 + 1 = 55个位置，导致尺寸为[363×3025]的im2col的输出矩阵X_col，其中每列是一个伸展的接受场，总共有55 * 55 = 3025。请注意，由于接收字段重叠，输入卷中的每个数字可能会复制在多个不同的列中。
2、CONV层的权重同样伸展成行。 例如，如果有大小为[11x11x3]的96个滤波器，则这将产生大小为[96 x 363]的矩阵W_row。
3、卷积的结果现在相当于执行一个大的矩阵乘法np.dot（W_row，X_col），它计算每个过滤器和每个接收域位置之间的点积。 在我们的示例中，此操作的输出将为[96 x 3025]，给出每个位置上每个过滤器的点积的输出。
4、结果必须最终重新整理为正确的输出维度[55x55x96]。
这种方法仍然有缺点，它可能使用大量的内存，因为输入卷中的某些值在X_col中被复制多次。然而，好处是有许多非常有效的矩阵乘法实现。相同的im2col思想可以重用以执行池化操作，这将在之后讨论。

反向传播

卷积运算的反向传播（对于数据和权重）也是卷积（但是具有空间翻转的滤波器)。

1x1卷积

有些论文使用了1x1卷积，对于二维的信号，1x1卷积没有任何意义（只是点取向缩放）。 然而，在ConvNets中，情况并非如此，因为我们必须记住，我们操作三维体积，并且过滤器总是延伸到输入卷的整个深度。 例如，如果输入为[32x32x3],则进行1x1卷积将有效地进行三维点积（因为输入深度为3个通道）。

扩张卷积(Dilated convolutions)

池化层

在ConvNet体系结构中，通常在连续Conv层之间定期插入一个Pooling层。 其功能是逐步减少表示的空间大小，以减少网络中的参数和计算量，从而也可以控制过拟合。 汇集层在输入的每个深度层上独立运行，并使用MAX操作在空间上调整其大小。最常见的形式是一个大小为2x2的过滤器的池化层，每个深度切片在宽度和高度均为2，每个深度切片下降2个步长，丢弃75％的激活。在这种情况下，每个MAX操作将占用超过4个数字（一些深度片段中的2×2个区域),其深度维度保持不变。
常用的池化操作是设置F=3，S=2(也叫做重叠池)，更常见的是F=2，S=2。如果F太大的话，破坏性太强就不适用了。

常见的池化方式

出了最大池化，池化单元还可以是其他形式，比如average pooling和L2-norm pooling。average pooling以前常用，但是现在实践证明max pooling的表现更好。
举例如下：

在池层的正向传递期间，通常要跟踪最大激活的索引（有时也称为交换机），以便使得反向传播期间梯度路径是有效的。

池化操作的替代

有一种方法是为了追求简单性：所有卷积网络舍弃pooling 操作，而只支持重复CONV层的架构。为了减少输出的大小，可以在CONV层中使用更大的步幅。已经发现，丢弃池层(Discarding pooling layers)对于训练良好生成模型（如变分自动编码器（VAE）或生成对抗网络（GAN））很重要。

归一化层

实践中归一化层的作用非常有限，往往不会被采用。

全连接层

完全连接层中的神经元与上一层中的所有激活具有完全连接，如常规神经网络所示。 因此，它们的激活可以用矩阵乘法后跟偏移偏移来计算。

转换全连接层到卷积层

全连接层和卷积层的区别就是卷积层只和输入的部分区域相联系。但是，两种层中的神经元都是计算点积，于是实际上它们的函数形式是相同的，因此，将全连接层转换成卷积层是可能的。
1、对于每一个卷积层，都会有一个对应的全连接层和它实现相同的前向函数。它的权重矩阵将是一个大的矩阵，除了某些块（由于本地连接）之外，大部分都是零，其中许多块中的权重相等（由于参数共享）。
2、相反，任何FC层都可以转换为CONV层,例如，K=4096的FC层，其输入尺寸为7×7×512,这样的输入容积可以等效地表示为具有F=7，P = 0，S = 1，K=4096的CONV层。换句话说，我们将滤波器大小设置为输入的大小，因此输出将为1×1×4096，只有一个深度列“适合”输入体积，于是给出与初始FC层相同的结果。

以上两种转换中，实践中最为有用的还是从全连接层转换到卷积层。现在考虑这样一个网络结构：输入为224x224x3,通过5层池化层和一系列卷积层之后将其变为7x7x512的尺寸。在这个例子中，最后通过2层4096的全连接层和最后的有1000个神经元的全连接层计算得分函数，我们可以根据刚刚说的方法把这三层全连接层转换为卷积层。
1、对于第一层，改为用一个F=7的卷积层，输入为7x7x512，实现输出为1x1x4096。
2、第二层使用F=1的卷积层，使得输出仍然为1x1x4096。
3、最后一层仍替换为F=1的卷积层，最后使得输出为1x1x1000。

卷积网络的架构

前面介绍了卷积网络的主要类型的层，包括CONV,POOL,FC，RELU。下面介绍怎么将这些层结构组合成一个完整的卷积神经网络。

Layer Patterns

最常见的卷积神经网络结构是堆砌几个CONV-RELU层，然后紧跟POOL层，重复这个结构直到输出的尺寸变为比较小。比较常见的结构是最后还加入一个全连接层作为输出层，其计算输出(比如得分函数)。最常见的卷积神经网络遵循以下的模式：
INPUT -> [[CONV -> RELU]N -> POOL?]M -> [FC -> RELU]K -> FC
其中表示重复次数,?表示可选，N>=0,M>=0,K>=0，并且通常N<=3，K<3。
实际应用中，通常使用小的过滤器堆叠CONV层，而不是使用一个具有大过滤器的CONV层，这样使我们能够表达更强大的输入特征，并具有较少的参数。当然这也会带来一些缺点，如果我们打算进行反向传播，我们可能需要更多的内存来保存所有的中间CONV层结果。

Layer Sizing Patterns

主要介绍一些关于尺寸的超参数设置技巧。

Input Layer

通常设置为2的倍数。常见的有32，64,96,224,384,512。

Conv Layer

应该使用较小的滤波器尺寸，比如3x3或者5x5，S=1，设置P使得不改变输入尺寸，比如当F=3时，设置P=1。F=5，设置P=2。更一般化就是P=(F-1)/2使得输出尺寸不改变。更大的滤波器尺寸很少使用，通常是放在离输入层很近的位置。

Pool Layer

池化层的目的是进行降采样，通常的做法是使用F=2，S=2，使得输出为原来的1/4，这将会丢弃75%的激活。另一种不太常用的做法是F=3，S=2。更大的尺寸就不推荐了，这通常会导致更差的表现。

CONV层为什么设置S=1？

实践中，S越小结果越好，所以设置S=1。另外，S=1使得我们仅在池化层实现下采样，在卷积层只改变深度。

Padding的作用

padding使得通过卷积层后尺寸不改变，这在实践中效果更好。如果不使用填充，这样输入每通过一个卷积层其尺寸都会减小一点，这样其边界信息会逐步丢失。

内存限制

有时由于内存限制，需要对网络结构进行一些折中。

常见的实例

LeNet
AlexNet
ZF Net
GoogleNet
VGGNet
ResNet

计算的注意事项

构建ConvNet架构时要注意的最大瓶颈是内存瓶颈，GPU是有内存限制的。下面是三个主要的内存开销。
1、中间卷大小：这些是ConvNet每层激活的原始数量，以及它们的梯度（大小相等）。通常，大部分的激活都在ConvNet的早期层（即第一个Conv Layers）上。由于它们需要进行反向传播，因此它们将会保留下来，一个聪明的实现是只有在测试时间才能运行ConvNet，原则上可以通过将当前的激活存储在任何层上，并将以前的激活放在下面的层上。
2、参数大小：它们包括保存网络参数的数字，反向传播过程中的梯度，如果优化使用moemntum，Adagrad或RMSProp，通常也是一个缓存。因此，单独存储参数矢量的存储器通常必须乘以至少3个左右的系数。
3、每个ConvNet实现都必须维护杂项内存，例如图像数据批次，也可能是其扩充版本等。在出现内存不足的情况下，一个通常的做法是减小batch size的大小，因为大多数内存通常被激活所消耗。

参考

1、cs231n 2017 cnn notes
2、cs231n 2017 cnn slides

展开全文 >>

Backpropagation

引言

主要介绍一些关于backpropagation(反向传播)的知识，反向传播主要就是利用chain rule(链式法则)计算关于weights的梯度，通过梯度计算的结果对网络进行梯度下降的优化。这对于我们设计和debug神经网络都很有用处。
值得注意的是，通常情况下我们计算对于W的梯度以便根据梯度下降进行参数更新，但是在一些特殊情况下，我们也有可能计算关于输入x的梯度，目的是解释和可视化神经网络的过程。

概念

当我们使用前馈神经网络接收输入x并产生输出y时，信息通过网络向前流动。输入x提供初始信息，然后传播到每一层的隐藏单元，最后产生输出y。这叫做 前向传播(forward prapagation)。而在训练过程中，前向传播可以持续向前知道计算出代价函数。反向传播算法则允许来自代价函数的信息通过网络向后流动，以便于计算梯度。

简单的解释和举例

实际上，每个变量的导数反映了整个表达式对这个变量的变化的敏感程度。其定义如下：

比较常见的有以下3种函数。


以上这些是针对简单的情况，针对复杂的复合函数的情况，往往需要使用链式法则来求解梯度。

一种比较直观的理解是：反向传播可以看做一组彼此之间通过梯度信号通信的门，每个门可以选择让通过自己的信号增加或者减小，并且可以决定增加或者减小的幅度。最后的目的是通过改变输入，经过这一系列门之后使得总的输出最大或者最小。

模块化操作

在实际计算反向传播的时候，我们可以通过一些模块化的操作使得计算和理解都更为简便直观。
如下面所示的一个例子：

通过将此函数分解为一系列函数的复合：

最后的一个计算过程如下：

可以看出这个流程还是比较复杂，但是通过将其中的一个sigmoid函数模块化之后，我们会得到更加简明的结果。

最后编程实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
w = [2,-3,-3] # assume some random weights and data
x = [-1, -2]
# forward pass
dot = w[0]*x[0] + w[1]*x[1] + w[2]
f = 1.0 / (1 + math.exp(-dot)) # sigmoid function
# backward pass through the neuron (backpropagation)
ddot = (1 - f) * f # gradient on dot variable, using the sigmoid gradient derivation
dx = [w[0] * ddot, w[1] * ddot] # backprop into x
dw = [x[0] * ddot, x[1] * ddot, 1.0 * ddot] # backprop into w
# we're done! we have the gradients on the inputs to the circuit

实践中的一些技巧

1、在实践中，我们需要根据实际情况对整个函数进行拆分，分成便于计算梯度的函数的一个复合。
2、为了反向计算方便，通常在正向计算的时候需要保存一些中间结果，便于反向计算梯度的时候使用它们。
3、前向计算需要使用x,y变量多次，在反向传播的时候应该用+=而不是=来累加结果。

扩展到矢量计算梯度

对矢量计算梯度的方法和上面所提及的并无二致，但是在处理时可能需要加入转置运算以便维数匹配。

计算矩阵相乘的梯度

下面这个例子里面就是根据维数匹配的原则对表达式加入一些转置的操作。

1
2
3
4
5
6
7
8
9
# forward pass
W = np.random.randn(5, 10)
X = np.random.randn(10, 3)
D = W.dot(X)
# now suppose we had the gradient on D from above in the circuit
dD = np.random.randn(*D.shape) # same shape as D
dW = dD.dot(X.T) #.T gives the transpose of the matrix
dX = W.T.dot(dD)

而对于一些一时难以看出梯度表达式的情况，可以利用实际的比较小的矩阵手动演算，根据结果推理出合适的表达式。

参考

1、cs231n 2017 lecture4 slides
2、cs231n 2017 backpropagation notes

展开全文 >>

String、StringBuider and StringBuffer

主要是对Java中的String,StringBuilder和StringBuffer类进行分析对比

结构

String,StringBuilder和StringBuffer都实现了CharSequence接口，用来进行字符串的相关操作，并且都定义为final class，意味着都不能够被继承，并且内部都是用char数组实现的。这里有一个显著的区别是：String的 char数组被定义为 final，意味着一旦确定是不可改变的，我们每当对字符串进行一些操作，比如得到substring,toLowerCase等时，最后都会new一个新的String对象；而 StringBuilder和StringBuffer的内部的char数组没有final修饰，它们都继承自AbstractStringBuilder，内部的char数组可以随时修改，动态扩容。其中StringBuilder和StringBuffer的一个显著区别是：StringBuffer的很多方法会用synchronized修饰，意味着StringBuffer是线程安全的，适合在多线程的时候使用。除了这个区别，StringBuilder和StringBuffer的其它一些方法基本上是一致的，感觉StringBuffer其实就是StringBuilder的一个多线程版本。

一些简单的使用建议

1、当不需要改变字符串的内容时，尽量使用String类。因为它是不可变的。
2、当需要改变字符串的内容，比如说对大量字符串进行一些拼接操作，这时候如果用String的话就比较麻烦，每次都会生成一个新的String，这将浪费大量的内存空间，并且需要多次垃圾回收操作，严重影响速度。一般的情况下是选用StringBuilder类，可以原地进行一些操作，比较方便快速。多线程情况下选择线程安全的StringBuffer类。在不考虑多线程的情况下，StringBuilder的效率是比StringBuffer高的。

性能测试

简单测试了String,StringBuilder和StringBuffer的字符串拼接效率。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Main {
    public static void main(String[] args) {
        int N = 100000;
        long t;
        {
            String s=new String();
            t=System.currentTimeMillis();
            for (int i=N;i-->0;){
                s+="Test";
            }
            System.out.println("String Time:"+(System.currentTimeMillis()-t)+"ms");
        }
        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("Test");
            }
            System.out.println("StringBuffer Time:"+(System.currentTimeMillis() - t)+"ms");
        }
        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("Test");
            }
            System.out.println("StringBuilder Time:"+(System.currentTimeMillis() - t)+"ms");
        }
    }
}

运行结果：

拼接空字符串的结果：

参考资料

stackoverflow question

展开全文 >>

Image Classfication(kNN and Linear Classfication)

主要是对图像分类的流程的总体介绍,主要介绍了kNN和Linear Classfication算法。和cs231n的 lecture_2 和 lecture_3对应。

图像分类的几大挑战

1、Viewpoint Variation:相机移动会造成像素点发生改变。
2、Illumination:同一物体在不同光照条件下差别也比较大。
3、Deformation:同一物体的不同形变也会给分类造成较大影响。
4、Occlusion:遮挡问题，有时只能看见物体局部，难以分辨。
5、Background Clutter:背景干扰，比如动物保护色等让人难以分辨。
6、Intraclass Variation:同一物种个体之间差异也大。

图像分类的任务

图像分类的任务就是输入一幅图像，返回其分类结果。此类任务是难以通过显示编程
制定一些规则来进行的。

1
2
3
def classify_image(image):
    #do something
    return label

具体分类方法

较为传统的方法

通过边缘检测，角点检测等方法找出一些特征，然后对特征进行一些统计得出分类结果。

数据驱动的方法(Data-Driven Approach)

大致的流程就是：
1、准备图像和标签一一对应的数据集。
2、通过机器学习的方法去训练一个分类的模型。
3、在另外的数据上去检验这个模型的准确性。

1
2
3
4
5
6
7
8
9
#train a model
def train(images,labels):
    #Machine Learning
    return model
#predict the label
def predict(model,test_images):
    #Use trained model to predict labels
    return test_labels

Nearest Neighbor（最近邻法）

1、在训练阶段只是将图片和标签载入内存，不做任何额外操作。
2、预测阶段，将待预测图片和之前载入的图片逐一比较，选取和待预测图片最相似的训练图片的标签作为预测结果。

如何判断相似性？
L1 Distance or L2 Distance or others?
这里简单使用 L1 distance

优点：思想简单，编程实现容易。
缺点：准确率较低，而且训练时只是读入数据，测试时需要逐一比较，耗时与数据集大小成线性关系，与我们的初衷不符。

K-Nearest Neighbors(K最近邻法)

其基本思想与 Nearest Neighbor一致，只是我们需要保留前k个最相似的图片的结果，然后在这k个结果里面做一个决策。
这里就会出现两个问题：
1、如何选取合适的k值使得预测结果更准确？
2、如何选取distance的算法使得预测结果更准确？
其实这些都叫做 hyperparameters(超参数)，需要我们预先设置。

如何设置超参数？

方法1：选取超参数使得其在训练集上的效果最好。
这个方法存在的一个显著问题就是：k=1总是能够使得其在训练集上的效果最好。这种方法显然不可取。
方法2：将数据集分为训练集和测试集两选取超参数使得在测试集上的效果最好这种方法避免了前一个问题，但是又带来了一个新问题，就是它不能预判断算法在新的数据集上的表现情况。
方法3：分为训练集、验证集和测试集，以验证集选取超参数，在测试集上验证。这种方法比前两种方法都好一点。有效避免了之前的问题。
方法4：交叉验证。将数据集分为n份，分别以其中一份作为验证集，其他作为训练集，最后得到n个结果，再对结果做一个平均。这种方法是目前来说最好的。这种方法主要还是用于训练样本较小的情况下，对于较大的训练样本，其实方法3就能达到较好效果，用该方法会浪费不少时间。

方法的缺陷

实际上k-Nearest Neighbor这种方法从来没有被实际采用过，主要有以下几个原因：
1、正如上面提及过的，时间效率太低。
2、通过像素差值判断相似性本身就有很大的问题。

总结

1、在图像分类问题上，我们在训练集上训练，之后在测试集上验证结果。对于其他的机器学习问题也是如此。
2、距离度量方式和K的都是超参数，需要我们事先确定。
3、用验证集确定超参数，最后在测试集上测试结果。

Linear Classification(线性分类器)

这种方法将比之前的方法都更有效，并且可以以此来引入之后的Neural Networks(神经网络)和Convolutional Neural Networks(卷积神经网络)。主要由两部分组成：
1、score function 实现从原始图像数据到各个标签的得分的一个映射。
2、loss function 用来定量比较分析预测的得分和实际的label的差距。
我们的最终目的就是通过优化，使得loss function最小，最后确定的score function 的参数作为最终的模型的参数，用来预测label。

Score function

f(xi,W,b)=W*xi+b

注意事项

1、W*xi 的结果是一个向量，每个元素代表对应标签的一个预测得分。
2、我们的目标就是通过训练确定W和b，使得预测结果和真实结果最为接近。也就是使得对于一个输入图像xi，我们要使得其正确分类的得分大于错误分类的得分。
3、这种方法的好处在于训练集只是用于训练确定参数W和b，我们最后只需要保留W，b的值。之后对于每一幅输入图像，只需要带入确定的W和b值即可预测出其分类结果。所以这种方法的时间效率远大于之前的NN和kNN算法。
4、实际上，之后的神经网络和卷积神经网络的方法和线性分类器的思想是一致的，只是score function 和 loss function 是另外的函数形式。

解释线性分类器

线性分类器实际上就是计算一个图像各个像素各个通道的加权和。加权的结果取决于我们设置的W，b的值。

将图像作为高维点分析

一幅32x32x3的图像可以被拉伸为1x3072的高维点来表示。所以数据集中的图像可以看做一系列高维点。因为我们定义每个分类的score是所有像素点的加权和，实际上每个分类的分数就是这个高维点的线性函数。虽然无法可视化3072维的数据，但是当我们把3072维压缩成2维，就可以尝试着可视化线性分类器的操作。

将线性分类器解释为模板匹配

这种解释将W的每一行看做是对应的分类的一个模板，也就是对应的分类的一个原型。实际上每个分类的score就是将输入图像与模板进行比较(这里是通过点积的形式)，最后看输入图像和哪个模板最匹配。
这其实和最近邻算法类似，主要区别在：
1、最近邻算法是将输入图像和每幅图像作比较，而线性分类器是将输入图像和模板图像相比较。
2、最近邻算法通过L1或者L2距离判断相似性，线性分类器通过点积判断相似性。

下面是根据CIFAR-10训练得到的模板图像

处理b参数的小技巧

实际上我们可以通过对W 矩阵增加1列，对xi增加1行的方法，将
f(xi,W,b)=Wxi+b ——> f(xi,W)=Wxi
这样就只用训练一个参数W。
如下图所示：

图像预处理

在应用中常常需要对图像数据进行预处理，比如
[0,255]->[-127,127]->[-1,1],关键在于让零值居中，使得数据集中。

Loss Function(损失函数)

损失函数的作用是来评价在训练集上分类结果的好坏，当分类结果接近真实结果时，损失函数自然就小，反之则大。损失函数有多种计算方法，下面分别从阐述。

Multiclass Support Vector Machine loss

设置 SVM loss的目的是为了让正确分类的得分与错误分类的得分至少相差某一个确定的δ,
简单来说，其计算公式如下：

更多细节可以参考
cs231n spring2017 linear_classify notes

其实概括来说就是SVM loss 希望让正确分类的得分大于错误分类的得分至少δ，如果没有 达到要求，那么我们就计算一个loss,如果达到要求，那么loss为0。针对线性分类器，我们有如下的计算SVM loss的公式：

其实形如 max(0,-)这样的损失函数叫做 hinge loss,并且指数项不一定是1次，有时为了让错误结果更明显，可能用指数项为2次得到的效果会更好。具体使用哪种可以通过前面提及的交叉验证来确定。确定了损失函数之后，接下来的工作就是找到一种优化的方法，使得loss尽可能小，然后确定W。

上面提及的SVM loss还存在一个问题：假设我们有一个数据集和W使得对于每一个图像i都满足Li=0,那么显然W 不是唯一的。因为这样的话 λW(λ>1) 也能使得Li=0。那这样我们该选择哪个W作为最终结果呢？这样对于正确的分类没有影响，但是对于错误的分类，就会将loss放大λ倍。

为了解决以上的问题，引入了一个 regularization penalty(正则惩罚项) R(W)。通常的做法是利用L2 norm 来限制W中每个元素的大小。
如下所示：

注意这里的R(W)只和W有关，而和数据集无关。这样SVM loss就有 data loss和 regularization loss 两部分组成：

在线性分类器中，其形式如下：

λ作为超参数通常也是要通过交叉验证来确定。

引入正则惩罚项的一个最大的好处是增强模型的泛化能力，让最终的结果尽可能受到更多参数的影响，能够减小过拟合的情况。另外值得注意的是，当引入正则惩罚之后，Loss就不可能为0了，因为如果Loss为0，那么意味着W=0，那将毫无意义。接下来我们将要考虑的就是通过什么方法来使得loss尽可能小。

如何确定超参数δ，实际上我们可以简单设置δ为1。其实δ和λ对于loss的影响是一致的，所以我们其实只需要确定λ就好。

Softmax loss

这是另一种计算损失函数的方法，和SVM 计算每个分类得分的方法不同，Softmax分类器是对属于每个分类的可能性做评估。
在这里，将每个分类的得分转化为属于这个分类的概率，并且用 cross-entropy loss(交叉熵损失)代替hinge loss。
计算形式如下：

其中softmax function 形如以下：

其中的一些理论不再阐述。
实践的技巧：由于要计算指数项，除以大数可能造成数值不稳定，所以需要归一化的技巧，可以如下操作：

比较常用的方法是设置

1
2
3
4
5
6
f = np.array([123, 456, 789]) # example with 3 classes and each having large scores
p = np.exp(f) / np.sum(np.exp(f)) # Bad: Numeric problem, potential blowup
# instead: first shift the values of f so that the highest number is 0:
f -= np.max(f) # f becomes [-666, -333, 0]
p = np.exp(f) / np.sum(np.exp(f)) # safe to do, gives the correct answer
SVM loss 和 Softmax loss 的比较

具体分析见
cs231n spring2017 linear_classify notes

Optimization(优化)

确定了score function和 loss function之后，我们要做的就是通过优化使得 loss function 尽可能小，然后确定 score function的参数。不仅是针对线性分类器，其他分类方法的整个流程也是一样的，只是score function 和 loss function可能有所不同。
主要有如下一些策略：

Random Search(随机搜索)

顾名思义就是随机设置W的数值，每次记录loss,迭代若干次，找出使得loss最小的结果。显然，迭代次数越多，能够尝试的参数就会越多，就越有可能找出更为准确的参数，但是永远不可能找出所有的结果。并且我们是盲目地找结果，效率较低，这显然过于笨拙。
但是这种方法也能给我们一些启示：我们能不能找到一种方法，从一个随机的参数W开始，进行优化，每次迭代使得loss降低一些？这给下一个策略提供了思路。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# assume X_train is the data where each column is an example (e.g. 3073 x 50,000)
# assume Y_train are the labels (e.g. 1D array of 50,000)
# assume the function L evaluates the loss function
bestloss = float("inf") # Python assigns the highest possible float value
for num in xrange(1000):
  W = np.random.randn(10, 3073) * 0.0001 # generate random parameters
  loss = L(X_train, Y_train, W) # get the loss over the entire training set
  if loss < bestloss: # keep track of the best solution
    bestloss = loss
    bestW = W
  print 'in attempt %d the loss was %f, best %f' % (num, loss, bestloss)
# prints:
# in attempt 0 the loss was 9.401632, best 9.401632
# in attempt 1 the loss was 8.959668, best 8.959668
# in attempt 2 the loss was 9.044034, best 8.959668
# in attempt 3 the loss was 9.278948, best 8.959668
# in attempt 4 the loss was 8.857370, best 8.857370
# in attempt 5 the loss was 8.943151, best 8.857370
# in attempt 6 the loss was 8.605604, best 8.605604
# ... (trunctated: continues for 1000 lines)

这种方法的思想就是随机给W设置一个初始值，然后在此基础上给一个增量变为W+δW,比较两处的loss,如果增加后更小，则更新W，否则维持原状。这种方法相比前一种方法少了盲目性，效果会好一些，但是计算量仍旧很大。

1
2
3
4
5
6
7
8
9
10
W = np.random.randn(10, 3073) * 0.001 # generate random starting W
bestloss = float("inf")
for i in xrange(1000):
  step_size = 0.0001
  Wtry = W + np.random.randn(10, 3073) * step_size
  loss = L(Xtr_cols, Ytr, Wtry)
  if loss < bestloss:
    W = Wtry
    bestloss = loss
  print 'iter %d loss is %f' % (i, bestloss)
Following the Gradient

第二种方法虽然效率比第一种稍高，但是在选择δW的时候还是随机的，效率也较低，而实际上是可以有一定的策略选择δW的。比如可以通过计算梯度，沿着梯度小于0的方向就能使得loss变小。

如何计算梯度

从以上分析看出，前两种优化策略都显得盲目，效率较低，而根据梯度来进行优化显然更为合理。那么梯度怎么去计算呢？主要有两种方法：1、numerical gradient,通过定义去计算梯度，其优点是思想简单，缺点是速度慢并且只是近似值，精度取决于δ的大小。2、analytic gradient，根据分析得出偏导数的表达式计算，其优点是快速准确，缺点就是容易出错。接下来分别介绍这两种算法。

Numerical Gradient
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def eval_numerical_gradient(f, x):
  """ 
  a naive implementation of numerical gradient of f at x 
  - f should be a function that takes a single argument
  - x is the point (numpy array) to evaluate the gradient at
  """ 
  fx = f(x) # evaluate function value at original point
  grad = np.zeros(x.shape)
  h = 0.00001
  # iterate over all indexes in x
  it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
  while not it.finished:
    # evaluate function at x+h
    ix = it.multi_index
    old_value = x[ix]
    x[ix] = old_value + h # increment by h
    fxh = f(x) # evalute f(x + h)
    x[ix] = old_value # restore to previous value (very important!)
    # compute the partial derivative
    grad[ix] = (fxh - fx) / h # the slope
    it.iternext() # step to next dimension
  return grad

实际使用中常用的公式是 [f(x+h)-f(x-h)]/2h
在更新W的时候，是沿着负梯度的方向更新的，这样能够确保每次使得loss在降低。
选择合适的step size 很重要，也就是 learning rate(学习率)，这也是机器学习中的一个超参数。learning rate过低，使得更新缓慢，时间效率低，而learning rate如果过高，可能使得overstep(即越过最低点到达一个很糟糕的地方)。
更新梯度与参数数量成线性关系，对于30730个参数，我们需要对30731个参数验证梯度，最后只在1个参数上更新，对于参数少的情况着无关紧要，但是当参数特别多时，这就比较麻烦了，所以需要更好的办法。

Computing the gradient analytically with Calculus

这种方法因为有确定的公式，所以计算速度很快，但是容易出错。常常会将这两种方法进行比较以验证梯度计算方法的正确性，这叫做 gradient check(梯度检查)。不同的loss function自然有不同的梯度表达式。

Gradient Descent

计算出梯度之后，我们就将沿着梯度下降的方向更新参数。这就叫做Gradient Descent(梯度下降)。

1
2
3
4
5
# Vanilla Gradient Descent
while True:
  weights_grad = evaluate_gradient(loss_fun, data, weights)
  weights += - step_size * weights_grad # perform parameter update

之后可能会有其他方法来优化这一过程，但是其核心思想都是梯度下降。

Mini-batch gradient descent

在训练集比较大的情况下，如果每执行一次单个参数的更新就对每个数据的loss进行计算，显得效率太低。常用的解决方法是计算批量数据之间的梯度，如下面所示：

1
2
3
4
5
6
# Vanilla Minibatch Gradient Descent
while True:
  data_batch = sample_training_data(data, 256) # sample 256 examples
  weights_grad = evaluate_gradient(loss_fun, data_batch, weights)
  weights += - step_size * weights_grad # perform parameter update

实际上，批量数据的梯度是完整数据的梯度的良好近似，用批量数据的梯度代替完整数据的梯度进行快速计算，实现参数的快速更新，在实践中往往能够达到更好的结果。这算是时间效率和精度的一个折中方案。

Stochastic Gradient Descent(SGD)

这是当batch size为1时的特例，不过在实践中很少用。batch的大小是一个超参数，但是实践中很少用交叉验证的方法去确定它。这个参数的设置通常是基于内存限制或者确定为某些值，通常为2的幂。

整个优化的流程大概如下所示：

参考资料

1、cs231n spring 2017 classification notes
2、cs231n spring 2017 linear_classify_1 notes
3、cs231n spring 2017 linear_classify_2 notes
3、cs231n spring 2017 lecture2 slides
4、cs231n spring 2017 lecture3 slides

展开全文 >>

cs231n assignment1

k-Nearest Neighbor classifier

compute distances

compute distances with two loops

思想很简单，但是耗时较长，代码如下。

1
2
3
4
5
6
7
8
9
10
import numpy as np
def compute_distances_two_loops(X,X_train):
    assert(X.shape[1]==X_train.shape[1])
    num_test=X.shape[0]
    num_train=X_train.shape[0]
    dists=np.zeros((num_test,num_train))
    for i in range(num_test):
        for j in range(num_train):
            dists[i][j]=np.linalg.norm(X[i,:]-X_train[j,:])
    return dists

compute distances with one loop

利用numpy.sum代替一个循环，但是在测试中比第一种方法更耗时。

1
2
3
4
5
6
7
8
def compute_distances_one_loop(X,X_train):
    assert(X.shape[1]==X_train.shape[1])
    num_test=X.shape[0]
    num_train=X_train.shape[0]
    dists=np.zeros((num_test,num_train))
    for i in range(num_test):
        dists[i,:]=np.linalg.norm(X[i,:]-X_train,axis=1)
    return dists

compute distances with no loop

利用矩阵运算代替循环，用时极短但是不容易理解。

1
2
3
4
5
6
7
8
9
10
def compute_distances_no_loop(X,X_train):
    assert(X.shape[1]==X_train.shape[1])
    num_test=X.shape[0]
    num_train=X_train.shape[0]
    dists=np.zeros((num_test,num_train))
    M=X.dot(X_train.T)
    te=np.square(X).sum(axis=1)
    tr=np.square(X_train).sum(axis=1)
    dists = np.sqrt(-2*M+tr+np.matrix(te).T)
    return dists

Cross-validation

Split up the training data into folds

1
2
y_train_ = y_train.reshape(-1, 1)
X_train_folds , y_train_folds = np.array_split(X_train,num_folds),p.array_split(y_train_,num_folds)

Perform k-fold cross validation

1
2
3
4
5
6
7
8
9
10
11
12
13
for k_ in k_choices:
    k_to_accuracies.setdefault(k_, [])
for i in range(num_folds):
    classifier = KNearestNeighbor()
    X_val_train = np.vstack(X_train_folds[0:i] + X_train_folds[i+1:])
    y_val_train = np.vstack(y_train_folds[0:i] + y_train_folds[i+1:])
    y_val_train = y_val_train[:,0]
    classifier.train(X_val_train, y_val_train)
    for k_ in k_choices:
        y_val_pred = classifier.predict(X_train_folds[i], k=k_)
        num_correct = np.sum(y_val_pred == y_train_folds[i][:,0])
        accuracy = float(num_correct) / len(y_val_pred)
        k_to_accuracies[k_] = k_to_accuracies[k_] + [accuracy]

参考

完整代码
Assignment1

展开全文 >>

How to use git

创建本地仓库并上传代码到GitHub

1）新建Text文件夹作为仓库根目录（文件夹名字随意命名） 2）将需要上传的代码文件加入到Text根目录
3）在根目录下建立仓库
使用命令行或Git Bash，输入下面命令：先进入到Text根目录下，再输入git init（初始化一个仓库） 4）将所有文件添加到仓库
使用命令行或Git Bash，输入下面命令：git add .
5）提交
使用命令行或Git Bash，输入下面命令：git commit -m “CommitInfo” 6）添加源到GitHub
git remote add origin git@github.com:YourName/YourRepositroy.git
*7）上传源到GitHub
git push -u origin master

IDEA创建项目并push到Github

配置方式

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true