用Tensorflow搭建简单神经网络

最近学习需要，做了一个用Tensorflow搭建好的简单神经网络，来预测回归问题。

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import pandas as pd

n_hidden_1 =60     #隐层1
n_input = 2         #输入层
n_output = 1        #输出层

# INPUTS AND OUTPUTS
x = tf.placeholder("float", [None, n_input])
y = tf.placeholder("float", [None, n_output])

# NETWORK PARAMETERS
stddev = 0.1
weights = {
    'w1': tf.Variable(tf.random_normal([n_input, n_hidden_1], stddev=stddev)),
    'w2': tf.Variable(tf.random_normal([n_hidden_1, n_output], stddev=stddev))
}
biases = {
    'b1': tf.Variable(tf.random_normal([n_hidden_1])),
    'b2': tf.Variable(tf.random_normal([n_output]))
}

# 取出数据
filepath = "D:\\SwarmData\\trans_result\\trans_step250.csv" #绝对路径，按需要修改
data = pd.DataFrame()
xtest=np.mat(np.array([])) #测试x
ytest=np.mat(np.array([]))#测试y
xMat=np.mat(np.array([]))#训练x
yMat=np.mat(np.array([]))#训练y

#预存各项最大值、最小值。用来归一化后的还原数据
max=pd.Series()
min=pd.Series()
rmax=0
rmin=0
sizemax=0
sizemin=0
gapmax=0
gapmin=0

def get_input():
    global data
    global xMat
    global yMat
    global xtest
    global ytest
    global max
    global min
    global rmax
    global rmin
    global sizemax
    global sizemin
    global gapmax
    global gapmin
    data = pd.read_csv(filepath)
    data = data[['swarmsize', 'gap', 'r']]
    max=data.max()
    min=data.min()
    rmax=max['r']
    rmin=min['r']
    sizemax = max['swarmsize']
    sizemin = min['swarmsize']
    gapmax = max['gap']
    gapmin = min['gap']
    data = (data - data.min()) / (data.max() - data.min()) #归一化操作
    # data=data.div(200)
    data = np.array(data)
    np.random.shuffle(data)
    allurl_fea = [d[0] for d in data]
    traindata = data[:int(0.9 * len(allurl_fea))]
    traindata = pd.DataFrame(traindata, columns=['swarmsize', 'gap', 'r'])
    testdata = data[int(0.9 * len(allurl_fea)): ]
    testdata = pd.DataFrame(testdata, columns=['swarmsize', 'gap', 'r'])

    xMat = traindata[['swarmsize', 'gap']].as_matrix()  #训练x
    yMat = traindata[['r']].as_matrix() #训练y
    xtest = testdata[['swarmsize', 'gap']].as_matrix()  #测试x
    ytest = testdata[['r']].as_matrix() #测试y

#取出数据
get_input()


def multilayer_perceptron(_X, _weights, _biases):
    layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(_X, _weights['w1']), _biases['b1']))
    # layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, _weights['w2']), _biases['b2']))
    return (tf.matmul(layer_1, _weights['w2']) + _biases['b2'])

# PREDICTION
pred = multilayer_perceptron(x, weights, biases)

# LOSS AND OPTIMIZER
# 损失函数
cost = tf.reduce_mean(tf.square(pred - y))
#0.02 学习率按具体需要设置
optm = tf.train.GradientDescentOptimizer(learning_rate=0.02).minimize(cost)
# INITIALIZER
# LAUNCH THE GRAPH
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#保存
saver=tf.train.Saver()

do_train=2     #do_train==1训练，do_train==0测试
training_epochs = 2000  #训练的轮数，按具体需要设置
batch_size      = 5     #随机梯度代入数据块，按具体需要设置

#训练
if do_train==1:
    for epoch in range(training_epochs):
        avg_cost = 0.
        total_batch = int(xMat.shape[0]/batch_size)
        # ITERATION
        for i in range(total_batch):
            batch_xs = xMat[i*batch_size:(i+1)*batch_size]
            batch_ys = yMat[i*batch_size:(i+1)*batch_size]
            feeds = {x: batch_xs, y: batch_ys}  #传入数据
            # print(feeds)
            sess.run(optm, feed_dict=feeds)
            avg_cost += sess.run(cost, feed_dict=feeds)
        avg_cost = avg_cost / total_batch
        print (avg_cost)
        do_save=1
        if do_save==1:
            if epoch==training_epochs-1:
                #保存模型到文件
                saver.save(sess,"save/w"+str(epoch))
#测试
if do_train == 0:
    epoch = training_epochs - 1
    #取出模型
    saver.restore(sess, "save/w" + str(epoch))
    testfeed = {x: xtest, y: ytest}     #传入测试数据
    test_cost = sess.run(cost, feed_dict=testfeed)
    print('test_cost:', test_cost)      #测试损失函数值

    # 以下部分是归一化之后的还原操作，对于训练模型而言可以忽略
    # 只是为了更直观的观察预测数据，与真实数据之间的差异
    feed = {x: xtest}
    preddata=sess.run(pred,feed_dict=feed)
    d=[]
    for i in range(200):
        yout=ytest[i:i+1]*(rmax-rmin)+rmin
        predout=preddata[i:i+1]*(rmax-rmin)+rmin
        d.append(abs(yout-predout))
        print('y',i,':',yout,'pred',i,':',predout,'abs:',d[i])
    aver=np.mean(d)
    var=np.var(d)
    print('average:',aver,'var:',var)

#以下代码 可忽略，只是需要预测size很大的时候，输出r的值
if do_train == 2:
    epoch = training_epochs - 1
    saver.restore(sess, "save/w" + str(epoch))
    xx=[]
    def func(size,gap):
        x1 = (size - sizemin) / (sizemax - sizemin)
        x2 = (gap - gapmin) / (gapmax - gapmin)
        x = [x1, x2]
        xx.append(x)
    func(500,25)
    func(1000,25)
    xtest=xx
    feed = {x: xtest}
    preddata=sess.run(pred,feed_dict=feed)
    predout = preddata * (rmax - rmin) + rmin
    print('pred:',predout)