读西瓜书神经网络的一些思考

最近拜读西瓜教授的西瓜书，读到神经网络章节的时候，看到了一个神奇的现象。书中，画出了一个神经网络迭代25次、50次和100次分别得到的分类边界图，令人惊讶的是分类边界在给定范围内都是直线！一直以来，对神经网络分类边界的认识是很模糊的，潜意识觉得应该是一个很复杂且直观无法解释的东西。（呵呵，对线性可分数据似乎也不需要多复杂的分类面吼）本能反应是，我应该把这个分类边界算一个，看看是个什么函数。

• 书本上的数据和图如下

令最上面一层两个节点的输出相等，可以得到如下公式（由于只是判断相等，最后一层省去Sigmoid函数运算）：
这么复杂的一个公式，局部作用域竟然是一条直线，有点不可思议，还是画出来看看。

第25轮

还真的几乎是一条直线！！不过新的问题来了，这个图貌似和书本上第25轮迭代时误分了3个样本的图很不一样，这个图中明显各个类别的样本都乖乖的待在自己该待的那一侧。
下面分别看一下第50次迭代和第100次迭代得到的模型参数画出来的图是什么样。

第50轮

第100轮

感觉这三个图的顺序似乎颠倒了，出现这个结果，首先想到是不是哪里出问题了呢。

• 首先，验证公式和模型参数都是不是正确的。然而，以两种不同的方式将公式的图像画出来，是一模一样的，见附录的代码。说明公式和参数这里基本没有问题。
  两种方式分别为：
• 手动计算公式如上文

• 以
  

  $$)的形式用code来计算

• 那接下来，自己用相同的样本来训练网络，画出其迭代过程中的图形变化看是否也是这种情况。既然最近TensorFlow这么火，就趁此机会好好利用一把。用TensorFlow搭建的神经网络迭代过程中的分类边界的变化情况如下。学习率设置为0.1时，貌似迭代大概1000次才起效果。经本人实践，迭代10000次的时候，直线就明显在两类数据的正中间了。训练过程也是很坎坷了，试了几次迭代次数设为1000，第1000轮迭代的时候分类面却差强人意，不由得有点灰心丧气，感觉对神经网络的认知有很大的偏差。把迭代次数调至10000次后，终于看到了合理的分类边界。再重复进行实验，却发现1000次也能基本训练出一个合格的分类面，这个过程真是有趣又无解。

第250轮

第500轮

第1000轮

第250轮的图中没有曲线可能是因为曲线不在这个范围中，但是我并没有设置画图的取值范围，难道有一个默认取值？这个地方还有待分析。
由此来看，这个画图的过程应该是没有什么问题。或许是理解错书上的分类机制了？还是周老师给的参数？？？看来得找个时间跟周老师好好谈一谈。[奸笑]

PS：

MATLAB作图Code

function ezplotAndscatter()  
    syms x y 
%     eq = exp(0.31*x+0.32*y+0.1)+ 3.64*exp(0.66*x + 0.58*y + 0.06) - 4.16*exp(-0.35*x-0.26*y+0.04) - 1.52;
%     ezplot(eq);
    ezplot(nn);
    hold on
    
    a = [0, 1, 1, 0, 2];
    b = [0, 0, 1, 2, 2];
    c = [1, -1, -1, -1, -1];
    scatter(a,b,'filled', 'cdata', c);
end

function eq = nn()
    syms x y
    X = [x; y];
    %%%%%%% Data from ML book
%     %%%%%%% Iter 25
%     W1 = [-0.66 -0.58; 0.35 0.26];
%     b1 = [-0.06; -0.04];
%     W2 = [0.63 -0.34; -0.66 0.32];
%     b2 = [-0.11; 0.14];
%     %%%%%%% Iter 50
%     W1 = [-1.56 -1.4; 1.3 1.11];
%     b1 = [-0.96; 0.53];
%     W2 = [2.0 -1.68; -2.02 1.65];
%     b2 = [-0.49; 0.51];
%     %%%%%% Iter 100
%     W1 = [-1.5 -2.6; 1.36 2.11];
%     b1 = [-2.27; 1.72];
%     W2 = [3.3 -2.8; -3.33 2.77];
%     b2 = [-0.53; 0.56];

    %%%%%%% Data from TensorFlow Result
