分别使用tensorflow2.0版本与tensorflow1.13版本构建Squeezenet网络

SqueezeNet的网络结构就不在这里详细介绍，这里给出用tensorflow1.x版本和tensorflow2.x版本的代码实现。

首先给出tensorflow1.x版本的代码实现

# coding=utf-8
import tensorflow as tf
import numpy as np
import cv2
import pickle

POOLING_LAYERS = [1, 3, 5]
MODEL_PATH = 'data/squeeze_net/model.pkl'

class SqueezeNet(object):

  def __init__(self, imgs):
    self.imgs = tf.placeholder(tf.float32, [None, 224, 224, 3])
    self.imgs = imgs
    self.weights = {}
    self.net = {}
    self.build_model()

  # take  BGR 0~255 image, i.e. like the ones loaded by open CV
  def build_model(self):
    net = {}
    self.net = net
    self.model = pickle.load(open(MODEL_PATH, 'rb'),encoding='iso-8859-1')
    for k in self.model.keys():
      print(k, self.model[k].shape)
    # Caffe order is BGR, this model is RGB.
    # The mean values are from caffe protofile from DeepScale/SqueezeNet github repo.
    # self.mean = tf.constant([123.0, 117.0, 104.0],
    #                         dtype=tf.float32, shape=[1, 1, 1, 3], name='img_mean')
    self.mean = tf.constant(
        [104.0, 117.0, 123.0],
        dtype=tf.float32,
        shape=[1, 1, 1, 3],
        name='img_mean')
    images = self.imgs - self.mean
    # images = self.imgs-np.array([123.0, 117.0, 104.0]).reshape([1,1,1,3])
    # images = self.imgs-self.imgs

    # images = tf.transpose(images, [0,2,1,3])
    #net是一个字典
    net['input'] = images
    # conv1_1
    net['conv1'] = self.conv_layer(
        'conv1',
        net['input'],
        W=self.weight_variable(
            [3, 3, 3, 64],
            name='conv1_w',
            init=np.transpose(self.model['conv1_weights'], [2, 3, 1, 0])),
        stride=[1, 2, 2, 1],
        padding='VALID') + self.model['conv1_bias'][None, None, None, :]

    net['relu1'] = self.relu_layer(
        'relu1', net['conv1'], b=self.bias_variable([64], 'relu1_b', value=0.0))
    net['pool1'] = self.pool_layer('pool1', net['relu1'])

    net['fire2'] = self.fire_module('fire2', net['pool1'], 16, 64, 64)
    net['fire3'] = self.fire_module('fire3', net['fire2'], 16, 64, 64)
    net['pool3'] = self.pool_layer('pool3', net['fire3'], padding='SAME')

    net['fire4'] = self.fire_module('fire4', net['pool3'], 32, 128, 128)
    net['fire5'] = self.fire_module('fire5', net['fire4'], 32, 128, 128)
    net['pool5'] = self.pool_layer('pool5', net['fire5'], padding='SAME')

    net['fire6'] = self.fire_module('fire6', net['pool5'], 48, 192, 192)
    net['fire7'] = self.fire_module('fire7', net['fire6'], 48, 192, 192)
    net['fire8'] = self.fire_module('fire8', net['fire7'], 64, 256, 256)
    net['pool8'] = self.pool_layer('pool8', net['fire8'])
    net['fire9'] = self.fire_module('fire9', net['fire8'], 64, 256, 256)
    print(net['fire9'].shape)

    # 50% dropout removed
    #net['dropout9'] = tf.nn.dropout(net['fire9'], self.dropout)
    net['conv10'] = self.conv_layer(
        'conv10',
        net['fire9'],
        W=self.weight_variable(
            [1, 1, 512, 1000],
            name='conv10',
            init=np.transpose(self.model['conv10_weights'], [2, 3, 1, 0])),
        padding='VALID') + self.model['conv10_bias'][None, None, None, :]
    print(net['conv10'].shape)
    net['relu10'] = self.relu_layer(
        'relu10',
        net['conv10'],
        b=self.bias_variable([1000], 'relu10_b', value=0.0))
    print(net['relu10'].shape)
    net['pool10'] = self.pool_layer('pool10', net['relu10'], pooling_type='avg')
    print(net['pool10'].shape)
    avg_pool_shape = tf.shape(net['pool10'])

    net['pool_reshaped'] = tf.reshape(net['pool10'], [avg_pool_shape[0], -1])
    self.fc2 = net['pool_reshaped']
    self.logits = net['pool_reshaped']

    self.probs = tf.nn.softmax(self.logits)
    self.net = net

  def bias_variable(self, shape, name, value=0.1, from_caffe=False):
    if not from_caffe:
      self.weights[name] = tf.get_variable(
          'bias_' + name,
          initializer=tf.constant_initializer(value),
          shape=shape)
    else:
      self.weights[name] = tf.get_variable(
          'bias_' + name,
          initializer=tf.constant_initializer(value=value),
          shape=shape)
    return self.weights[name]

  def weight_variable(self, shape, name=None, init='xavier'):
    if init == 'variance':
      assert False
      initial = tf.get_variable(
          'W' + name,
          shape,
          initializer=tf.contrib.layers.variance_scaling_initializer())
    elif init == 'xavier':
      assert False
      initial = tf.get_variable(
          'W' + name, shape, initializer=tf.contrib.layers.xavier_initializer())
    else:
      assert isinstance(init, np.ndarray)
      print(name, init.shape)
      initial = tf.get_variable(
          'W' + name, shape, initializer=tf.constant_initializer(value=init))

    self.weights[name] = initial
    return self.weights[name]

  def relu_layer(self, layer_name, layer_input, b=None):
    if b:
      layer_input += b
    relu = tf.nn.relu(layer_input)
    return relu

  def pool_layer(self,
                 layer_name,
                 layer_input,
                 pooling_type='max',
                 padding='VALID'):
    if pooling_type == 'avg':
      pool = tf.nn.avg_pool(
          layer_input,
          ksize=[1, 14, 14, 1],
          strides=[1, 1, 1, 1],
          padding=padding)
    elif pooling_type == 'max':
      pool = tf.nn.max_pool(
          layer_input,
          ksize=[1, 3, 3, 1],
          strides=[1, 2, 2, 1],
          padding=padding)
    return pool

  def conv_layer(self,
                 layer_name,
                 layer_input,
                 W,
                 stride=[1, 1, 1, 1],
                 padding='VALID'):
    return tf.nn.conv2d(layer_input, W, strides=stride, padding=padding)

  def fire_module(self,
                  layer_name,
                  layer_input,
                  s1x1,
                  e1x1,
                  e3x3,
                  residual=False):
    """ Fire module consists of squeeze and expand convolutional layers. """
    fire = {}

    shape = layer_input.get_shape()

    # squeeze np.transpose(self.model['conv1_weights'], [2,3,1,0])),
    s1_weight = self.weight_variable(
        [1, 1, int(shape[3]), s1x1], layer_name + '_s1_weight',
        np.transpose(
            self.model[layer_name + '/' + 'squeeze1x1_weights'],
            axes=[2, 3, 1, 0]))

    # expand
    e1_weight = self.weight_variable(
        [1, 1, s1x1, e1x1], layer_name + '_e1',
        np.transpose(
            self.model[layer_name + '/' + 'expand1x1_weights'],
            axes=[2, 3, 1, 0]))
    e3_weight = self.weight_variable(
        [3, 3, s1x1, e3x3], layer_name + '_e3',
        np.transpose(
            self.model[layer_name + '/' + 'expand3x3_weights'],
            axes=[2, 3, 1, 0]))

    fire['s1'] = self.conv_layer(
        layer_name + '_s1', layer_input, W=s1_weight, padding='SAME')
    fire['relu1'] = self.relu_layer(
        layer_name + '_relu1',
        fire['s1'],
        b=self.bias_variable([s1x1], layer_name + '_fire_bias_s1'))

    fire['e1'] = self.conv_layer(
        layer_name + '_e1', fire['relu1'], W=e1_weight,
        padding='SAME')  # 'SAME' and 'VALID' padding should be the same here
    fire['e3'] = self.conv_layer(
        layer_name + '_e3', fire['relu1'], W=e3_weight, padding='SAME')
    fire['concat'] = tf.concat([
        tf.add(fire['e1'],
               self.bias_variable(
                   [e1x1],
                   name=layer_name + '_fire_bias_e1',
                   value=self.model[layer_name + '/' + 'expand1x1_bias'])),
        tf.add(fire['e3'],
               self.bias_variable(
                   [e3x3],
                   name=layer_name + '_fire_bias_e3',
                   value=self.model[layer_name + '/' + 'expand3x3_bias']))
    ], 3)

    if residual:
      fire['relu2'] = self.relu_layer(layer_name + 'relu2_res',
                                      tf.add(fire['concat'], layer_input))
    else:
      fire['relu2'] = self.relu_layer(layer_name + '_relu2', fire['concat'])
    self.net[layer_name + '_debug'] = fire['relu2']
    return fire['relu2']

  def get_features_out(self):
    return self.net['pool8']


