modify nework

Author: yxlijun

config/cfg.py

@@ -8,16 +8,18 @@
 common_params = {
 	'batch_size':64,
 	'image_size':(32,32),
-	'learning_rate':0.01,
+	'learning_rate':0.1,
 	'moment':0.9,
-	'display_step':10,
+	'display_step':100,
 	'num_epochs':200,
 	'predict_step':500
 }
 
 
 graph_node = {
 	'input':'input:0',
+	'is_training':'is_training:0',
+	'keep_prob':'keep_prob:0',
 	'output':'output:0'
 }
 

network/denseNet.py

@@ -8,7 +8,7 @@
 
 class DenseNet(object):
 	"""docstring for DenseNet"""
-	def __init__(self, k = 12,L = 40,base = True,num_classes=10,is_training=True,):
+	def __init__(self,is_training,keep_prob, k = 12,L = 40,base = True,num_classes=10):
 		super(DenseNet, self).__init__()
 		self.num_classes = num_classes
 		self.is_training = is_training
@@ -22,6 +22,8 @@ def __init__(self, k = 12,L = 40,base = True,num_classes=10,is_training=True,):
 
 		self.per_block_num = (L - 4)//3 if self.base else (L - 4)//6
 
+		self.keep_prob = keep_prob
+
 	def bottle_block(self,inputs):
 		internel_out = tf.identity(inputs)
 		for i in range(self.per_block_num):
@@ -67,8 +69,8 @@ def forward(self,inputs):
 		out = self.bottle_block(out)
 		out = tf.layers.average_pooling2d(out,pool_size=8,strides=8,padding='same')
 		out = tf.layers.flatten(out)
-		out = tf.layers.dropout(out,rate=0.5)
-		predicts = tf.layers.dense(out,units=self.num_classes,kernel_regularizer=self.regularizer,name='fc')
+		out = tf.layers.dropout(out,rate=self.keep_prob)
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,kernel_regularizer=self.regularizer,name='fc')
 		softmax_out = tf.nn.softmax(predicts,name='output')
 		return predicts,softmax_out
 
@@ -79,29 +81,29 @@ def loss(self,predicts,labels):
 		return losses
 
 
-def DensetNet40_12():
-	net = DenseNet(k=12,L = 40)
+def DensetNet40_12(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k=12,L = 40)
 	return net 
 
 
-def DenseNet100_12():
-	net = DenseNet(k=12,L=100)
+def DenseNet100_12(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k=12,L=100)
 	return net  
 
-def DenseNet100_24():
-	net = DenseNet(k=24,L = 100)
+def DenseNet100_24(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k=24,L = 100)
 	return net 
 
-def DenseNetBC100_12():
-	net = DenseNet(k = 12,L = 100,base=False)
+def DenseNetBC100_12(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k = 12,L = 100,base=False)
 	return net 
 
-def DenseNetBC250_24():
-	net = DenseNet(k = 24,L = 250,base = False)
+def DenseNetBC250_24(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k = 24,L = 250,base = False)
 	return net 
 
-def DenseNetBC190_40():
-	net = DenseNet(k = 40,L = 190,base = False)
+def DenseNetBC190_40(is_training=True,keep_prob=0.5):
+	net = DenseNet(is_training=is_training,keep_prob = keep_prob,k = 40,L = 190,base = False)
 	return net 
 
 

network/mobileNet.py

@@ -7,15 +7,15 @@
 
 class MobileNet(object):
 	"""docstring for MobileNet"""
-	def __init__(self, num_classes=10,is_training=True):
+	def __init__(self,is_training=True,keep_prob=0.5,num_classes=10):
 		super(MobileNet, self).__init__()
 		self.num_classes = num_classes
 		self.is_training = is_training
 		self.conv_num = 0
 		self.weight_decay = 5e-4
 		self.regularizer = tf.contrib.layers.l2_regularizer(scale=self.weight_decay)
 		self.initializer = tf.contrib.layers.xavier_initializer()
-
+		self.keep_prob = keep_prob
 
 	def conv2d(self,inputs,out_channel,kernel_size=1,stride=1):
 		inputs = tf.layers.conv2d(inputs,filters=out_channel,kernel_size=kernel_size,strides=stride,padding='same',
@@ -62,8 +62,8 @@ def forward(self,inputs):
 		out = self.separable_conv2d(out,out_channel=1024,kernel_size=[3,3,1024,1],stride=1)
 		out = tf.layers.average_pooling2d(out,pool_size=1,strides=1)
 		out = tf.layers.flatten(out)
-		out = tf.layers.dropout(out,rate=0.5)
-		predicts = tf.layers.dense(out,units=self.num_classes,kernel_regularizer=self.regularizer,name='fc')
+		out = tf.layers.dropout(out,rate=self.keep_prob)
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,kernel_regularizer=self.regularizer,name='fc')
 		softmax_out = tf.nn.softmax(predicts,name='output')
 		return predicts,softmax_out
 