%     %%%%%%% Iter 250
%     W1=[-1.26210248, -0.25560322; -0.3448638, -1.05593634];
%     b1=[-1.71526241; -0.26877293];
%     W2=[-0.00534603, 0.66253644; -0.56399935, -1.31708527];
%     b2=[-1.31086206; 1.47235668];
%     %%%%%% Iter 500
%     W1=[-1.29343784, -0.31103003; -0.77500188, -1.32072091];
%     b1=[-1.62698305; 0.12957691];
%     W2=[0.1474047, 1.09768057; -0.71989417, -1.74458826];
%     b2=[-1.42118454; 1.55051541];
    %%%%%%% Iter 1000
    W1=[-1.40092099, -0.46792907; -1.99782729, -1.86098731];
    b1=[-1.34137416; 1.03618503];
    W2=[0.49490803, 2.38475251; -1.02381837, -2.8431468];
    b2=[-1.66594923; 1.86549616];
    
    Ksi = sigmoid(W1*X + b1);
%     O = sigmoid(W2*Ksi + b2);
    O = W2*Ksi + b2;
    
    eq = O(1,1) - O(2,1);
end

function A = sigmoid(x)
    A = 1./(1+exp(-x));
end

TensorFlow训练神经网络

import numpy as np
import tensorflow as tf

# Parameters  
learning_rate = 0.1  
batch_size = 100  
display_step = 1  
#model_path = "/home/lei/TensorFlow-Examples-master/examples/4_Utils/model.ckpt"  
  
# Network Parameters  
n_hidden_1 = 2 # 1st layer number of features  
n_input = 2 # MNIST data input (img shape: 28*28)  
n_classes = 2 # MNIST total classes (0-9 digits)
  
# tf Graph input  
xs = tf.placeholder("float", [None, n_input])  
ys = tf.placeholder("float", [None, n_classes])  
  
  
# Create model  
def multilayer_perceptron(x, weights, biases):  
    # Hidden layer with RELU activation  
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])  
    layer_1 = tf.sigmoid(layer_1)  
    # Output layer with linear activation  
    out_layer = tf.add(tf.matmul(layer_1, weights['out']), biases['out'])  
    out_layer = tf.sigmoid(out_layer)  
    return out_layer  
  
# Store layers weight & bias  
weights = {  
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1])),   
    'out': tf.Variable(tf.random_normal([n_hidden_1, n_classes]))  
}  
biases = {  
    'b1': tf.Variable(tf.random_normal([n_hidden_1])),  
    'out': tf.Variable(tf.random_normal([n_classes]))  
}  
  
# Construct model  
prediction = multilayer_perceptron(xs, weights, biases)  


x_data = np.array([[0,0],[1,0],[1,1],[0,2],[2,2]])
y_data = np.array([[1, 0],[0, 1],[0, 1],[0, 1],[0,1]])
# x_data = np.linspace(-1,1,300)[:, np.newaxis]
# noise = np.random.normal(0, 0.05, x_data.shape)
# y_data = np.square(x_data) - 0.5 + noise

# 4.定义 loss 表达式
# the error between prediciton and real data    
loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
                     reduction_indices=[1]))

# 5.选择 optimizer 使 loss 达到最小                   
# 这一行定义了用什么方式去减少 loss，学习率是 0.1       
train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)


# important step 对所有变量进行初始化
# init = tf.initialize_all_variables()
init = tf.global_variables_initializer()
sess = tf.Session()
# 上面定义的都没有运算，直到 sess.run 才会开始运算
sess.run(init)

# 迭代 1000 次学习，sess.run optimizer
for i in range(1000):
    # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 250 == 0:    
        print(i)
        #print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
        print(sess.run(weights), sess.run(biases))

print(sess.run(weights), sess.run(biases))