神经网络计算过程

1.导入模块，生成模拟数据集
import
常量定义
生成数据集

2.前向传播：定义输入、参数和输出
x= y_=
w1= w2=
b= y=

3.反向传播：定义损失函数，反向传播方法
loss=
train_step=

4.生成会话，训练STEPS轮

with ft.Session() as sess:
	Init_op=tf.global_variables_initializer()
	sess.run(init_op)
	STEPS=3000
	for i in range(STEPS):
		start=
		end=
		sess.run(train_step, feed_dict:)

---

反向传播训练方法： 以减小 loss 值为优化目标 ，有梯度下降 、 adam优化器等优化方法。

# 随机梯度下降算法：
# 使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数。
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

#自适应学习率的优化算法
#随机梯度下降算法保持单一的学习率更新所有的参数，学习率在训练过程中并不会改变。
#而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率。
train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)

损失函数（loss）：
1.均方误差MSE（回归问题）

loss_mse = tf.reduce_mean(tf.square(y_ - y))

2.交叉熵（分类问题）

# 计算公式
ce=-tf.reduce_sum(p * tf.log(tf.clip_by_value(q, 1e-12, 1.0))) 

#常见的交叉熵函数
tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=labels)
#适用：每个类别相互独立但互不排斥的情况：例如一幅图可以同时包含一条狗和一只大象。output不是一个数，而是一个batch中每个样本的loss,所以一般配合`tf.reduce_mean(loss)`使用。

tf.nn.softmax_cross_entropy_with_logits(labels=None, logits=None)
#适用：每个类别相互独立且排斥的情况，一幅图只能属于一类，而不能同时包含一条狗和一只大象。

学习率 learning_rate：
决定每次参数更新的幅度，一般选择 0.01 、 0.001。

#coding utf-8
#导入模块，生成模拟数据集
import tensorflow as tf
import numpy as np
import sklearn.datasets as datasets
import matplotlib.pyplot as mp
BATCH_SIZE = 32 #批次，一批8个样本

X, Y = datasets.make_moons(200, noise=0.10) #获取输出集和输入集
Y = np.array(np.column_stack((Y, ~Y+2)), dtype='f4') #转换输入集从（n,）(n,2)
print(Y)

#定义神经网络的输入、参数和输出，定义向前传播过程
x = tf.placeholder(tf.float32, shape=(None,2), name='x')
y = tf.placeholder(tf.float32, shape=(None,2), name='y')

w1 = tf.Variable(tf.random_normal((2,3),stddev=1,seed=1))
b1 = tf.Variable(tf.random_normal((3,),stddev=1,seed=1))
w2 = tf.Variable(tf.random_normal((3,2),stddev=1,seed=1))
b2 = tf.Variable(tf.random_normal((2,),stddev=1,seed=1))

l1 = tf.nn.sigmoid(tf.add(tf.matmul(x,w1), b1))
y_ = tf.add(tf.matmul(l1,w2), b2)

#定义损失函数及反向传播方法
loss = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=y_))
train_step = tf.train.GradientDescentOptimizer(0.0005).minimize(loss)
#train_step=tf.train.AdamOptimizer(0.001).minimize(loss)

#生成会话，训练STEPS轮
with tf.Session() as sess:
    # 初始化参数
    init_op=tf.global_variables_initializer()
    sess.run(init_op)

    #训练模型
    STEPS = 30000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32 # 定义起始下标
        end = start + BATCH_SIZE    # 定义结束下标
        sess.run(train_step,feed_dict={x:X[start:end], y:Y[start:end]})
        if i % 500 ==0:
            total_loss = sess.run(loss,feed_dict={x:X, y:Y})
            print("After %d training steps, loss on all data is %g"%(i,total_loss))

    pred_y = sess.run(y_, feed_dict={x:X})
    pred_y = np.piecewise(pred_y, [pred_y<0, pred_y>0], [0, 1])

    l, r = X[:, 0].min() - 1, X[:, 0].max() + 1
    b, t = X[:, 1].min() - 1, X[:, 1].max() + 1
    n = 500
    grid_x, grid_y = np.meshgrid(np.linspace(l, r, n), np.linspace(b, t, n))
    samples = np.column_stack((grid_x.ravel(), grid_y.ravel()))

    grid_z = sess.run(y_, feed_dict={x:samples})
    grid_z = grid_z.reshape(-1, 2)[:,0]
    grid_z = np.piecewise(grid_z, [grid_z<0, grid_z>0], [0, 1])
    grid_z = grid_z.reshape(grid_x.shape)
    mp.figure('Logistic Classification', facecolor='lightgray')
    mp.title('Logistic Classification', fontsize=20)
    mp.xlabel('x', fontsize=14)
    mp.ylabel('y', fontsize=14)
    mp.tick_params(labelsize=10)
    mp.pcolormesh(grid_x, grid_y, grid_z, cmap='gray')
    mp.scatter(X[:, 0], X[:, 1], c=Y[:,0], cmap='brg', s=80)
    mp.show()