TensorFlow实现神经网络

这里，我们将实现一个单层神经网络，并在IRIS数据集上进行模型训练

输入数据：IRIS数据集的前三个特征

输出数据：IRIS数据集的第四个特征即花萼长度

神经网络大小：输入为batch_size*3，隐层为5个神经元,激活函数采用ReLU激活函数,一共需要训练(3*5+5+5+1)=26个变量

代码如下：

第1步：导入库以及相应的数据集，并对数据集按列（特征）进行归一化处理

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets

sess = tf.Session()


#数据集
iris = datasets.load_iris()
x_vals = np.array(iris.data[:,0:3])
y_vals = np.array(iris.data[:,3])


def normalize_cols(m):
    col_max = m.max(axis = 0)
    col_min = m.min(axis = 0)
    return (m-col_min)/(col_max-col_min)

x_vals = np.nan_to_num(normalize_cols(x_vals))

第2步：声明数据集和目标值得占位符以及批量训练大小batch_size

#声明批量大小
batch_size = 50

#声明变量与占位符

x_data = tf.placeholder(shape=[None,3],dtype=tf.float32)
y_target = tf.placeholder(shape=[None,1],dtype=tf.float32)

第3步:声明神经网络层变量，这里设置隐藏层神经元个数为5

hidden_layer_nodes = 5 #隐藏层节点个数

a1 = tf.Variable(tf.random_normal(dtype=tf.float32,shape=[3,hidden_layer_nodes]))
b1 = tf.Variable(tf.random_normal(dtype=tf.float32,shape=[hidden_layer_nodes]))
a2 = tf.Variable(tf.random_normal(dtype=tf.float32,shape=[hidden_layer_nodes,1]))
b2 = tf.Variable(tf.random_normal(dtype=tf.float32,shape=[1]))

第4步：连接各层，构建模型

#声明训练模型
hidden_output = tf.nn.relu(tf.add(tf.matmul(x_data,a1),b1))
final_output = tf.nn.relu(tf.add(tf.matmul(hidden_output,a2),b2))

第5步：创建L2损失函数

loss = tf.reduce_mean(tf.square(tf.subtract(final_output,y_target)))

第6步：声明优化器和学习率并初始化模型变量

#初始化变量
init = tf.global_variables_initializer()
sess.run(init)

#声明优化器
opt = tf.train.GradientDescentOptimizer(learning_rate=0.05)
train_step = opt.minimize(loss)

第7步：遍历迭代训练模型，并记录损失值，画出Loss曲线

#迭代训练
Loss = []

for i in range(1000):
    rand_indices = np.random.choice(len(x_vals),size=batch_size)
    rand_x = x_vals[rand_indices]
    rand_y = np.transpose([y_vals[rand_indices]])

    sess.run(train_step,feed_dict={x_data:rand_x,y_target:rand_y})

    temp_Loss = sess.run(loss,feed_dict={x_data:rand_x,y_target:rand_y})
    Loss.append(temp_Loss)




fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(Loss,'k-',label = ' Loss')

handles , labels = ax.get_legend_handles_labels()
ax.legend(handles=handles,labels=labels)
ax.set_xlabel('Generation')
ax.set_ylabel('Loss')
fig.suptitle('Loss per Generation')

plt.show()

单层神经网络实现，实现多层同样可以实现

下面给出一个例子，内含三层隐藏层，神经元个数分别为25、10、3，大家可以自行找一些数据集进行训练，激活函数type=1为sigmoid，type=2为ReLU函数

import xlrd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
sess = tf.Session()

#数据集

batch_size = 50
features = 13

dataset = xlrd.open_workbook('./aaa.xlsx')
table = dataset.sheets()[0]
nrows = table.nrows
ncols = table.ncols
data_head = table.row_values(0)
data = []
for i in range(1,nrows):
    temp = table.row_values(i)
    data.append([float(x) for x in temp]) #某一行数据