z = tf.random.normal([16,224,224,3])
s = Squeezenet()
print(s(z).shape)

 

接下来给出tensorflow2.x版本的代码实现

import tensorflow as tf
import numpy as np
import random


class Fire(tf.keras.Model):
    def __init__(self,filters_1,filters_2):
        super().__init__()
        self.squeeze = tf.keras.layers.Conv2D(filters = filters_1,kernel_size = 1,strides = 1,padding='SAME',activation=tf.nn.relu)
        self.expand_1 = tf.keras.layers.Conv2D(filters = filters_2,kernel_size = 1,strides = 1,padding='SAME',activation=tf.nn.relu)
        self.expand_3 = tf.keras.layers.Conv2D(filters = filters_2,kernel_size = 3,strides = 1,padding='SAME',activation=tf.nn.relu)

    def call(self,inputs):
        x = self.squeeze(inputs)
        x1 = self.expand_1(x)
        x2 = self.expand_3(x)

        return tf.concat([x1, x2], axis=3)


class Squeezenet(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(filters=96, kernel_size=7, strides=2, padding='SAME', activation=tf.nn.relu)
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=3, strides=2)
        self.conv2 = tf.keras.layers.Conv2D(filters=1000, kernel_size=1, strides=1, padding='SAME',activation=tf.nn.relu)
        self.pool2 = tf.keras.layers.AveragePooling2D(pool_size=13, strides=1)
        self.flatten = tf.keras.layers.Flatten()
        self.fc1 = tf.keras.layers.Dense(10, activation=tf.nn.softmax)
    def call(self,inputs):
        print(inputs.shape)
        x = self.conv1(inputs)
        print(x.shape)
        fir1 = Fire(16,64)
        x = fir1(x)
        print(x.shape)
        fir2 = Fire(16,64)
        x1 = fir2(x)
        fir3 = Fire(32,128)
        x = fir3(x1)
        x = self.pool1(x)
        fir4 = Fire(32,128)
        x = fir4(x)
        fire5 = Fire(48,192)
        x = fire5(x)
        fir6 = Fire(48,192)
        x = fir6(x)
        fir7 = Fire(64,256)
        x = fir7(x)
        x = self.pool1(x)
        fir8 = Fire(64,256)
        x = fir8(x)
        x = self.conv2(x)
        x = self.pool2(x)
        x = self.flatten(x)
        out = self.fc1(x)
        return out

z = tf.random.normal([16,224,224,3])
s = Squeezenet()
print(s(z).shape)