devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Alexnet网络的实现（tensorflow版本）_def cnn_inference(images, batch_size, n_classes):

作者：小丑西瓜9 | 2024-02-21 12:59:20

赞

踩

def cnn_inference(images, batch_size, n_classes): with tf.variable_scope('co

由于基础不是很好，最近花了大概五天的时间。终于把Alexnet网络实现了。首先看一下网络结构。

test，test2分别是训练网络时生成的文件。input_data是处理数据的文件，3个model文件，由上至下分别对应了最原始，最简单的Alexnet网络结构，其次是模仿2块GPU进行训练的网络结构，最后是去掉lrn层的网络结构。test.py文件是取一张没有训练过的图片进行测试，两个training文件对应两个model文件的网络进行训练。我并没有训练去掉lrn层的网络，感兴趣的朋友也可以将training.py改动一下进行训练。

我主要参考了这篇文章进行编码：https://blog.csdn.net/qq_26499769/article/details/82928178

在写代码前首先要理清楚思路：

  • 网络的结构，每一步的输入与输出分别是什么，最后要实现何种功能
  • 选择数据集，根据网络的输入，对数据集进行处理
  • 设计网络的结构
  • 训练网络
  • 测试网络
  • 总结

我们可以按着思路来走一遍：

首先我们需要了解Alexnet的网络结构，如下图所示：

接着是第二步，我选择的是来源于Kaggle的猫狗数据集，数据集有12500只猫和12500只狗。

第三步是根据前两步，设计我们的网络结构，见第一张图。

接着是编写代码训练网络，然后测试网络。

input_data.py

  1. import tensorflow as tf
  2. import numpy as np
  3. import os
  4.  
  5. #img_width = 227
  6. #img_height = 227
  7. #train_dir = 'H:/liangpan/train1/'
  8.  
  9.  
  10. def get_files(file_dir):
  11.     cats = []
  12.     label_cats = []
  13.     dogs = []
  14.     label_dogs = []
  15.     for file in os.listdir(file_dir):#os.listdir返回指定的文件夹包含的文件或文件夹的名字的列表
  16.         # 将图片存入一个列表中
  17.         # 如果是猫的图片，将图片的标签为0
  18.         name = file.split(sep='.')
  19.         if name[0] == 'cat':
  20.             cats.append(file_dir + file)
  21.             label_cats.append(0)
  22.         else:
  23.             # 如果是狗的图片，将图片的标签为1
  24.             dogs.append(file_dir + file)
  25.             label_dogs.append(1)
  26.     print('There are %d cats\nThere are %d dogs' % (len(cats), len(dogs)))
  27.     image_list = np.hstack((cats, dogs))
  28.     label_list = np.hstack((label_cats, label_dogs))
  29.     # 把图片和标签都取出放入temp文件中，然后将图片的顺序打乱，最后取出
  30.     temp = np.array([image_list, label_list])
  31.     temp = temp.transpose()#转置，由两行的矩阵转换成两列的矩阵
  32.     np.random.shuffle(temp)
  33.     image_list = list(temp[:, 0])
  34.     label_list = list(temp[:, 1])
  35.     label_list = [int(i) for i in label_list]
  36.     return image_list, label_list
  37.  
  38.  
  39. #image_list, label_list = get_files(train_dir)
  40.  
  41.  
  42. def get_batch(image, label, image_W, image_H, batch_size, capacity):
  43.     image = tf.cast(image, tf.string)
  44.     label = tf.cast(label, tf.int32)
  45.     # 将图片与其标签放入队列中
  46.     input_queue = tf.train.slice_input_producer([image, label])
  47.     label = input_queue[1]
  48.     image_contents = tf.read_file(input_queue[0])
  49.     # 把图片解码
  50.     image = tf.image.decode_jpeg(image_contents, channels=3)
  51.     #设置图片的大小
  52.     image = tf.image.resize_image_with_crop_or_pad(image, image_W, image_H)
  53.     #将图片进行标准化
  54.     image = tf.image.per_image_standardization(image)
  55.     # 生成批次
  56.     image_batch, label_batch = tf.train.batch([image, label], batch_size=batch_size, num_threads=64, capacity=capacity)
  57.     label_batch = tf.reshape(label_batch, [batch_size])
  58.     return image_batch, label_batch
  59.  
  60. #对get_batch进行测试
  61. """
  62. import matplotlib.pyplot as plt
  64. BATCH_SIZE = 2
  65. CAPACITY = 256
  66. IMG_W = 208
  67. IMG_H = 208
  68. train_dir = 'H:/liangpan/train1/'
  69. image_list, label_list = get_files(train_dir)
  70. image_batch, label_batch = get_batch(image_list, label_list, IMG_W, IMG_H, BATCH_SIZE, CAPACITY)
  72. with tf.Session() as sess:
  73.     i = 0
  74.     coord = tf.train.Coordinator()
  75.     threads = tf.train.start_queue_runners(coord=coord)
  76.     try:
  77.         while not coord.should_stop() and i < 1:
  78.             img, label = sess.run([image_batch, label_batch])
  79.             for j in np.arange(BATCH_SIZE):
  80.                 print('label:%d' % label[j])
  81.                 plt.imshow(img[j, :, :, :])
  82.                 plt.show()
  83.             i += 1
  84.     except tf.errors.OutOfRangeError:
  85.         print('done!')
  86.     finally:
  87.         coord.request_stop()
  88.     coord.join(threads)
  89.     """

model.py

  1. import tensorflow as tf
  2.  
  3. #输出各层参数
  4. def shape(value):
  5.     print(value.op.name,value.get_shape().as_list())
  6.  
  7. def inference(images, batch_size, n_classes):
  8.     #conv1
  9.     with tf.variable_scope('conv1') as scope:
  10.         weights = tf.get_variable('weights',
  11.                                   shape=[11,11,3,96],#随机生成96个11*11*3 的卷积核
  12.                                   dtype=tf.float32,
  13.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  14.         # 其中tf.truncated_normal:从截断的正态分布中输出随机值。
  15.         # 生成的值服从具有指定平均值和标准偏差的正态分布，如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。
  16.         # stddev: 正态分布的标准差。
  17.         biases = tf.get_variable("biases",
  18.                                  shape=[96],
  19.                                  dtype=tf.float32,
  20.                                  initializer=tf.constant_initializer(0.1))
  21.         conv = tf.nn.conv2d(images, weights, strides=[1, 4, 4, 1], padding='SAME')
  22.         # 描述：过滤器移动的步长，第一位和第四位一般恒定为1，第二位指水平移动时候的步长，第三位指垂直移动的步长。
  23.         # strides = [1, stride, stride, 1].
  24.         # Valid: 用过滤器在输入的矩阵中按步长移动时候，会把最后的不足部分的列和行抛弃；
  25.         # Same：先在输入矩阵上下各加个值为0的行，在左右各加个个值为0的列，也就是用0把原先的矩阵包裹一层，
  26.         # 然后在移动的时候如果输入矩阵的列或者行长度不够，就用0来补齐。
  27.         pre_activation = tf.nn.bias_add(conv, biases)
  28.         #tf.nn.bias_add将偏差项biases（向量）加到conv（矩阵）上，是向量与矩阵的每一行进行相加，得到的结果和conv矩阵大小相同
  29.         conv1 = tf.nn.relu(pre_activation, name=scope.name)
  30.  
  31.         #使用relu激活函数进行激活
  32.  
  33.     with tf.variable_scope('pooling1_lrn') as scope:
  34.         # conv1经卷积之后得到的feature map，那么它就具有[batch, height, width, channels]这样的shape
  35.         shape(conv1)
  36.         # 池化层
  37.         pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  38.                                padding='VALID', name='pooling1')
  39.         # 局部响应归一化层
  40.         norm1 = tf.nn.lrn(pool1, depth_radius=4, bias=1.0, alpha=0.001 / 9.0,
  41.                           beta=0.75, name='norm1')
  42.         shape(norm1)
  43.  
  44.     #conv2
  45.     with tf.variable_scope('conv2') as scope:
  46.         weights = tf.get_variable('weights',
  47.                                   shape=[5, 5, 96, 256],
  48.                                   dtype=tf.float32,
  49.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  50.         biases = tf.get_variable('biases',
  51.                                  shape=[256],
  52.                                  dtype=tf.float32,
  53.                                  initializer=tf.constant_initializer(0.1))
  54.         conv = tf.nn.conv2d(norm1, weights, strides=[1, 1, 1, 1], padding='SAME')
  55.         pre_activation = tf.nn.bias_add(conv, biases)
  56.         conv2 = tf.nn.relu(pre_activation, name='conv2')
  57.  
  58.     with tf.variable_scope('pooling2_lrn') as scope:
  59.         norm2 = tf.nn.lrn(conv2, depth_radius=4, bias=1.0, alpha=0.001 / 9.0,
  60.                           beta=0.75, name='norm2')
  61.         pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  62.                                padding='VALID', name='pooling2')
  63.  
  64.     #conv3
  65.     with tf.variable_scope('conv3') as scope:
  66.         weights = tf.get_variable('weights',
  67.                                   shape=[3, 3, 256, 384],
  68.                                   dtype=tf.float32,
  69.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  70.         biases = tf.get_variable('biases',
  71.                                  shape=[384],
  72.                                  dtype=tf.float32,
  73.                                  initializer=tf.constant_initializer(0.1))
  74.         conv = tf.nn.conv2d(pool2, weights, strides=[1, 1, 1, 1], padding='SAME')
  75.         pre_activation = tf.nn.bias_add(conv, biases)
  76.         conv3 = tf.nn.relu(pre_activation, name='conv3')
  77.  
  78.     #conv4
  79.     with tf.variable_scope('conv4') as scope:
  80.         weights = tf.get_variable('weights',
  81.                                   shape=[3, 3, 384, 384],
  82.                                   dtype=tf.float32,
  83.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  84.         biases = tf.get_variable('biases',
  85.                                  shape=[384],
  86.                                  dtype=tf.float32,
  87.                                  initializer=tf.constant_initializer(0.1))
  88.         conv = tf.nn.conv2d(conv3, weights, strides=[1, 1, 1, 1], padding='SAME')
  89.         pre_activation = tf.nn.bias_add(conv, biases)
  90.         conv4 = tf.nn.relu(pre_activation, name='conv4')
  91.  
  92.     #conv5
  93.     with tf.variable_scope('conv5') as scope:
  94.         weights = tf.get_variable('weights',
  95.                                   shape=[3, 3, 384, 256],
  96.                                   dtype=tf.float32,
  97.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  98.         biases = tf.get_variable('biases',
  99.                                  shape=[256],
  100.                                  dtype=tf.float32,
  101.                                  initializer=tf.constant_initializer(0.1))
  102.         conv = tf.nn.conv2d(conv4, weights, strides=[1, 1, 1, 1], padding='SAME')
  103.         pre_activation = tf.nn.bias_add(conv, biases)
  104.         conv5 = tf.nn.relu(pre_activation, name='conv5')
  105.  
  106.     with tf.variable_scope('pooling2_lrn') as scope:
  107.         norm5 = tf.nn.lrn(conv5, depth_radius=4, bias=1.0, alpha=0.001 / 9.0,
  108.                           beta=0.75, name='norm5')
  109.         pool5 = tf.nn.max_pool(norm5, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  110.                                padding='VALID', name='pooling5')
  111.  
  112.  
  113.     print("pool5.shape = ",pool5.shape)
  114.     #fc6
  115.     with tf.variable_scope('fc6') as scope:
  116.         reshape = tf.reshape(pool5, shape=[batch_size, -1])#将pool5拉直，将最后3个维度变成一个维度,并且保留前面的batch_size维度
  117.         print("reshape.shape = ", reshape.shape)
  118.         dim = reshape.get_shape()[1].value
  119.         print("dim",dim)
  120.         weights = tf.get_variable('weights',
  121.                                   shape=[dim, 4096],
  122.                                   dtype=tf.float32,
  123.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  124.  
  125.         biases = tf.get_variable('biases',
  126.                                  shape=[4096],
  127.                                  dtype=tf.float32,
  128.                                  initializer=tf.constant_initializer(0.1))
  129.         fc6 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
  130.  
  131.         # dropout6
  132.         with tf.name_scope('dropout6') as scope:
  133.             dropout6 = tf.nn.dropout(fc6, 0.5)#0.5表示随机选择一半的神经元失效
  134.  
  135.     with tf.variable_scope('fc7') as scope:
  136.         weights = tf.get_variable('weights',
  137.                                   shape=[4096, 4096],
  138.                                   dtype=tf.float32,
  139.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  140.         biases = tf.get_variable('biases',
  141.                                  shape=[4096],
  142.                                  dtype=tf.float32,
  143.                                  initializer=tf.constant_initializer(0.1))
  144.         fc7 = tf.nn.relu(tf.matmul(dropout6, weights) + biases, name='fc7')
  145.         # dropout7
  146.         with tf.name_scope('dropout6') as scope:
  147.             dropout7 = tf.nn.dropout(fc7, 0.5)
  148.  
  149.     #fc8
  150.     with tf.variable_scope('fc8') as scope:
  151.         weights = tf.get_variable('fc8',
  152.                                   shape=[4096, n_classes],
  153.                                   dtype=tf.float32,
  154.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  155.         biases = tf.get_variable('biases',
  156.                                  shape=[n_classes],
  157.                                  dtype=tf.float32,
  158.                                  initializer=tf.constant_initializer(0.1))
  159.         fc8 = tf.add(tf.matmul(dropout7, weights), biases, name='fc8')
  160.  
  161.     return fc8
  162.  
  163.  
  164. def losses(logits, labels):
  165.     with tf.variable_scope('loss') as scope:
  166.         cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits \
  167.             (logits=logits, labels=labels, name='xentropy_per_example')
  168.  
  169.         loss = tf.reduce_mean(cross_entropy, name='loss')
  170.         tf.summary.scalar(scope.name + '/loss', loss)
  171.     return loss
  172.  
  173.  
  174. def training(loss, learning_rate):
  175.     with tf.name_scope('optimizer'):
  176.         optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate)
  177.         global_step = tf.Variable(0, name='global_step', trainable=False)
  178.         train_op = optimizer.minimize(loss, global_step=global_step)#用于记录全局训练步骤的单值
  179.     return train_op
  180.  
  181. #评估函数
  182. def evaluation(logits, labels):
  183.     with tf.variable_scope('accuracy') as scope:
  184.         # 用于计算预测的结果和实际结果的是否相等，返回一个bool类型的张量
  185.         correct = tf.nn.in_top_k(logits, labels, 1)#预测的结果，实际样本类别的标签，一般都取1
  186.         correct = tf.cast(correct, tf.float16)
  187.         accuracy = tf.reduce_mean(correct)
  188.         tf.summary.scalar(scope.name + '/accuracy', accuracy)#生成loss的标量信息
  189.  
  190.     return accuracy

training.py

  1. import os
  2. import numpy as np
  3. import tensorflow as tf
  4. import input_data
  5. import model
  6.  
  7. N_CLASSES = 2#输出的分类的数量
  8. IMG_W = 227#图片的尺寸
  9. IMG_H = 227
  10. BATCH_SIZE = 8#每批数据的大小
  11. CAPACITY = 200
  12. MAX_STEP = 15000#训练步数
  13. learing_rate = 0.0001#学习率
  14.  
  15.  
  16. def run_training():
  17.     train_dir = 'H:/liangpan/train1/'#训练的数据集所在的路径
  18.     logs_train_dir = 'H:/liangpan/test_alexnet/test/'#存放训练模型过程的数据的存储路径
  19.     # 获取图片和标签集
  20.     train, train_label = input_data.get_files(train_dir)
  21.     # 生成批次
  22.     train_batch, train_label_batch = input_data.get_batch(train,
  23.                                                           train_label,
  24.                                                           IMG_W,
  25.                                                           IMG_H,
  26.                                                           BATCH_SIZE,
  27.                                                           CAPACITY)
  28.     # 进入训练模型
  29.     train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
  30.     # 获取 loss
  31.     train_loss = model.losses(train_logits, train_label_batch)
  32.     # 训练
  33.     train_op = model.training(train_loss, learing_rate)
  34.     #获取准确率
  35.     train_acc = model.evaluation(train_logits, train_label_batch)
  36.     # 合并summary
  37.     summary_op = tf.summary.merge_all()
  38.  
  39.     sess = tf.Session()
  40.     train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)#保存summary
  41.     saver = tf.train.Saver()
  42.     sess.run(tf.global_variables_initializer())#初始化全部的变量
  43.     # Coordinator类用来管理在Session中的多个线程，
  44.     # 可以用来同时停止多个工作线程并且向那个在等待所有工作线程终止的程序报告异常，
  45.     # 该线程捕获到这个异常之后就会终止所有线程。
  46.     coord = tf.train.Coordinator()
  47.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)
  48.     try:
  49.         for step in np.arange(MAX_STEP):
  50.             # coord.should_stop() 返回 true 时也就是数据读完了,应该调用 coord.request_stop()
  51.             if coord.should_stop():
  52.                 break
  53.             _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc])
  54.             if step % 100 == 0:
  55.                 print('step %d,train loss=%.2f,train accuracy=%.2f' % (step, tra_loss, tra_acc))
  56.                 summary_str = sess.run(summary_op)
  57.                 train_writer.add_summary(summary_str, step)
  58.  
  59.             if step % 2000 == 0 or (step + 1) == MAX_STEP:
  60.                 # 每隔2000步保存一下模型，模型保存在 checkpoint_path 中
  61.                 checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
  62.                 saver.save(sess, checkpoint_path, global_step=step)
  63.  
  64.     except tf.errors.OutOfRangeError:
  65.         print('Done traing -- epoch limit reached')
  66.     finally:
  67.         coord.request_stop()
  68.  
  69.     coord.join(threads)
  70.     sess.close()
  71.  
  72.  
  73. run_training()

test.py测试的是training的model

  1. import os
  2. import numpy as np
  3. import tensorflow as tf
  4. import input_data
  5. import model
  6.  
  7. N_CLASSES = 2#输出的分类的数量
  8. IMG_W = 227#图片的尺寸
  9. IMG_H = 227
  10. BATCH_SIZE = 8#每批数据的大小
  11. CAPACITY = 200
  12. MAX_STEP = 15000#训练步数
  13. learing_rate = 0.0001#学习率
  14.  
  15.  
  16. def run_training():
  17.     train_dir = 'H:/liangpan/train1/'#训练的数据集所在的路径
  18.     logs_train_dir = 'H:/liangpan/test_alexnet/test/'#存放训练模型过程的数据的存储路径
  19.     # 获取图片和标签集
  20.     train, train_label = input_data.get_files(train_dir)
  21.     # 生成批次
  22.     train_batch, train_label_batch = input_data.get_batch(train,
  23.                                                           train_label,
  24.                                                           IMG_W,
  25.                                                           IMG_H,
  26.                                                           BATCH_SIZE,
  27.                                                           CAPACITY)
  28.     # 进入训练模型
  29.     train_logits = model.inference(train_batch, BATCH_SIZE, N_CLASSES)
  30.     # 获取 loss
  31.     train_loss = model.losses(train_logits, train_label_batch)
  32.     # 训练
  33.     train_op = model.training(train_loss, learing_rate)
  34.     #获取准确率
  35.     train_acc = model.evaluation(train_logits, train_label_batch)
  36.     # 合并summary
  37.     summary_op = tf.summary.merge_all()
  38.  
  39.     sess = tf.Session()
  40.     train_writer = tf.summary.FileWriter(logs_train_dir, sess.graph)#保存summary
  41.     saver = tf.train.Saver()
  42.     sess.run(tf.global_variables_initializer())#初始化全部的变量
  43.     # Coordinator类用来管理在Session中的多个线程，
  44.     # 可以用来同时停止多个工作线程并且向那个在等待所有工作线程终止的程序报告异常，
  45.     # 该线程捕获到这个异常之后就会终止所有线程。
  46.     coord = tf.train.Coordinator()
  47.     threads = tf.train.start_queue_runners(sess=sess, coord=coord)
  48.     try:
  49.         for step in np.arange(MAX_STEP):
  50.             # coord.should_stop() 返回 true 时也就是数据读完了,应该调用 coord.request_stop()
  51.             if coord.should_stop():
  52.                 break
  53.             _, tra_loss, tra_acc = sess.run([train_op, train_loss, train_acc])
  54.             if step % 100 == 0:
  55.                 print('step %d,train loss=%.2f,train accuracy=%.2f' % (step, tra_loss, tra_acc))
  56.                 summary_str = sess.run(summary_op)
  57.                 train_writer.add_summary(summary_str, step)
  58.  
  59.             if step % 2000 == 0 or (step + 1) == MAX_STEP:
  60.                 # 每隔2000步保存一下模型，模型保存在 checkpoint_path 中
  61.                 checkpoint_path = os.path.join(logs_train_dir, 'model.ckpt')
  62.                 saver.save(sess, checkpoint_path, global_step=step)
  63.  
  64.     except tf.errors.OutOfRangeError:
  65.         print('Done traing -- epoch limit reached')
  66.     finally:
  67.         coord.request_stop()
  68.  
  69.     coord.join(threads)
  70.     sess.close()
  71.  
  72.  
  73. run_training()

test_2_gpu.py测试的是training_2_gpu的model

  1. from PIL import Image
  2. import matplotlib.pyplot as plt
  3. import numpy as np
  4. import input_data
  5. import tensorflow as tf
  6. import model_2_gpu
  7.  
  8. #获取一张图片
  9. def get_one_image(train):
  10.     n = len(train)
  11.     ind = np.random.randint(0, n)#从数据集中随机选取一张图片
  12.     img_dir = train[ind]#图片的路径
  13.     print(img_dir)
  14.     image = Image.open(img_dir)#打开图片
  15.     plt.imshow(image)
  16.     image = image.resize([227, 227])#把图片裁成大小为227*227
  17.     image = np.array(image)#把图片转成数组
  18.     plt.show()
  19.     return image
  20.  
  21.  
  22. def evaluate_one_image():
  23.     train_dir = 'H:/liangpan/train/'
  24.     train, train_label = input_data.get_files(train_dir)
  25.     image_array = get_one_image(train)
  26.     # Graph.as_default() 的上下文管理器（context manager），它能够在这个上下文里面覆盖默认的图
  27.     with tf.Graph().as_default():
  28.         BATCH_SIZE = 1# 因为只读取一副图片 所以batch 设置为1
  29.         N_CLASSES = 2
  30.         # 转化图片格式
  31.         image = tf.cast(image_array, tf.float32)
  32.         image = tf.reshape(image, [1, 227, 227, 3])
  33.         # 图片原来是三维的 [227, 227, 3] 重新定义图片形状 改为一个4D  四维的 tensor
  34.         logit = model_2_gpu.inference(image, BATCH_SIZE, N_CLASSES)
  35.         # 因为 inference 的返回没有用激活函数，所以在这里对结果用softmax 激活
  36.         logit = tf.nn.softmax(logit)
  37.         # 用最原始的输入数据的方式向模型输入数据 placeholder（占位符）
  38.         x = tf.placeholder(tf.float32, shape=[227, 227, 3])
  39.  
  40.         logs_train_dir = 'H:/liangpan/test_alexnet/test2/'
  41.         saver = tf.train.Saver()
  42.         with tf.Session() as sess:
  43.             print("reading checkpoints")
  44.             # 将模型加载到sess 中
  45.             ckpt = tf.train.get_checkpoint_state(logs_train_dir)
  46.             if ckpt and ckpt.model_checkpoint_path:
  47.                 global_step = ckpt.model_checkpoint_path.split('/')[-1].split('-')[-1]
  48.                 saver.restore(sess, ckpt.model_checkpoint_path)
  49.                 print('loading success,global_step is %s' % global_step)
  50.             else:
  51.                 print('no checkpoint file found')
  52.             # 将图片输入到模型计算
  53.             prediction = sess.run(logit, feed_dict={x: image_array})
  54.             # 获取输出结果中最大概率的索引
  55.             max_index = np.argmax(prediction)
  56.             if max_index == 0:
  57.                 print("this is a cat with possibility %.6f" % prediction[:, 0])
  58.             else:
  59.                 print("this is a dog with posiibility %.6f" % prediction[:, 1])
  60.  
  61.  
  62. evaluate_one_image()

model_2_gpu.py

  1. import tensorflow as tf
  2.  
  3. #输出各层参数
  4. def shape(value):
  5.     print(value.op.name,value.get_shape().as_list())
  6.  
  7. def inference(images, batch_size, n_classes):
  8.     #conv1
  9.     with tf.variable_scope('conv1') as scope:
  10.         weights = tf.get_variable('weights',
  11.                                   shape=[11,11,3,96],
  12.                                   dtype=tf.float32,
  13.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  14.         biases = tf.get_variable("biases",
  15.                                  shape=[96],
  16.                                  dtype=tf.float32,
  17.                                  initializer=tf.constant_initializer(0.1))
  18.         conv = tf.nn.conv2d(images, weights, strides=[1, 4, 4, 1], padding='SAME')
  19.         pre_activation = tf.nn.bias_add(conv, biases)
  20.         conv1 = tf.nn.relu(pre_activation, name=scope.name)
  21.  
  22.     with tf.variable_scope('pooling1_lrn') as scope:
  23.  
  24.         norm1 = tf.nn.lrn(conv1, depth_radius=2, bias=2.0, alpha=1e-4,
  25.                           beta=0.75, name='norm1')
  26.         pool1 = tf.nn.max_pool(norm1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  27.                                padding='VALID', name='pooling1')
  28.  
  29.     #conv2
  30.     with tf.variable_scope('conv2') as scope:
  31.         # 数据的分组处理，分组时则把输入数据和权重先划分后做卷积运算，卷积结束后再用concat()合并起来
  32.         pool1_groups = tf.split(axis=3, value=pool1, num_or_size_splits=2)
  33.         weights = tf.get_variable('weights',
  34.                                   shape=[5, 5, 48, 256],
  35.                                   dtype=tf.float32,
  36.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  37.         weights_groups = tf.split(axis=3, value=weights, num_or_size_splits=2)
  38.         conv_up = tf.nn.conv2d(pool1_groups[0], weights_groups[0], [1, 1, 1, 1], padding='SAME')
  39.         conv_down = tf.nn.conv2d(pool1_groups[1], weights_groups[1], [1, 1, 1, 1], padding='SAME')
  40.  
  41.         biases = tf.get_variable('biases',
  42.                                  shape=[256],
  43.                                  dtype=tf.float32,
  44.                                  initializer=tf.constant_initializer(0.1))
  45.  
  46.         biases_groups = tf.split(axis=0, value=biases, num_or_size_splits=2)
  47.         bias_up = tf.nn.bias_add(conv_up, biases_groups[0])
  48.         bias_down = tf.nn.bias_add(conv_down, biases_groups[1])
  49.         bias = tf.concat(axis=3, values=[bias_up, bias_down])
  50.         conv2 = tf.nn.relu(bias, name=scope.name)
  51.  
  52.     with tf.variable_scope('pooling2_lrn') as scope:
  53.         norm2 = tf.nn.lrn(conv2, depth_radius=2, bias=2.0, alpha=1e-4,
  54.                           beta=0.75, name='norm2')
  55.         pool2 = tf.nn.max_pool(norm2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  56.                                padding='VALID', name='pooling2')
  57.  
  58.     #conv3
  59.     with tf.variable_scope('conv3') as scope:
  60.         weights = tf.get_variable('weights',
  61.                                   shape=[3, 3, 256, 384],
  62.                                   dtype=tf.float32,
  63.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  64.         biases = tf.get_variable('biases',
  65.                                  shape=[384],
  66.                                  dtype=tf.float32,
  67.                                  initializer=tf.constant_initializer(0.1))
  68.         conv = tf.nn.conv2d(pool2, weights, strides=[1, 1, 1, 1], padding='SAME')
  69.         pre_activation = tf.nn.bias_add(conv, biases)
  70.         conv3 = tf.nn.relu(pre_activation, name='conv3')
  71.  
  72.     #conv4
  73.     with tf.variable_scope('conv4') as scope:
  74.         conv3_groups = tf.split(axis=3, value=conv3, num_or_size_splits=2)
  75.         weights = tf.get_variable('weights',
  76.                                   shape=[3, 3, 192, 384],
  77.                                   dtype=tf.float32,
  78.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  79.         weights_groups = tf.split(axis=3, value=weights, num_or_size_splits=2)
  80.         conv_up = tf.nn.conv2d(conv3_groups[0], weights_groups[0], [1, 1, 1, 1], padding='SAME')
  81.         conv_down = tf.nn.conv2d(conv3_groups[1], weights_groups[1], [1, 1, 1, 1], padding='SAME')
  82.  
  83.         biases = tf.get_variable('biases',
  84.                                  shape=[384],
  85.                                  dtype=tf.float32,
  86.                                  initializer=tf.constant_initializer(0.1))
  87.         biases_groups = tf.split(axis=0, value=biases, num_or_size_splits=2)
  88.         bias_up = tf.nn.bias_add(conv_up, biases_groups[0])
  89.         bias_down = tf.nn.bias_add(conv_down, biases_groups[1])
  90.         bias = tf.concat(axis=3, values=[bias_up, bias_down])
  91.         conv4 = tf.nn.relu(bias, name=scope.name)
  92.  
  93.     #conv5
  94.     with tf.variable_scope('conv5') as scope:
  95.         conv4_groups = tf.split(axis=3, value=conv4, num_or_size_splits=2)
  96.         weights = tf.get_variable('weights',
  97.                                   shape=[3, 3, 192, 256],
  98.                                   dtype=tf.float32,
  99.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  100.         weights_groups = tf.split(axis=3, value=weights, num_or_size_splits=2)
  101.         conv_up = tf.nn.conv2d(conv4_groups[0], weights_groups[0], [1, 1, 1, 1], padding='SAME')
  102.         conv_down = tf.nn.conv2d(conv4_groups[1], weights_groups[1], [1, 1, 1, 1], padding='SAME')
  103.  
  104.         biases = tf.get_variable('biases',
  105.                                  shape=[256],
  106.                                  dtype=tf.float32,
  107.                                  initializer=tf.constant_initializer(0.1))
  108.  
  109.         biases_groups = tf.split(axis=0, value=biases, num_or_size_splits=2)
  110.         bias_up = tf.nn.bias_add(conv_up, biases_groups[0])
  111.         bias_down = tf.nn.bias_add(conv_down, biases_groups[1])
  112.         bias = tf.concat(axis=3, values=[bias_up, bias_down])
  113.         conv5 = tf.nn.relu(bias, name=scope.name)
  114.  
  115.     with tf.variable_scope('pooling2_lrn') as scope:
  116.         norm5 = tf.nn.lrn(conv5, depth_radius=2, bias=2.0, alpha=1e-4,
  117.                           beta=0.75, name='norm5')
  118.         pool5 = tf.nn.max_pool(norm5, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  119.                                padding='VALID', name='pooling5')
  120.  
  121.  
  122.  
  123.     #fc6
  124.     with tf.variable_scope('fc6') as scope:
  125.         reshape = tf.reshape(pool5, shape=[batch_size, -1])
  126.         dim = reshape.get_shape()[1].value
  127.         weights = tf.get_variable('weights',
  128.                                   shape=[dim, 4096],
  129.                                   dtype=tf.float32,
  130.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  131.  
  132.         biases = tf.get_variable('biases',
  133.                                  shape=[4096],
  134.                                  dtype=tf.float32,
  135.                                  initializer=tf.constant_initializer(0.1))
  136.         fc6 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
  137.  
  138.         # dropout6
  139.         with tf.name_scope('dropout6') as scope:
  140.             dropout6 = tf.nn.dropout(fc6, 0.5)
  141.  
  142.     with tf.variable_scope('fc7') as scope:
  143.         weights = tf.get_variable('weights',
  144.                                   shape=[4096, 4096],
  145.                                   dtype=tf.float32,
  146.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  147.         biases = tf.get_variable('biases',
  148.                                  shape=[4096],
  149.                                  dtype=tf.float32,
  150.                                  initializer=tf.constant_initializer(0.1))
  151.         fc7 = tf.nn.relu(tf.matmul(dropout6, weights) + biases, name='fc7')
  152.         # dropout7
  153.         with tf.name_scope('dropout6') as scope:
  154.             dropout7 = tf.nn.dropout(fc7, 0.5)
  155.  
  156.     #fc8
  157.     with tf.variable_scope('fc8') as scope:
  158.         weights = tf.get_variable('fc8',
  159.                                   shape=[4096, n_classes],
  160.                                   dtype=tf.float32,
  161.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  162.         biases = tf.get_variable('biases',
  163.                                  shape=[n_classes],
  164.                                  dtype=tf.float32,
  165.                                  initializer=tf.constant_initializer(0.1))
  166.         fc8 = tf.add(tf.matmul(dropout7, weights), biases, name='fc8')
  167.  
  168.     return fc8
  169.  
  170.  
  171. def losses(logits, labels):
  172.     with tf.variable_scope('loss') as scope:
  173.         cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits \
  174.             (logits=logits, labels=labels, name='xentropy_per_example')
  175.  
  176.         loss = tf.reduce_mean(cross_entropy, name='loss')
  177.         tf.summary.scalar(scope.name + '/loss', loss)
  178.     return loss
  179.  
  180.  
  181. def training(loss, learning_rate):
  182.     with tf.name_scope('optimizer'):
  183.         optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate)
  184.         global_step = tf.Variable(0, name='global_step', trainable=False)
  185.         train_op = optimizer.minimize(loss, global_step=global_step)
  186.     return train_op
  187.  
  188.  
  189. def evaluation(logits, labels):
  190.     with tf.variable_scope('accuracy') as scope:
  191.         correct = tf.nn.in_top_k(logits, labels, 1)
  192.         correct = tf.cast(correct, tf.float16)
  193.         accuracy = tf.reduce_mean(correct)
  194.         tf.summary.scalar(scope.name + '/accuracy', accuracy)
  195.  
  196.     return accuracy

model_no_lrn.py

  1. import tensorflow as tf
  2.  
  3.  
  4. def inference(images, batch_size, n_classes):
  5.     #conv1
  6.     with tf.variable_scope('conv1') as scope:
  7.         weights = tf.get_variable('weights',
  8.                                   shape=[11,11,3,96],
  9.                                   dtype=tf.float32,
  10.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  11.         biases = tf.get_variable("biases",
  12.                                  shape=[96],
  13.                                  dtype=tf.float32,
  14.                                  initializer=tf.constant_initializer(0.1))
  15.         conv = tf.nn.conv2d(images, weights, strides=[1, 4, 4, 1], padding='SAME')
  16.         pre_activation = tf.nn.bias_add(conv, biases)
  17.         conv1 = tf.nn.relu(pre_activation, name=scope.name)
  18.  
  19.     with tf.variable_scope('pooling1_lrn') as scope:
  20.         pool1 = tf.nn.max_pool(conv1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  21.                                padding='SAME', name='pooling1')
  22.  
  23.  
  24.     #conv2
  25.     with tf.variable_scope('conv2') as scope:
  26.         weights = tf.get_variable('weights',
  27.                                   shape=[5, 5, 96, 256],
  28.                                   dtype=tf.float32,
  29.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  30.         biases = tf.get_variable('biases',
  31.                                  shape=[256],
  32.                                  dtype=tf.float32,
  33.                                  initializer=tf.constant_initializer(0.1))
  34.         conv = tf.nn.conv2d(pool1, weights, strides=[1, 1, 1, 1], padding='SAME')
  35.         pre_activation = tf.nn.bias_add(conv, biases)
  36.         conv2 = tf.nn.relu(pre_activation, name='conv2')
  37.  
  38.     with tf.variable_scope('pooling2_lrn') as scope:
  39.         pool2 = tf.nn.max_pool(conv2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  40.                                padding='SAME', name='pooling2')
  41.  
  42.     #conv3
  43.     with tf.variable_scope('conv3') as scope:
  44.         weights = tf.get_variable('weights',
  45.                                   shape=[3, 3, 256, 384],
  46.                                   dtype=tf.float32,
  47.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  48.         biases = tf.get_variable('biases',
  49.                                  shape=[384],
  50.                                  dtype=tf.float32,
  51.                                  initializer=tf.constant_initializer(0.1))
  52.         conv = tf.nn.conv2d(pool2, weights, strides=[1, 1, 1, 1], padding='SAME')
  53.         pre_activation = tf.nn.bias_add(conv, biases)
  54.         conv3 = tf.nn.relu(pre_activation, name='conv3')
  55.  
  56.     #conv4
  57.     with tf.variable_scope('conv4') as scope:
  58.         weights = tf.get_variable('weights',
  59.                                   shape=[3, 3, 384, 384],
  60.                                   dtype=tf.float32,
  61.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  62.         biases = tf.get_variable('biases',
  63.                                  shape=[384],
  64.                                  dtype=tf.float32,
  65.                                  initializer=tf.constant_initializer(0.1))
  66.         conv = tf.nn.conv2d(conv3, weights, strides=[1, 1, 1, 1], padding='SAME')
  67.         pre_activation = tf.nn.bias_add(conv, biases)
  68.         conv4 = tf.nn.relu(pre_activation, name='conv4')
  69.  
  70.     #conv5
  71.     with tf.variable_scope('conv5') as scope:
  72.         weights = tf.get_variable('weights',
  73.                                   shape=[3, 3, 384, 256],
  74.                                   dtype=tf.float32,
  75.                                   initializer=tf.truncated_normal_initializer(stddev=0.1, dtype=tf.float32))
  76.         biases = tf.get_variable('biases',
  77.                                  shape=[256],
  78.                                  dtype=tf.float32,
  79.                                  initializer=tf.constant_initializer(0.1))
  80.         conv = tf.nn.conv2d(conv4, weights, strides=[1, 1, 1, 1], padding='SAME')
  81.         pre_activation = tf.nn.bias_add(conv, biases)
  82.         conv5 = tf.nn.relu(pre_activation, name='conv5')
  83.  
  84.     with tf.variable_scope('pooling2_lrn') as scope:
  85.         norm5 = tf.nn.lrn(conv5, depth_radius=4, bias=1.0, alpha=0.001 / 9.0,
  86.                           beta=0.75, name='norm5')
  87.         pool5 = tf.nn.max_pool(norm5, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1],
  88.                                padding='SAME', name='pooling5')
  89.  
  90.  
  91.  
  92.     #fc6
  93.     with tf.variable_scope('fc6') as scope:
  94.         reshape = tf.reshape(pool5, shape=[batch_size, -1])
  95.         dim = reshape.get_shape()[1].value
  96.         weights = tf.get_variable('weights',
  97.                                   shape=[dim, 4096],
  98.                                   dtype=tf.float32,
  99.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  100.  
  101.         biases = tf.get_variable('biases',
  102.                                  shape=[4096],
  103.                                  dtype=tf.float32,
  104.                                  initializer=tf.constant_initializer(0.1))
  105.         fc6 = tf.nn.relu(tf.matmul(reshape, weights) + biases, name=scope.name)
  106.  
  107.         # dropout6
  108.         with tf.name_scope('dropout6') as scope:
  109.             dropout6 = tf.nn.dropout(fc6, 0.5)
  110.  
  111.     with tf.variable_scope('fc7') as scope:
  112.         weights = tf.get_variable('weights',
  113.                                   shape=[4096, 4096],
  114.                                   dtype=tf.float32,
  115.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  116.         biases = tf.get_variable('biases',
  117.                                  shape=[4096],
  118.                                  dtype=tf.float32,
  119.                                  initializer=tf.constant_initializer(0.1))
  120.         fc7 = tf.nn.relu(tf.matmul(dropout6, weights) + biases, name='fc7')
  121.         # dropout7
  122.         with tf.name_scope('dropout6') as scope:
  123.             dropout7 = tf.nn.dropout(fc7, 0.5)
  124.  
  125.     #fc8
  126.     with tf.variable_scope('fc8') as scope:
  127.         weights = tf.get_variable('fc8',
  128.                                   shape=[4096, n_classes],
  129.                                   dtype=tf.float32,
  130.                                   initializer=tf.truncated_normal_initializer(stddev=0.005, dtype=tf.float32))
  131.         biases = tf.get_variable('biases',
  132.                                  shape=[n_classes],
  133.                                  dtype=tf.float32,
  134.                                  initializer=tf.constant_initializer(0.1))
  135.         fc8 = tf.add(tf.matmul(dropout7, weights), biases, name='fc8')
  136.  
  137.     return fc8
  138.  
  139.  
  140. def losses(logits, labels):
  141.     with tf.variable_scope('loss') as scope:
  142.         cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits \
  143.             (logits=logits, labels=labels, name='xentropy_per_example')
  144.  
  145.         loss = tf.reduce_mean(cross_entropy, name='loss')
  146.         tf.summary.scalar(scope.name + '/loss', loss)
  147.     return loss
  148.  
  149.  
  150. def training(loss, learning_rate):
  151.     with tf.name_scope('optimizer'):
  152.         optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate)
  153.         global_step = tf.Variable(0, name='global_step', trainable=False)
  154.         train_op = optimizer.minimize(loss, global_step=global_step)
  155.     return train_op
  156.  
  157.  
  158. def evaluation(logits, labels):
  159.     with tf.variable_scope('accuracy') as scope:
  160.         correct = tf.nn.in_top_k(logits, labels, 1)
  161.         correct = tf.cast(correct, tf.float16)
  162.         accuracy = tf.reduce_mean(correct)
  163.         tf.summary.scalar(scope.name + '/accuracy', accuracy)
  164.  
  165.     return accuracy

总结

由于基础不好磕磕绊绊写了好久，也写了n多个版本，最后终于弄出像那么点样子的了。虽然代码看起来很简单，但是自己动手写，一点点深究，才发现并不简单，so，动手能力有待加强。

 

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号