def __init__(self, n_channel=3, n_classes=10, image_size=24, n_layers=20): # 设置超参数 self.n_channel = n_channel self.n_classes = n_classes self.image_size = image_size self.n_layers = n_layers # 输入变量 self.images = tf.placeholder( dtype=tf.float32, shape=[None, self.image_size, self.image_size, self.n_channel], name='images') self.labels = tf.placeholder( dtype=tf.int64, shape=[None], name='labels') self.keep_prob = tf.placeholder( dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable( 0, dtype=tf.int32, name='global_step') # 网络输出 conv_layer1 = ConvLayer( input_shape=(None, image_size, image_size, n_channel), n_size=3, n_filter=3, stride=1,activation='relu', batch_normal=True, weight_decay=1e-4, name='conv1') # 数据流 basic_conv = conv_layer1.get_output(input=self.images) # basic_conv = conv_layer1.get_output(input=self.images) with slim.arg_scope(squeezenet_arg_scope()): self.logits_1 = self.plain_cnn_inference(images=basic_conv, n_layers=14, scope_name='net_1') # 目标函数 self.objective_1 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1, labels=self.labels)) self.objective = self.objective_1 tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond(tf.less(self.global_step, 50000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 100000), lambda: tf.constant(0.005), lambda: tf.cond(tf.less(self.global_step, 150000), lambda: tf.constant(0.0025), lambda: tf.constant(0.001)))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 correct_prediction_1 = tf.equal(self.labels, tf.argmax(self.logits_1, 1)) self.accuracy_1 = tf.reduce_mean(tf.cast(correct_prediction_1, 'float'))
def __init__(self, n_channel=3, n_classes=10, image_size=24): # 输入变量 self.images = tf.placeholder( dtype=tf.float32, shape=[None, image_size, image_size, n_channel], name='images') self.labels = tf.placeholder(dtype=tf.int64, shape=[None], name='labels') self.keep_prob = tf.placeholder(dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable(0, dtype=tf.int32, name='global_step') # 网络结构 conv_layer1 = ConvLayer(input_shape=(None, image_size, image_size, n_channel), n_size=3, n_filter=64, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv1') pool_layer1 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool1') conv_layer2 = ConvLayer(input_shape=(None, int(image_size / 2), int(image_size / 2), 64), n_size=3, n_filter=128, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv2') pool_layer2 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool2') conv_layer3 = ConvLayer(input_shape=(None, int(image_size / 4), int(image_size / 4), 128), n_size=3, n_filter=256, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv3') pool_layer3 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool3') dense_layer1 = DenseLayer(input_shape=(None, int(image_size / 8) * int(image_size / 8) * 256), hidden_dim=1024, activation='relu', dropout=True, keep_prob=self.keep_prob, batch_normal=True, weight_decay=1e-4, name='dense1') dense_layer2 = DenseLayer(input_shape=(None, 1024), hidden_dim=n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense2') # 数据流 hidden_conv1 = conv_layer1.get_output(input=self.images) hidden_pool1 = pool_layer1.get_output(input=hidden_conv1) hidden_conv2 = conv_layer2.get_output(input=hidden_pool1) hidden_pool2 = pool_layer2.get_output(input=hidden_conv2) hidden_conv3 = conv_layer3.get_output(input=hidden_pool2) hidden_pool3 = pool_layer3.get_output(input=hidden_conv3) input_dense1 = tf.reshape( hidden_pool3, [-1, int(image_size / 8) * int(image_size / 8) * 256]) output_dense1 = dense_layer1.get_output(input=input_dense1) logits = dense_layer2.get_output(input=output_dense1) # 目标函数 self.objective = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=self.labels)) tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond( tf.less(self.global_step, 50000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 100000), lambda: tf. constant(0.001), lambda: tf.constant(0.0001))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 correct_prediction = tf.equal(self.labels, tf.argmax(logits, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
def __init__(self, n_channel=3, n_classes=10, image_size=24): # 输入变量 self.images = tf.placeholder( dtype=tf.float32, shape=[None, image_size, image_size, n_channel], name='images') self.labels = tf.placeholder( dtype=tf.int64, shape=[None], name='labels') self.keep_prob = tf.placeholder( dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable( 0, dtype=tf.int32, name='global_step') # 网络结构 conv_layer1 = ConvLayer( input_shape=(None, image_size, image_size, n_channel), n_size=3, n_filter=64, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv1') pool_layer1 = PoolLayer( n_size=2, stride=2, mode='max', resp_normal=True, name='pool1') conv_layer2 = ConvLayer( input_shape=(None, int(image_size/2), int(image_size/2), 64), n_size=3, n_filter=128, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv2') pool_layer2 = PoolLayer( n_size=2, stride=2, mode='max', resp_normal=True, name='pool2') conv_layer3 = ConvLayer( input_shape=(None, int(image_size/4), int(image_size/4), 128), n_size=3, n_filter=256, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv3') pool_layer3 = PoolLayer( n_size=2, stride=2, mode='max', resp_normal=True, name='pool3') dense_layer1 = DenseLayer( input_shape=(None, int(image_size/8) * int(image_size/8) * 256), hidden_dim=1024, activation='relu', dropout=True, keep_prob=self.keep_prob, batch_normal=True, weight_decay=1e-4, name='dense1') dense_layer2 = DenseLayer( input_shape=(None, 1024), hidden_dim=n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense2') # 数据流 hidden_conv1 = conv_layer1.get_output(input=self.images) hidden_pool1 = pool_layer1.get_output(input=hidden_conv1) hidden_conv2 = conv_layer2.get_output(input=hidden_pool1) hidden_pool2 = pool_layer2.get_output(input=hidden_conv2) hidden_conv3 = conv_layer3.get_output(input=hidden_pool2) hidden_pool3 = pool_layer3.get_output(input=hidden_conv3) input_dense1 = tf.reshape(hidden_pool3, [-1, int(image_size/8) * int(image_size/8) * 256]) output_dense1 = dense_layer1.get_output(input=input_dense1) logits = dense_layer2.get_output(input=output_dense1) # 目标函数 self.objective = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=logits, labels=self.labels)) tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond(tf.less(self.global_step, 50000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 100000), lambda: tf.constant(0.001), lambda: tf.constant(0.0001))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 correct_prediction = tf.equal(self.labels, tf.argmax(logits, 1)) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float'))
def __init__(self, n_channel=3, n_classes=10, image_size=24, n_layers=44,is_training =True): # 设置超参数 self.n_channel = n_channel self.n_classes = n_classes self.image_size = image_size self.n_layers = n_layers self.is_training = is_training # 输入变量 self.images = tf.placeholder( dtype=tf.float32, shape=[None, self.image_size, self.image_size, self.n_channel], name='images') self.labels = tf.placeholder( dtype=tf.int64, shape=[None], name='labels') self.keep_prob = tf.placeholder( dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable( 0, dtype=tf.int32, name='global_step') # 网络输出 conv_layer1 = ConvLayer( input_shape=(None, image_size, image_size, n_channel), n_size=3, n_filter=3, stride=1,activation='relu', batch_normal=True, weight_decay=1e-4, name='conv1') dense_layer_1 = DenseLayer( input_shape=(None, 512), hidden_dim=self.n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense_layer_1') dense_layer_2 = DenseLayer( input_shape=(None, 490), hidden_dim=self.n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense_layer_2') dense_layer_3 = DenseLayer( input_shape=(None, 200), hidden_dim=self.n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense_layer_3') # 数据流 #父层 basic_conv = conv_layer1.get_output(input=self.images) #子层1 hidden_conv_1 = self.residual_inference(images=basic_conv, scope_name='net_1_1') hidden_conv_1 = self.son_google_v2_part(hidden_conv_1,'net_1_2') input_dense_1 = tf.reduce_mean(hidden_conv_1, reduction_indices=[1, 2]) self.logits_1 = dense_layer_1.get_output(input=input_dense_1) #子层1--孙1 densenet self.logits_1_1 = self.grand_son_1_1(hidden_conv_1,scope_name='grand_son_1') #子层1--孙2 densenet_bc self.logits_1_2 = self.grand_son_1_2(hidden_conv_1,scope_name='grand_son_2') # 子层1--孙3 mobilenet --- depth conv self.logits_1_3 = self.grand_son_1_3(hidden_conv_1, scope_name='grand_son_3') #子层2 hidden_conv_2 = self.residual_inference(images=basic_conv, scope_name='net_2_1') hidden_conv_2 = self.son_google_v3_part_2(hidden_conv_2,'net_2_2') # global average pooling input_dense_2 = tf.reduce_mean(hidden_conv_2, reduction_indices=[1, 2]) self.logits_2 = dense_layer_2.get_output(input=input_dense_2) # 子层3 hidden_conv_3 = self.residual_inference(images=basic_conv, scope_name='net_3_1') hidden_conv_3 =self.son_cnn_part_3(hidden_conv_3,scope_name='net_3_2') # global average pooling input_dense_3= tf.reduce_mean(hidden_conv_3, reduction_indices=[1, 2]) self.logits_3 = dense_layer_3.get_output(input=input_dense_3) # 目标函数 self.objective_1 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1, labels=self.labels)) self.objective_1_1 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1_1, labels=self.labels)) self.objective_1_2 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1_2, labels=self.labels)) self.objective_1_3 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1_3, labels=self.labels)) self.objective_2 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_2, labels=self.labels)) self.objective_3 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_3, labels=self.labels)) # self.objective_4 = tf.reduce_sum( # tf.nn.sparse_softmax_cross_entropy_with_logits( # logits=self.logits_4, labels=self.labels)) # # self.objective_5 = tf.reduce_sum( # tf.nn.sparse_softmax_cross_entropy_with_logits( # logits=self.logits_5, labels=self.labels)) self.objective = \ self.objective_1 + self.objective_1_1 +self.objective_1_2 +self.objective_1_3 \ +self.objective_2 \ +self.objective_3 tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond(tf.less(self.global_step, 50000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 75000), lambda: tf.constant(0.005), lambda: tf.cond(tf.less(self.global_step, 100000), lambda: tf.constant(0.001), lambda: tf.constant(0.001)))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 #son1 correct_prediction_1 = tf.equal(self.labels, tf.argmax(self.logits_1, 1)) self.accuracy_1 = tf.reduce_mean(tf.cast(correct_prediction_1, 'float')) # 观察值 grand son1 correct_prediction_1_1 = tf.equal(self.labels, tf.argmax(self.logits_1_1, 1)) self.accuracy_1_1 = tf.reduce_mean(tf.cast(correct_prediction_1_1, 'float')) # 观察值 grand son2 correct_prediction_1_2 = tf.equal(self.labels, tf.argmax(self.logits_1_2, 1)) self.accuracy_1_2 = tf.reduce_mean(tf.cast(correct_prediction_1_2, 'float')) # 观察值 grand son3 correct_prediction_1_3 = tf.equal(self.labels, tf.argmax(self.logits_1_3, 1)) self.accuracy_1_3 = tf.reduce_mean(tf.cast(correct_prediction_1_3, 'float')) # son2 correct_prediction_2 = tf.equal(self.labels, tf.argmax(self.logits_2, 1)) self.accuracy_2 = tf.reduce_mean(tf.cast(correct_prediction_2, 'float')) # son3 correct_prediction_3 = tf.equal(self.labels, tf.argmax(self.logits_3, 1)) self.accuracy_3 = tf.reduce_mean(tf.cast(correct_prediction_3, 'float'))
def net_2(hidden_pool1, keep_prob, image_size, n_classes): with tf.variable_scope('net_2'): conv_layer2_2 = ConvLayer(input_shape=(None, int(image_size / 2), int(image_size / 2), 64), n_size=3, n_filter=128, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv2') pool_layer2_2 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool2') conv_layer3_2 = ConvLayer(input_shape=(None, int(image_size / 4), int(image_size / 4), 128), n_size=3, n_filter=256, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv3') pool_layer3_2 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool3') dense_layer1_2 = DenseLayer(input_shape=(None, int(image_size / 8) * int(image_size / 8) * 256), hidden_dim=1024, activation='relu', dropout=True, keep_prob=keep_prob, batch_normal=True, weight_decay=1e-4, name='dense1') dense_layer2_2 = DenseLayer(input_shape=(None, 1024), hidden_dim=n_classes, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense2') # net 1 hidden_conv2_2 = conv_layer2_2.get_output(input=hidden_pool1) hidden_pool2_2 = pool_layer2_2.get_output(input=hidden_conv2_2) hidden_conv3_2 = conv_layer3_2.get_output(input=hidden_pool2_2) hidden_pool3_2 = pool_layer3_2.get_output(input=hidden_conv3_2) input_dense1_2 = tf.reshape( hidden_pool3_2, [-1, int(image_size / 8) * int(image_size / 8) * 256]) output_dense1_2 = dense_layer1_2.get_output(input=input_dense1_2) logits_2 = dense_layer2_2.get_output(input=output_dense1_2) return logits_2
def __init__(self, n_channel=3, n_classes=10, image_size=24): # 输入变量 self.images = tf.placeholder( dtype=tf.float32, shape=[None, image_size, image_size, n_channel], name='images') self.labels = tf.placeholder(dtype=tf.int64, shape=[None], name='labels') self.keep_prob = tf.placeholder(dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable(0, dtype=tf.int32, name='global_step') # 网络结构 conv_layer1 = ConvLayer(input_shape=(None, image_size, image_size, n_channel), n_size=3, n_filter=64, stride=1, activation='relu', batch_normal=True, weight_decay=1e-4, name='conv1') pool_layer1 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=True, name='pool1') # 数据流 hidden_conv1 = conv_layer1.get_output(input=self.images) hidden_pool1 = pool_layer1.get_output(input=hidden_conv1) #net_1 self.logits_1 = net_1(hidden_pool1, self.keep_prob, image_size, n_classes) #net 2 self.logits_2 = net_2(hidden_pool1, self.keep_prob, image_size, n_classes) #net 3 self.logits_3 = net_3(hidden_pool1, self.keep_prob, image_size, n_classes) # 目标函数 self.objective_1 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_1, labels=self.labels)) self.objective_2 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_2, labels=self.labels)) self.objective_3 = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits( logits=self.logits_3, labels=self.labels)) self.objective = self.objective_1 + self.objective_2 + self.objective_3 tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond( tf.less(self.global_step, 50000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 100000), lambda: tf. constant(0.001), lambda: tf.constant(0.0001))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 correct_prediction_1 = tf.equal(self.labels, tf.argmax(self.logits_1, 1)) self.accuracy_1 = tf.reduce_mean(tf.cast(correct_prediction_1, 'float')) correct_prediction_2 = tf.equal(self.labels, tf.argmax(self.logits_2, 1)) self.accuracy_2 = tf.reduce_mean(tf.cast(correct_prediction_2, 'float')) correct_prediction_3 = tf.equal(self.labels, tf.argmax(self.logits_3, 1)) self.accuracy_3 = tf.reduce_mean(tf.cast(correct_prediction_3, 'float'))
def inference(self, images): # 网络结构 conv_layer1 = ConvLayer(input_shape=(self.batch_size, self.image_size, self.image_size, self.n_channel), n_size=3, n_filter=16, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv1') pool_layer1 = PoolLayer(input_shape=(self.batch_size, self.image_size, self.image_size, 16), n_size=2, stride=2, mode='max', resp_normal=False, name='pool1') conv_layer2 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 2), int(self.image_size / 2), 16), n_size=3, n_filter=32, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv2') pool_layer2 = PoolLayer(input_shape=(self.batch_size, int(self.image_size / 2), int(self.image_size / 2), 32), n_size=2, stride=2, mode='max', resp_normal=False, name='pool2') conv_layer3 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 4), int(self.image_size / 4), 32), n_size=3, n_filter=64, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv3') pool_layer3 = PoolLayer(input_shape=(self.batch_size, int(self.image_size / 4), int(self.image_size / 4), 64), n_size=2, stride=2, mode='max', resp_normal=False, name='pool3') conv_layer4 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 8), int(self.image_size / 8), 64), n_size=3, n_filter=128, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv4') pool_layer4 = PoolLayer(input_shape=(self.batch_size, int(self.image_size / 8), int(self.image_size / 8), 128), n_size=2, stride=2, mode='max', resp_normal=False, name='pool4') conv_layer5 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 16), int(self.image_size / 16), 128), n_size=3, n_filter=256, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv5') pool_layer5 = PoolLayer(input_shape=(self.batch_size, int(self.image_size / 16), int(self.image_size / 16), 256), n_size=2, stride=2, mode='max', resp_normal=False, name='pool5') conv_layer6 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 32), int(self.image_size / 32), 256), n_size=3, n_filter=512, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv6') pool_layer6 = PoolLayer(input_shape=(self.batch_size, int(self.image_size / 32), int(self.image_size / 32), 512), n_size=2, stride=2, mode='max', resp_normal=False, name='pool6') conv_layer7 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 64), int(self.image_size / 64), 512), n_size=3, n_filter=1024, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv7') conv_layer8 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 64), int(self.image_size / 64), 1024), n_size=3, n_filter=1024, stride=1, activation='leaky_relu', batch_normal=True, weight_decay=5e-4, name='conv8') conv_layer9 = ConvLayer(input_shape=(self.batch_size, int(self.image_size / 64), int(self.image_size / 64), 1024), n_size=1, n_filter=self.n_boxes * 5, stride=1, activation='none', batch_normal=False, weight_decay=5e-4, name='conv9') # 数据流 print('\n%-10s\t%-20s\t%-20s\t%s' % ('Name', 'Filter', 'Input', 'Output')) hidden_conv1 = conv_layer1.get_output(input=images) hidden_pool1 = pool_layer1.get_output(input=hidden_conv1) hidden_conv2 = conv_layer2.get_output(input=hidden_pool1) hidden_pool2 = pool_layer2.get_output(input=hidden_conv2) hidden_conv3 = conv_layer3.get_output(input=hidden_pool2) hidden_pool3 = pool_layer3.get_output(input=hidden_conv3) hidden_conv4 = conv_layer4.get_output(input=hidden_pool3) hidden_pool4 = pool_layer4.get_output(input=hidden_conv4) hidden_conv5 = conv_layer5.get_output(input=hidden_pool4) hidden_pool5 = pool_layer5.get_output(input=hidden_conv5) hidden_conv6 = conv_layer6.get_output(input=hidden_pool5) hidden_pool6 = pool_layer6.get_output(input=hidden_conv6) hidden_conv7 = conv_layer7.get_output(input=hidden_pool6) hidden_conv8 = conv_layer8.get_output(input=hidden_conv7) hidden_conv9 = conv_layer9.get_output(input=hidden_conv8) logits = hidden_conv9 print() sys.stdout.flush() # 网络输出 return logits
class ConvNet(): def __init__(self, n_channel, n_classes, image_height, image_width, sentence_length, vocab_size, embedding_dim, LSTM_hidden_size): # 输入变量 self.images1 = tf.placeholder( dtype=tf.float32, shape=[None, image_height, image_width, n_channel], name='images') self.images2 = tf.placeholder( dtype=tf.float32, shape=[None, image_height, image_width, n_channel], name='images') self.labels = tf.placeholder(dtype=tf.int64, shape=[None], name='labels') ''' self.instructions = tf.placeholder( dtype=tf.int64, shape=[None, sentence_length], name='instructions') ''' self.keep_prob = tf.placeholder(dtype=tf.float32, name='keep_prob') self.global_step = tf.Variable(0, dtype=tf.int32, name='global_step') # CNN网络结构 self.conv_layer1 = ConvLayer(input_shape=(None, image_height, image_width, n_channel), n_size=3, n_filter=64, stride=1, activation='relu', batch_normal=False, weight_decay=1e-4, name='conv1') self.pool_layer1 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=False, name='pool1') self.conv_layer2 = ConvLayer(input_shape=(None, int(image_height / 2), int(image_width / 2), 64), n_size=3, n_filter=128, stride=1, activation='relu', batch_normal=False, weight_decay=1e-4, name='conv2') self.pool_layer2 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=False, name='pool2') self.conv_layer3 = ConvLayer(input_shape=(None, int(image_height / 4), int(image_width / 4), 128), n_size=3, n_filter=256, stride=1, activation='relu', batch_normal=False, weight_decay=1e-4, name='conv3') self.pool_layer3 = PoolLayer(n_size=2, stride=2, mode='max', resp_normal=False, name='pool3') self.dense_layer1 = DenseLayer( input_shape=(None, int(image_height / 8) * int(image_width / 8) * 256), hidden_dim=1024, activation='relu', dropout=True, keep_prob=self.keep_prob, batch_normal=False, weight_decay=1e-4, name='dense1') self.dense_layer2 = DenseLayer(input_shape=(None, 1024), hidden_dim=512, activation='none', dropout=False, keep_prob=None, batch_normal=False, weight_decay=1e-4, name='dense2') # CNN数据流 cnn_output1 = self.get_output(self.images1, image_height, image_width) cnn_output2 = self.get_output(self.images2, image_height, image_width) ''' #LSTM embedding = tf.get_variable("embedding", [vocab_size, embedding_dim]) # [19, 128] input_embeddings = tf.nn.embedding_lookup(embedding, self.instructions) # [batch_size, 5, 128] instruc_cell = tf.nn.rnn_cell.BasicLSTMCell(LSTM_hidden_size) # LSTM_hidden_size = 128 lstm_outputs, lstm_state = tf.nn.dynamic_rnn(instruc_cell, input_embeddings, dtype=tf.float32) #[batch_size, 5, 128] lstm_output = lstm_outputs[:, -1, :] #[batch_size, 128] ''' #predict fully_connected1 = DenseLayer(input_shape=(None, 512), hidden_dim=256, activation='relu', dropout=False, keep_prob=self.keep_prob, batch_normal=False, weight_decay=1e-4, name='fc1') fully_connected2 = DenseLayer(input_shape=(None, 256), hidden_dim=n_classes, activation='relu', dropout=False, keep_prob=self.keep_prob, batch_normal=False, weight_decay=1e-4, name='fc2') multi_output = tf.multiply(cnn_output1, cnn_output2, name='element_wise_multiplication') output_fc1 = fully_connected1.get_output(input=multi_output) logits = fully_connected2.get_output(input=output_fc1) logit = tf.argmax(logits, 1, name='predicted_class') # 目标函数 self.objective = tf.reduce_sum( tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=self.labels)) tf.add_to_collection('losses', self.objective) self.avg_loss = tf.add_n(tf.get_collection('losses')) # 优化器 lr = tf.cond( tf.less(self.global_step, 5000), lambda: tf.constant(0.01), lambda: tf.cond(tf.less(self.global_step, 10000), lambda: tf. constant(0.001), lambda: tf.constant(0.0001))) self.optimizer = tf.train.AdamOptimizer(learning_rate=lr).minimize( self.avg_loss, global_step=self.global_step) # 观察值 correct_prediction = tf.equal(self.labels, logit) self.accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float')) def get_output(self, input, image_height, image_width): hidden_conv1 = self.conv_layer1.get_output(input=input) hidden_pool1 = self.pool_layer1.get_output(input=hidden_conv1) hidden_conv2 = self.conv_layer2.get_output(input=hidden_pool1) hidden_pool2 = self.pool_layer2.get_output(input=hidden_conv2) hidden_conv3 = self.conv_layer3.get_output(input=hidden_pool2) hidden_pool3 = self.pool_layer3.get_output(input=hidden_conv3) input_dense1 = tf.reshape( hidden_pool3, [-1, int(image_height / 8) * int(image_width / 8) * 256]) output_dense1 = self.dense_layer1.get_output(input=input_dense1) cnn_output = self.dense_layer2.get_output(input=output_dense1) #logit = tf.argmax(logits, 1, name='predicted_class') return cnn_output def train(self, dataloader, backup_path, n_epoch=5, batch_size=128): # 构建会话 gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.45) self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) # 模型保存器 self.saver = tf.train.Saver(var_list=tf.global_variables(), write_version=tf.train.SaverDef.V2, max_to_keep=10) # 模型初始化 self.sess.run(tf.global_variables_initializer()) # 模型训练 for epoch in range(0, n_epoch + 1): train_images1 = dataloader.train_images1 train_images2 = dataloader.train_images2 #train_instructions = dataloader.train_instructions train_labels = dataloader.train_labels valid_images1 = dataloader.valid_images1 valid_images2 = dataloader.valid_images2 #valid_instructions = dataloader.valid_instructions valid_labels = dataloader.valid_labels # 开始本轮的训练,并计算目标函数值 train_accuracy, train_loss = 0.0, 0.0 for i in range(0, dataloader.n_train, batch_size): batch_images1 = train_images1[i:i + batch_size] batch_images2 = train_images2[i:i + batch_size] #batch_instructions = train_instructions[i: i+batch_size] batch_labels = train_labels[i:i + batch_size] [_, avg_accuracy, avg_loss, iteration] = self.sess.run( fetches=[ self.optimizer, self.accuracy, self.avg_loss, self.global_step ], feed_dict={ self.images1: batch_images1, self.images2: batch_images2, #self.instructions: batch_instructions, self.labels: batch_labels, self.keep_prob: 0.5 }) train_accuracy += avg_accuracy * batch_images1.shape[0] train_loss += avg_loss * batch_images1.shape[0] train_accuracy = 1.0 * train_accuracy / dataloader.n_train train_loss = 1.0 * train_loss / dataloader.n_train # 在训练之后,获得本轮的验证集损失值和准确率 valid_accuracy, valid_loss = 0.0, 0.0 for i in range(0, dataloader.n_valid, batch_size): batch_images1 = valid_images1[i:i + batch_size] batch_images2 = valid_images2[i:i + batch_size] #batch_instructions = valid_instructions[i: i+batch_size] batch_labels = valid_labels[i:i + batch_size] [avg_accuracy, avg_loss] = self.sess.run( fetches=[self.accuracy, self.avg_loss], feed_dict={ self.images1: batch_images1, self.images2: batch_images2, #self.instructions: batch_instructions, self.labels: batch_labels, self.keep_prob: 1.0 }) valid_accuracy += avg_accuracy * batch_images1.shape[0] valid_loss += avg_loss * batch_images1.shape[0] valid_accuracy = 1.0 * valid_accuracy / dataloader.n_valid valid_loss = 1.0 * valid_loss / dataloader.n_valid print( 'epoch{%d}, iter[%d], train precision: %.6f, train loss: %.6f, ' 'valid precision: %.6f, valid loss: %.6f' % (epoch, iteration, train_accuracy, train_loss, valid_accuracy, valid_loss)) sys.stdout.flush() # 保存模型 if not os.path.exists(backup_path): os.makedirs(backup_path) saver_path = self.saver.save( self.sess, os.path.join(backup_path, 'model_%d.ckpt' % (epoch))) self.sess.close() def test(self, dataloader, backup_path, epoch, batch_size=128): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.25) self.sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options)) # 读取模型 self.saver = tf.train.Saver(write_version=tf.train.SaverDef.V2) model_path = os.path.join(backup_path, 'model_%d.ckpt' % (epoch)) assert (os.path.exists(model_path + '.index')) self.saver.restore(self.sess, model_path) print('read model from %s' % (model_path)) # 在测试集上计算准确率 accuracy_list = [] test_images = dataloader.data_augmentation(dataloader.test_images, flip=False, crop=True, crop_shape=(24, 24, 3), whiten=True, noise=False) test_labels = dataloader.test_labels for i in range(0, dataloader.n_test, batch_size): batch_images = test_images[i:i + batch_size] batch_labels = test_labels[i:i + batch_size] [avg_accuracy] = self.sess.run(fetches=[self.accuracy], feed_dict={ self.images: batch_images, self.labels: batch_labels, self.keep_prob: 1.0 }) accuracy_list.append(avg_accuracy) print('test precision: %.4f' % (numpy.mean(accuracy_list))) self.sess.close() def debug(self): sess = tf.Session() sess.run(tf.global_variables_initializer()) [temp] = sess.run(fetches=[self.observe], feed_dict={ self.images: numpy.random.random(size=[128, 24, 24, 3]), self.labels: numpy.random.randint(low=0, high=9, size=[ 128, ]), self.keep_prob: 1.0 }) print(temp) def observe_salience(self, batch_size=128, image_h=32, image_w=32, n_channel=3, num_test=10, epoch=1): if not os.path.exists('results/epoch%d/' % (epoch)): os.makedirs('results/epoch%d/' % (epoch)) saver = tf.train.Saver(write_version=tf.train.SaverDef.V2) sess = tf.Session() # 读取模型 model_path = 'backup/cifar10/model_%d.ckpt' % (epoch) assert (os.path.exists(model_path + '.index')) saver.restore(sess, model_path) print('read model from %s' % (model_path)) # 获取图像并计算梯度 for batch in range(num_test): batch_image, batch_label = cifar10.test.next_batch(batch_size) image = numpy.array( batch_image.reshape([image_h, image_w, n_channel]) * 255, dtype='uint8') result = sess.run( [ self.labels_prob, self.labels_max_prob, self.labels_pred, self.gradient ], feed_dict={ self.images: batch_image, self.labels: batch_label, self.keep_prob: 0.5 }) print(result[0:3], result[3][0].shape) gradient = sess.run(self.gradient, feed_dict={ self.images: batch_image, self.keep_prob: 0.5 }) gradient = gradient[0].reshape([image_h, image_w, n_channel]) gradient = numpy.max(gradient, axis=2) gradient = numpy.array((gradient - gradient.min()) * 255 / (gradient.max() - gradient.min()), dtype='uint8') print(gradient.shape) # 使用pyplot画图 plt.subplot(121) plt.imshow(image) plt.subplot(122) plt.imshow(gradient, cmap=plt.cm.gray) plt.savefig('results/epoch%d/result_%d.png' % (epoch, batch)) def observe_hidden_distribution(self, batch_size=128, image_h=32, image_w=32, n_channel=3, num_test=10, epoch=1): if not os.path.exists('results/epoch%d/' % (epoch)): os.makedirs('results/epoch%d/' % (epoch)) saver = tf.train.Saver(write_version=tf.train.SaverDef.V2) sess = tf.Session() # 读取模型 model_path = 'backup/cifar10/model_%d.ckpt' % (epoch) if os.path.exists(model_path + '.index'): saver.restore(sess, model_path) print('read model from %s' % (model_path)) else: sess.run(tf.global_variables_initializer()) # 获取图像并计算梯度 for batch in range(num_test): batch_image, batch_label = cifar10.test.next_batch(batch_size) result = sess.run( [ self.nobn_conv1, self.bn_conv1, self.nobn_conv2, self.bn_conv2, self.nobn_conv3, self.bn_conv3, self.nobn_fc1, self.nobn_fc1, self.nobn_softmax, self.bn_softmax ], feed_dict={ self.images: batch_image, self.labels: batch_label, self.keep_prob: 0.5 }) distribution1 = result[0][:, 0].flatten() distribution2 = result[1][:, 0].flatten() distribution3 = result[2][:, 0].flatten() distribution4 = result[3][:, 0].flatten() distribution5 = result[4][:, 0].flatten() distribution6 = result[5][:, 0].flatten() distribution7 = result[6][:, 0].flatten() distribution8 = result[7][:, 0].flatten() plt.subplot(241) plt.hist(distribution1, bins=50, color='#1E90FF') plt.title('convolutional layer 1') plt.subplot(242) plt.hist(distribution3, bins=50, color='#1C86EE') plt.title('convolutional layer 2') plt.subplot(243) plt.hist(distribution5, bins=50, color='#1874CD') plt.title('convolutional layer 3') plt.subplot(244) plt.hist(distribution7, bins=50, color='#5CACEE') plt.title('full connection layer') plt.subplot(245) plt.hist(distribution2, bins=50, color='#00CED1') plt.title('batch normalized') plt.subplot(246) plt.hist(distribution4, bins=50, color='#48D1CC') plt.title('batch normalized') plt.subplot(247) plt.hist(distribution6, bins=50, color='#40E0D0') plt.title('batch normalized') plt.subplot(248) plt.hist(distribution8, bins=50, color='#00FFFF') plt.title('batch normalized') plt.show()