神经网络的模块化

前向传播就是搭建网络，设计网络结构 forward.py

def forward(x,regularizer): 定义前向传播过程

	w=                                 
	b=
	y=
	return y

def get_weight(shape,regularizer): w的形状和正则化regularizer的权重

	w=tf.Variable()         #***需要 赋初值 （）里面 写上赋初值的方法***
	tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(regularizer)(w))
	#**把每一个w的正则化损失加到总损失losses中** 
	return w

Varible括号里的方法

def get_bias(shape): shape是参数b的形状 其实就是b的个数

	b= tf.Variable()
	return b		

反向传播 训练网络 优化网络参数 （backward.py）

def backward():

x = tf.placeholder()
y_ = tf.placeholder()
y = forward.forward(x,REGULARIZER)
global_step = tf.Variable(0,trainable = False)
loss=

正则化
使用均方误差
loss可以是loss_mse = tf.reduce_mean(tf.square(y - y_))
使用交叉熵
或者 ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))
loss_cem = tf.reduce_mean(ce)

加入正则化后：
loss = y与y_的差距 +tf.add_n(tf.get_collection(‘losses’))

指数衰减学习率
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step=,
数据集总样本数/BATCH_SIZE,
LEARNING_RATE_SIZE,
starcase = True
)
滑动平均
前提：
train_step = tf.train.AdamOptimizer( 里面添加学习率 eg：0.0001).minimize(loss_total，global_step = global_step)

开始移动平均

ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_steps)
ema_op = ema.apply(tf.trainable_variables())
with tf.control_dependencies([train_step,ema_op])
    train _op = tf.op(name = "train")


with tf.Session() as sess:

    init_op = tf.global_variables_initializer()
    sess.run(init_op)


    STEPS = 40000
    for i in range(STEPS):
        if i%轮数  ==0
        	print loss的值
if __name__=='__main__'
		backward()

附录代码

代码第一块

 #generate data
 import numpy as np
 import matplotlib.pyplot as plt;
 seed = 2
 def generateds():
     rdm = np.random.RandomState(seed)
     X = rdm.randn(300, 2)
     Y_ = [int(x0 * x0 + x1 * x1 < 2) for (x0, x1) in X]
     Y_c = [['red' if y else 'blue'] for y in Y_]
     X = np.vstack(X).reshape(-1, 2)
     Y_ = np.vstack(Y_).reshape(-1, 1)
     return X,Y_,Y_c

关于reshape的一点小研究—— -1的应用：
在代码中有出现reshape(-1,2) -1 表示不知道该填什么数字合适的情况下，可以选择，由python通过a和其他的值3推测出来，
比如，这里的a 是二维的数组，数组中共有300个元素，当使用reshape()时，300/2=150，所以形成的是150行2列的二维数组，可以看出，利用reshape进行数组形状的转换时，一定要满足（x,y）中x×y=数组的个数。

代码第二块

import tensorflow as tf
def get_weight(shape, regularizer):
    w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w


def get_bias(shape):
    b = tf.Variable(tf.constant(0.01, shape=shape))
    return b

def forward(x,regularizaer):
    w1 = get_weight([2, 11], 0.01)
    b1 = get_bias([11])
    y1 = tf.nn.relu(tf.matmul(x, w1) + b1)

    w2 = get_weight([11, 1], 0.01)
    b2 = get_bias([1])
    y = tf.matmul(y1, w2) + b2

    return y

代码第三块

def backward():
    x = tf.placeholder(tf.float32, shape=(None, 2))
    y_ = tf.placeholder(tf.float32, shape=(None, 1))

    X, Y_, Y_c = generateds.generateds()
    y = forward.forward(x, REGULARIZER)

    global_step = tf.Variable(0, trainable=False)

    learning_rate = tf.train.exponential_decay(
        LEARNING_RATE_BASE,
        global_step,
        300 / BATCH_SIZE,
        LEARNING_RATE_DECAY,
        staircase=True
    )
    loss_mse = tf.reduce_mean(tf.square(y - y_))
    loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))

    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss_total)

    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()
        sess.run(init_op)

        # 一共    轮数
        STEPS = 40000
        for i in range(STEPS):
            start = (i * BATCH_SIZE) % 300
            end = start + BATCH_SIZE
            # 每轮从 X数据集和Y的标签中，选取 从start到end喂入神经网络   用sess.run进行训练
            sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
            # 每2000轮打印出loss值
            if (i % 2000 == 0):
                loss_v = sess.run(loss_total, feed_dict={x: X, y_: Y_})
                print("After %d training step(s),loss on all data is %g" % (i, loss_v))
        xx, yy = np.mgrid[-3:3:0.01, -3:3:0.01]
        grid = np.c_[xx.ravel(), yy.ravel()]  # 生成网络格点
        probs = sess.run(y, feed_dict={x: grid})  # 喂入神经网络 生成probs
        probs = probs.reshape(xx.shape)  # probs 整理形状

    plt.scatter(X[:, 0], X[:, 1], c=np.squeeze(Y_c))
    plt.contour(xx, yy, probs, levels=[.5])
    plt.show()


if __name__ == '__main__':
    backward()