上一篇文章讲到了神经网络分类边界的一些问题。这次再来探讨一下，对于非线性数据，神经网络的分类边界能够达到什么效果。已证明：只需一个包含足够多神经元的隐层，多层前馈网络就能以任意精度逼近任意复杂度的连续函数。
为了便于画出分类边界，这里采用Feature只有2维的二分类数据。简单起见，就采用sinx来随机生成数据好了。[微笑]
用sinx随机生成500个数据，根据数据在曲线的两端将其分成两个类别，数据分布图如下：

用sinx随机生成500个数据

仍然采用TensorFlow来实现一个简单的3层神经网络，将隐藏结点个数设置为20，随着网络参数的更新分类边界的变化如下：

第10000轮

第30000轮

第50000轮

随着迭代次数的增加，曲线的拟合越来越接近真实边界。
将隐藏层个数设置为500，第50000轮的结果如下：

第50000轮

似乎跟上面的图没有太大的区别。然而，太复杂的结构可能就会引起over-fitting等问题，而且上面隐层结点个数从20变到500后，训练时间明显有所增加。相同的配置下迭代50000次，2个隐层结点耗时26秒，20个隐层结点耗时32秒，而500个隐层结点耗时250秒。

TensorFlow训练code

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 = 500 # 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.loadtxt('data-sinx-x.txt')
y_data=np.loadtxt('data-sinx-y.txt')
# 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.5).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
N = 50000
for i in range(N):
    # training train_step 和 loss 都是由 placeholder 定义的运算，所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 10000 == 0:    
        print(i)
        #print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
        #print(sess.run(weights), sess.run(biases))
        w = sess.run(weights)
        b = sess.run(biases)
        w1 = np.transpose(w['h1'])
        b1 = b['b1']
        w2 = np.transpose(w['out'])
        b2 = b['out']
        np.savetxt("w1_"+ str(i) + ".txt", w1)
        np.savetxt("b1_"+ str(i) + ".txt", b1)
        np.savetxt("w2_"+ str(i) + ".txt", w2)
        np.savetxt("b2_"+ str(i) + ".txt", b2)

w = sess.run(weights)
b = sess.run(biases)
w1 = np.transpose(w['h1'])
b1 = b['b1']
w2 = np.transpose(w['out'])
b2 = b['out']
np.savetxt("w1_"+ str(N) + ".txt", w1)
np.savetxt("b1_"+ str(N) + ".txt", b1)
np.savetxt("w2_"+ str(N) + ".txt", w2)
np.savetxt("b2_"+ str(N) + ".txt", b2)

MATLAB画图code

function sinxborder()
    load data-sinx.txt
    a = data_sinx(:,1);
    b = data_sinx(:,2);
    c = data_sinx(:,3);
    
%     syms x y
%     h = ezplot('sin(x)-y');
%     set(h,'Color','red')
    
    ezplot(nn(50000));
    hold on
    scatter(a,b,'filled', 'cdata', c);
end

function eq = nn(i)
    syms x y
    X = [x; y];
    W1 = load(['data/w1_', num2str(i), '.txt']);
    b1 = load(['data/b1_', num2str(i), '.txt']);
    W2 = load(['data/w2_', num2str(i), '.txt']);
    b2 = load(['data/b2_', num2str(i), '.txt']);
    
    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