利用Tensorflow实现卷积神经网络模型

时间：2023-12-10 18:10:14

首先看一下卷积神经网络模型，如下图：

利用Tensorflow实现卷积神经网络模型

卷积神经网络（CNN）由输入层、卷积层、激活函数、池化层、全连接层组成，即INPUT-CONV-RELU-POOL-FC
池化层：为了减少运算量和数据维度而设置的一种层。

代码如下：

n_input  = 784        # 28*28的灰度图

n_output = 10         # 完成一个10分类的操作

weights  = {

    #'权重参数': tf.Variable(tf.高期([feature的H, feature的W, 当前feature连接的输入的深度, 最终想得到多少个特征图], 标准差=0.1)),

    'wc1': tf.Variable(tf.random_normal([3, 3, 1, 64], stddev=0.1)),

    'wc2': tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.1)),

　　 #'全连接层参数': tf.Variable(tf.高斯([特征图H*特征图W*深度, 最终想得到多少个特征图], 标准差=0.1)),

    'wd1': tf.Variable(tf.random_normal([7*7*128, 1024], stddev=0.1)),

    'wd2': tf.Variable(tf.random_normal([1024, n_output], stddev=0.1))

}

biases   = {

　　 #'偏置参数': tf.Variable(tf.高斯([第1层有多少个偏置项], 标准差=0.1)),

    'bc1': tf.Variable(tf.random_normal([64], stddev=0.1)),

    'bc2': tf.Variable(tf.random_normal([128], stddev=0.1)),

    'bd1': tf.Variable(tf.random_normal([1024], stddev=0.1)),

    'bd2': tf.Variable(tf.random_normal([n_output], stddev=0.1))

}

#卷积神经网络

def conv_basic(_input, _w, _b, _keepratio):

    #将输入数据转化成一个四维的[n, h, w, c]tensorflow格式数据

    #_input_r = tf.将输入数据转化成tensorflow格式(输入, shape=[batch_size大小, H, W, 深度])

    _input_r = tf.reshape(_input, shape=[-1, 28, 28, 1])

    #第1层卷积

    #_conv1 = tf.nn.卷积(输入, 权重参数, 步长=[batch_size大小, H, W, 深度], padding='建议选择SAME')

    _conv1 = tf.nn.conv2d(_input_r, _w['wc1'], strides=[1, 1, 1, 1], padding='SAME')

    #_conv1 = tf.nn.非线性激活函数(tf.nn.加法(_conv1, _b['bc1']))

    _conv1 = tf.nn.relu(tf.nn.bias_add(_conv1, _b['bc1']))

    #第1层池化

    #_pool1 = tf.nn.池化函数(_conv1, 指定池化窗口的大小=[batch_size大小, H, W, 深度], strides=[1, 2, 2, 1], padding='SAME')

    _pool1 = tf.nn.max_pool(_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

    #随机杀死一些节点，不让所有神经元都加入到训练中

    #_pool_dr1 = tf.nn.dropout(_pool1, 保留比例)

    _pool_dr1 = tf.nn.dropout(_pool1, _keepratio)

    #第2层卷积

    _conv2 = tf.nn.conv2d(_pool_dr1, _w['wc2'], strides=[1, 1, 1, 1], padding='SAME')

    _conv2 = tf.nn.relu(tf.nn.bias_add(_conv2, _b['bc2']))

    _pool2 = tf.nn.max_pool(_conv2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

    _pool_dr2 = tf.nn.dropout(_pool2, _keepratio)

    #全连接层

    #转化成tensorflow格式

    _dense1 = tf.reshape(_pool_dr2, [-1, _w['wd1'].get_shape().as_list()[0]])

    #第1层全连接层

    _fc1 = tf.nn.relu(tf.add(tf.matmul(_dense1, _w['wd1']), _b['bd1']))

    _fc_dr1 = tf.nn.dropout(_fc1, _keepratio)

    #第2层全连接层

    _out = tf.add(tf.matmul(_fc_dr1, _w['wd2']), _b['bd2'])

    #返回值

    out = { 'input_r': _input_r, 'conv1': _conv1, 'pool1': _pool1, 'pool1_dr1': _pool_dr1,

        'conv2': _conv2, 'pool2': _pool2, 'pool_dr2': _pool_dr2, 'dense1': _dense1,

        'fc1': _fc1, 'fc_dr1': _fc_dr1, 'out': _out

    }

    return out

print ("CNN READY")

#设置损失函数&优化器（代码说明：略 请看前面文档）

learning_rate = 0.001

x      = tf.placeholder("float", [None, nsteps, diminput])

y      = tf.placeholder("float", [None, dimoutput])

myrnn  = _RNN(x, weights, biases, nsteps, 'basic')

pred   = myrnn['O']

cost   = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(pred, y))

optm   = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) # Adam Optimizer

accr   = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(pred,1), tf.argmax(y,1)), tf.float32))

init   = tf.global_variables_initializer()

print ("Network Ready!")

#训练（代码说明：略 请看前面文档）

training_epochs = 5

batch_size      = 16

display_step    = 1

sess = tf.Session()

sess.run(init)

print ("Start optimization")

for epoch in range(training_epochs):

    avg_cost = 0.

    #total_batch = int(mnist.train.num_examples/batch_size)

    total_batch = 100

    # Loop over all batches

    for i in range(total_batch):

        batch_xs, batch_ys = mnist.train.next_batch(batch_size)

        batch_xs = batch_xs.reshape((batch_size, nsteps, diminput))

        # Fit training using batch data

        feeds = {x: batch_xs, y: batch_ys}

        sess.run(optm, feed_dict=feeds)

        # Compute average loss

        avg_cost += sess.run(cost, feed_dict=feeds)/total_batch

    # Display logs per epoch step

    if epoch % display_step == 0:

        print ("Epoch: %03d/%03d cost: %.9f" % (epoch, training_epochs, avg_cost))

        feeds = {x: batch_xs, y: batch_ys}

        train_acc = sess.run(accr, feed_dict=feeds)

        print (" Training accuracy: %.3f" % (train_acc))

        testimgs = testimgs.reshape((ntest, nsteps, diminput))

        feeds = {x: testimgs, y: testlabels, istate: np.zeros((ntest, 2*dimhidden))}

        test_acc = sess.run(accr, feed_dict=feeds)

        print (" Test accuracy: %.3f" % (test_acc))

print ("Optimization Finished.")

相关文章