data = np.array(data)
print('数据示例:')
print(data_head)
print(data[1:5,:])
print('数据大小: ',np.shape(data))



x_vals = data[:,0:features]
y_vals = data[:,13]

#归一化
def normalize_cols(m):
    col_max = m.max(axis = 0)
    col_min = m.min(axis = 0)
    return (m-col_min)/(col_max-col_min)

x_vals = normalize_cols(x_vals)

print('x: ',x_vals[200:205,:])
print('y: ',y_vals[200:205])

#初始化权重
def init_weight(shape,st_dev):
    weight = tf.Variable(tf.random_normal(shape=shape,stddev=st_dev))
    return weight

#初始化偏置
def init_bias(shape,st_dev):
    bias = tf.Variable(tf.random_normal(shape=shape,stddev=st_dev))
    return bias

#初始化占位符

x_data = tf.placeholder(shape=[None,features],dtype=tf.float32)
y_target = tf.placeholder(shape=[None,1],dtype=tf.float32)

#全连接

def fully_connected(input_layer,weights,biases,type = 1):
    layer = tf.add(tf.matmul(input_layer,weights),biases)
    if type==1:
        return tf.sigmoid(layer)
    if type==2:
        return tf.nn.relu(layer)

#13*25*10*3*1

#创建第一层隐含层
weight_1 = init_weight([features,25],st_dev=10.0)
bias_1 = init_bias([25],st_dev=10.0)
layer_1 = fully_connected(x_data,weights=weight_1,biases=bias_1)

#创建第二层隐含层
weight_2 = init_weight([25,10],st_dev=10.0)
bias_2 = init_bias([10],st_dev=10.0)
layer_2 = fully_connected(layer_1,weights=weight_2,biases=bias_2)

#创建第三层隐含层
weight_3 = init_weight([10,3],st_dev=10.0)
bias_3 = init_bias([3],st_dev=10.0)
layer_3 = fully_connected(layer_2,weights=weight_3,biases=bias_3,type=1)

#输出层
weight_4 = init_weight([3,1],st_dev=10.0)
bias_4 = init_bias([1],st_dev=10.0)
output = fully_connected(layer_3,weights=weight_4,biases=bias_4,type=2)

#L1损失函数
loss = tf.reduce_mean(tf.abs(y_target-output))

#优化器
opt = tf.train.GradientDescentOptimizer(learning_rate=0.1)
train_step = opt.minimize(loss)

#初始化变量
init = tf.initialize_all_variables()
sess.run(init)

#迭代
Loss = []

for i in range(1000):
    rand_indices = np.random.choice(len(x_vals),size=batch_size)
    rand_x = x_vals[rand_indices]
    rand_y = np.transpose([y_vals[rand_indices]])

    sess.run(train_step,feed_dict={x_data:rand_x,y_target:rand_y})

    temp_Loss = sess.run(loss,feed_dict={x_data:rand_x,y_target:rand_y})
    Loss.append(temp_Loss)




fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(Loss,'k-',label = ' Loss')

handles , labels = ax.get_legend_handles_labels()
ax.legend(handles=handles,labels=labels)
ax.set_xlabel('Generation')
ax.set_ylabel('Loss')
fig.suptitle('Loss per Generation')

fit = []
for xx in range(len(x_vals)):
    temp_x = [x_vals[xx,0:features]]
    [get_data] = sess.run(output,feed_dict={x_data:temp_x})
    fit.append(get_data)

fig2 = plt.figure()
ax2 = fig2.add_subplot(111)
ax2.plot(y_vals,'o',label = ' data')
ax2.plot(fit,'k-',label = ' fit')

handles , labels = ax2.get_legend_handles_labels()
ax2.legend(handles=handles,labels=labels)
ax2.set_xlabel('Generation')
ax2.set_ylabel('Loss')
fig2.suptitle('Loss per Generation')

plt.show()