network/resnet.py

@@ -7,13 +7,14 @@
 
 class Resnet(object):
 	"""docstring for Resnet"""
-	def __init__(self, stack_num=3,num_classes=10,is_training=True):
+	def __init__(self,is_training,keep_prob,stack_num=3,num_classes=10):
 		super(Resnet, self).__init__()
 		self.num_classes = num_classes
 		self.is_training = is_training
 		self.regularizer = tf.contrib.layers.l2_regularizer(scale=1e-4)
 		self.initializer = tf.contrib.layers.xavier_initializer()
 		self.stack_num = stack_num
+		self.keep_prob = keep_prob
 
 	def residual_block(self,inputs,output_channel,stride=[1,1]):
 		residual = tf.identity(inputs)
@@ -40,7 +41,7 @@ def forward(self,inputs):
 		out = self.make_layer(out,[64,64])
 		out = tf.layers.average_pooling2d(out,pool_size=8,strides=1)
 		out = tf.layers.flatten(out)
-		predicts = tf.layers.dense(out,units=self.num_classes,kernel_regularizer=self.regularizer)
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,kernel_regularizer=self.regularizer)
 		softmax_out = tf.nn.softmax(predicts,name='output')
 		return predicts,softmax_out
 
@@ -63,23 +64,23 @@ def loss(self,predicts,labels):
 
 '''
 
-def resnet20():
-	net = Resnet(stack_num=3)
+def resnet20(is_training=True,keep_prob=0.5):
+	net = Resnet(is_training=is_training,keep_prob=keep_prob,stack_num=3)
 	return net 
 
 
-def resnet32():
-	net = Resnet(stack_num=5)
+def resnet32(is_training=True,keep_prob=0.5):
+	net = Resnet(is_training=is_training,keep_prob=keep_prob,stack_num=5)
 	return net 
 
 
-def resnet44():
-	net = Resnet(stack_num=7)
+def resnet44(is_training=True,keep_prob=0.5):
+	net = Resnet(is_training=is_training,keep_prob=keep_prob,stack_num=7)
 	return net 
 
 
-def resnet56():
-	net = Resnet(stack_num=9)
+def resnet56(is_training=True,keep_prob=0.5):
+	net = Resnet(is_training=is_training,keep_prob=keep_prob,stack_num=9)
 	return net 
 
 

network/resnext.py

@@ -8,7 +8,7 @@
 
 class resNext(object):
 	"""docstring for resNext"""
-	def __init__(self, block_num,num_classes=10,is_training=True):
+	def __init__(self, block_num,is_training,keep_prob,num_classes=10):
 		super(resNext, self).__init__()
 		self.num_classes = num_classes
 		self.is_training = is_training
@@ -21,6 +21,7 @@ def __init__(self, block_num,num_classes=10,is_training=True):
 		self.initializer = tf.contrib.layers.xavier_initializer()
 
 		self.cardinality = 32
+		self.keep_prob = keep_prob
 
 	def bottleneck_layer(self,inputs,out_channel,stride):
 		residual = tf.identity(inputs)
@@ -85,8 +86,8 @@ def forward(self,inputs):
 
 		out = tf.layers.average_pooling2d(out,pool_size=(pool_size,pool_size),strides=(stride,stride),name='avg_pool')
 		out = tf.layers.flatten(out,name='flatten')
-		out = tf.layers.dropout(out,rate=0.5,name='dropout')
-		predicts = tf.layers.dense(out,units=self.num_classes,kernel_regularizer=self.regularizer,name='fc')
+		out = tf.layers.dropout(out,rate=self.keep_prob,name='dropout')
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,kernel_regularizer=self.regularizer,name='fc')
 		softmax_out = tf.nn.softmax(predicts,name='output')
 
 		return predicts,softmax_out
@@ -111,24 +112,23 @@ def loss(self,predicts,labels):
 
 
 
-def ResNext50():
+def ResNext50(is_training=True,keep_prob=0.5):
 	'''
 		stage1: 1x1x128->group conv->3x3x128 cardinality 32 ->1x1x256
 		stage2: 1x1x256->group conv->3x3x256 cardinality 32 ->1x1x512
 		stage3: 1x1x512->group conv->3x3x512 cardinality 32 ->1x1x1024
 		stage4: 1x1x1024->group conv->3x3x1024 cardinality 32 ->1x1x2048
 	'''
-	net = resNext([3,4,6,3])
+	net = resNext([3,4,6,3],is_training=is_training,keep_prob=keep_prob)
 	return net 
 
 
 
-def ResNext101():
-	net = resNext([3,4,23,3])
+def ResNext101(is_training=True,keep_prob=0.5):
+	net = resNext([3,4,23,3],is_training=is_training,keep_prob=keep_prob)
 	return net 
 
 
-
 if __name__=='__main__':
 	with tf.device('/cpu:0'):
 		net = ResNext50()

network/seNet.py

@@ -8,10 +8,11 @@
 
 class SeNet(object):
 	"""docstring for SeNet"""
-	def __init__(self, block_num,num_classes=10,is_training=True):
+	def __init__(self, block_num,is_training,keep_prob,num_classes=10):
 		super(SeNet, self).__init__()
 		self.num_classes = num_classes
 		self.is_training = is_training
+		self.keep_prob = keep_prob
 		self.block_nums = block_num
 
 		self.conv_num = 0
@@ -87,8 +88,8 @@ def forward(self,inputs):
 		h,w = inputs.shape[1] // 32 ,inputs.shape[2] // 32
 		out = tf.layers.average_pooling2d(out,pool_size=(h,w),strides=(h,w),padding='same',name='average_pool_'+str(self.average_num))
 		out = tf.layers.flatten(out,name='flatten')
-		out = tf.layers.dropout(out,rate=0.5,name='dropout')
-		predicts = tf.layers.dense(out,units=self.num_classes,kernel_regularizer=self.regularizer,name='fc_'+str(self.fc_num))
+		out = tf.layers.dropout(out,rate=self.keep_prob,name='dropout')
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,kernel_regularizer=self.regularizer,name='fc_'+str(self.fc_num))
 		softmax_out = tf.nn.softmax(predicts,name='output')
 
 		return predicts,softmax_out
@@ -111,12 +112,12 @@ def loss(self,predicts,labels):
 
 
 
-def SE_Resnet_50():
-	net = SeNet([3,4,6,3])
+def SE_Resnet_50(is_training=True,keep_prob=0.5):
+	net = SeNet([3,4,6,3],is_training=is_training,keep_prob=keep_prob)
 	return net 
 
-def SE_Resnet_101():
-	net = SeNet([3,4,23,3])
+def SE_Resnet_101(is_training=True,keep_prob=0.5):
+	net = SeNet([3,4,23,3],is_training=is_training,keep_prob=keep_prob)
 	return net 
 
 

network/squeezeNet.py

@@ -18,7 +18,7 @@
 
 class SqueezeNet(object):
 	"""docstring for SqueezeNet"""
-	def __init__(self, net_config,mode='A',num_classes=10):
+	def __init__(self, net_config,is_training,keep_prob,mode='A',num_classes=10):
 		super(SqueezeNet, self).__init__()
 		self.num_classes = num_classes
 		self.conv_num = 0
@@ -31,6 +31,9 @@ def __init__(self, net_config,mode='A',num_classes=10):
 		self.pct33 = net_config['pct33']
 		self.freq = net_config['freq']
 
+		self.is_training = is_training
+		self.keep_prob = keep_prob
+
 		if mode=='A':
 			self.make_layer = self.make_layerA
 		elif mode =='B':
@@ -81,8 +84,8 @@ def forward(self,inputs):
 
 		out = tf.layers.average_pooling2d(out,pool_size=(pool_size,pool_size),strides=(stride,stride),name='avg_pool_0')
 		out = tf.layers.flatten(out,name='flatten')
-		out = tf.layers.dropout(out,rate=0.5,name='dropout')
-		predicts = tf.layers.dense(out,units=self.num_classes,name='fc')
+		out = tf.layers.dropout(out,rate=self.keep_prob,name='dropout')
+		predicts = tf.layers.dense(out,units=self.num_classes,kernel_initializer=self.initializer,name='fc')
 		softmax_out = tf.nn.softmax(predicts,name='output')
 
 		return predicts,softmax_out
@@ -122,13 +125,13 @@ def loss(self,predicts,labels):
 
 
 
-def SqueezeNetA():
-	net = SqueezeNet(net_config=net_config)
+def SqueezeNetA(is_training=True,keep_prob=0.5):
+	net = SqueezeNet(net_config=net_config,is_training=is_training,keep_prob=keep_prob)
 	return net 
 
 
-def SqueezeNetB():
-	net = SqueezeNet(net_config=net_config,mode='B')
+def SqueezeNetB(is_training=True,keep_prob=0.5):
+	net = SqueezeNet(net_config=net_config,is_training=is_training,keep_prob=keep_prob,mode='B')
 	return net