def buildNetwork(n, k): # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) img_prep.add_featurewise_stdnorm() # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() # Building Residual Network net = tflearn.input_data(shape=[None, b.IMG_WIDTH, b.IMG_HEIGHT, b.CHANNELS], data_preprocessing=img_prep, data_augmentation=img_aug) net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001) # wideresnet part net = wideresnet_block(net, n, 16, k, downsample=True) net = wideresnet_block(net, 1, 32, k, downsample=True) net = wideresnet_block(net, n - 1, 32, k, downsample=True) net = wideresnet_block(net, 1, 64, 2, downsample=True) net = wideresnet_block(net, n - 1, 64, k, downsample=True) net = tflearn.batch_normalization(net) net = tflearn.activation(net, 'relu') net = tflearn.global_avg_pool(net) # Regression net = tflearn.fully_connected(net, b.CLASS_3_NUMBER, activation='softmax') mom = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) net = tflearn.regression(net, optimizer=mom, loss='categorical_crossentropy') model = tflearn.DNN(net, tensorboard_verbose=0, clip_gradients=0., tensorboard_dir=b.PATH + 'log') return model
def get_input_layer(flags): img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() curr = input_data(shape=[None, flags.inres, flags.inres, flags.inchan], name='input', data_preprocessing=img_prep) if flags.rts_aug: w, h = curr.get_shape().as_list()[1:3] a = -flags.rts_aug_ang + 2 * flags.rts_aug_ang * tf.random_uniform( [flags.bs]) a *= np.pi / 180 # centralize rot/scale y = ((w - 1) - (tf.cos(a) * (w - 1) - tf.sin(a) * (h - 1))) / 2.0 x = ((h - 1) - (tf.sin(a) * (w - 1) + tf.cos(a) * (h - 1))) / 2.0 transforms = tf.transpose( tf.stack([ tf.cos(a), tf.sin(a), x, -tf.sin(a), tf.cos(a), y, tf.zeros(flags.bs), tf.zeros(flags.bs) ])) return tf.cond(tflearn.get_training_mode(), lambda: tf.contrib.image.transform(curr, transforms), lambda: curr) else: return curr
def build_network(self): """ Build the convnet. Input is 48x48 3072 nodes in fully connected layer """ # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center( per_channel=True, mean=[0.53990436, 0.4405486, 0.39328504]) # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([49, 49], padding=4) # Building Residual Network self.network = tflearn.input_data(shape=[None, 49, 49, 3], data_preprocessing=img_prep, data_augmentation=img_aug) self.network = tflearn.conv_2d(self.network, 16, 3, regularizer='L2', weight_decay=0.0001) self.network = tflearn.resnext_block(self.network, 5, 16, 32) self.network = tflearn.resnext_block(self.network, 1, 32, 32, downsample=True) self.network = tflearn.resnext_block(self.network, 4, 32, 32) self.network = tflearn.resnext_block(self.network, 1, 64, 32, downsample=True) self.network = tflearn.resnext_block(self.network, 4, 64, 32) self.network = tflearn.batch_normalization(self.network) self.network = tflearn.activation(self.network, 'relu') self.network = tflearn.global_avg_pool(self.network) # Regression self.network = tflearn.fully_connected(self.network, 11, activation='softmax') opt = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) self.network = tflearn.regression(self.network, optimizer=opt, loss='categorical_crossentropy') # Training self.model = tflearn.DNN(self.network, checkpoint_path='Snapshots/model_resnext', max_checkpoints=10, tensorboard_verbose=0, tensorboard_dir='Logs/', clip_gradients=0.) self.load_model()
def return2img(): n = 5 img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([32, 32], padding=4) # Building Residual Network net = tflearn.input_data(shape=[None, 32, 32, 1], data_preprocessing=img_prep, data_augmentation=img_aug) net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001) net = tflearn.residual_block(net, n, 16) net = tflearn.residual_block(net, 1, 32, downsample=True) net = tflearn.residual_block(net, n - 1, 32) net = tflearn.residual_block(net, 1, 64, downsample=True) net = tflearn.residual_block(net, n - 1, 64) net = tflearn.batch_normalization(net) net = tflearn.activation(net, 'relu') net = tflearn.global_avg_pool(net) # Regression net = tflearn.fully_connected(net, 3, activation='softmax') mom = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) net = tflearn.regression(net, optimizer=mom, loss='categorical_crossentropy') # Training model = tflearn.DNN(net) model.load("model_resnet_+-------cifar10-6500") img = load_img_label('/media/bai/Elements/LiangData_Afterchoose/img1') livermask = load_mask('/media/bai/Elements/LiangData_Afterchoose/mask1') abc=[] np.array(abc) for i in range(img.shape[0]): a = np.zeros((512,512,3,3),dtype=np.float32)#最后一项表示第几个分割方式,倒数第二项表示预测的三个结果 for j in range(0,3): this_mask = livermask[i, :, :, j] this_mask_num = int(np.max(this_mask)) for k in range(1,this_mask_num+1): if os.path.exists('/media/bai/Elements/LiangData_Afterchoose/superpixel/'+str(i)+'_'+str(j)+'_'+str(k)+'.jpg'): this_img = io.imread('/media/bai/Elements/LiangData_Afterchoose/superpixel/'+str(i)+'_'+str(j)+'_'+str(k)+'.jpg') this_img = np.reshape(this_img,(1,32,32,1)) this_img = this_img.astype(np.float32) result = model.predict(this_img) # print(result) abc.append(result) thisPartLoc=np.where(this_mask==k) for num in range(len(thisPartLoc[1])): a[thisPartLoc[0][num],thisPartLoc[1][num],0,j] = result[0,0] a[thisPartLoc[0][num],thisPartLoc[1][num], 1, j] = result[0,1] a[thisPartLoc[0][num],thisPartLoc[1][num], 2, j] = result[0,2] b = np.max(a,axis=3) final = np.argmax(b,axis=2) #添加3D CRF misc.imsave('/media/bai/Elements/LiangData_Afterchoose/result/' + str(i) + '.jpg', final)
def build_network(self): # Smaller 'AlexNet' # https://github.com/tflearn/tflearn/blob/master/examples/images/alexnet.py img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() # img_aug.add_random_flip_updown() img_aug.add_random_crop([SIZE_FACE, SIZE_FACE], padding=4) img_aug.add_random_rotation(max_angle=16.0) img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) img_prep.add_featurewise_stdnorm(per_channel=True) print('[+] Building CNN') self.network = input_data(shape = [None, SIZE_FACE, SIZE_FACE, 1], data_preprocessing=img_prep, data_augmentation=img_aug) self.network = conv_2d(self.network, 64, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = conv_2d(self.network, 64, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = local_response_normalization(self.network) self.network = max_pool_2d(self.network, 2, strides=2) self.network = dropout(self.network, 0.8) self.network = conv_2d(self.network, 128, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = conv_2d(self.network, 128, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = max_pool_2d(self.network, 2, strides=2) self.network = dropout(self.network, 0.8) self.network = conv_2d(self.network, 256, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = conv_2d(self.network, 256, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = max_pool_2d(self.network, 2, strides=2) self.network = dropout(self.network, 0.8) self.network = conv_2d(self.network, 512, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = conv_2d(self.network, 512, 3, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = max_pool_2d(self.network, 2, strides=2) self.network = dropout(self.network, 0.8) self.network = fully_connected(self.network, 4096, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = dropout(self.network, 0.7) self.network = fully_connected(self.network, 4096, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = dropout(self.network, 0.7) self.network = fully_connected(self.network, 1024, activation='relu', regularizer='L2')#, weight_decay=0.0001) self.network = dropout(self.network, 0.7) self.network = fully_connected(self.network, len(EMOTIONS), activation='softmax')#, restore=False) mom = tflearn.optimizers.Momentum(learning_rate=0.02, lr_decay=0.8, decay_step=500) self.network = regression(self.network, optimizer=mom, loss='categorical_crossentropy')#, restore=False) self.model = tflearn.DNN( self.network, tensorboard_dir = '../tmp/', checkpoint_path = None, max_checkpoints = None, tensorboard_verbose = 0 )
def get_model(model_name): # First we load the network print("Setting up neural networks...") n = 18 # Real-time data preprocessing print("Doing preprocessing...") img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center( per_channel=True, mean=[0.573364, 0.44924123, 0.39455055]) # Real-time data augmentation print("Building augmentation...") img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([32, 32], padding=4) #Build the model (for 32 x 32) print("Shaping input data...") net = tflearn.input_data(shape=[None, 32, 32, 3], data_preprocessing=img_prep, data_augmentation=img_aug) net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001) print("Carving Resnext blocks...") net = tflearn.resnext_block(net, n, 16, 32) net = tflearn.resnext_block(net, 1, 32, 32, downsample=True) net = tflearn.resnext_block(net, n - 1, 32, 32) net = tflearn.resnext_block(net, 1, 64, 32, downsample=True) net = tflearn.resnext_block(net, n - 1, 64, 32) print("Erroding Gradient...") net = tflearn.batch_normalization(net) net = tflearn.activation(net, 'relu') net = tflearn.global_avg_pool(net) net = tflearn.fully_connected(net, 8, activation='softmax') opt = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) net = tflearn.regression(net, optimizer=opt, loss='categorical_crossentropy') print("Structuring model...") model = tflearn.DNN(net, tensorboard_verbose=0, clip_gradients=0.) # Load the model from checkpoint print("Loading the model...") model.load(model_name) return model
def build(IMAGE_H, IMAGE_W, IMAGE_C, LABELS, model_file, learning_rate=0.01, val_acc_thresh=0.99): img_prep = tflearn.ImagePreprocessing() # img_prep.add_featurewise_zero_center(per_channel=True) # 输入图像要减图像均值 img_aug = tflearn.ImageAugmentation() img_aug.add_random_rotation(max_angle=10.0) # 随机旋转角度 # img_aug.add_random_blur(sigma_max=5.0) # Building Residual Network net = tflearn.input_data(shape=[None, IMAGE_H, IMAGE_W, IMAGE_C], data_preprocessing=img_prep, data_augmentation=img_aug, name='input') net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weights_init='variance_scaling', weight_decay=0.0001, name="conv1") # 卷积处理, 16个卷积,卷积核大小为3,L2 正则化减少过拟合 net = tflearn.residual_block(net, 1, 16, name="res1") # 1 个残差层,输出16特征 net = tflearn.residual_block(net, 1, 32, downsample=True, name="res2") # 1 个残差层,输出32特征,降维1/2 net = tflearn.residual_block(net, 1, 64, downsample=True, name="res3") # 1 个残差层,输出64特征,降维1/2 # Regression net = tflearn.fully_connected(net, len(LABELS), activation='softmax') mom = tflearn.Momentum(learning_rate, lr_decay=0.1, decay_step=32000, staircase=True) net = tflearn.regression(net, optimizer=mom, loss='categorical_crossentropy') # Training model = tflearn.DNN(net, max_checkpoints=1, tensorboard_verbose=3) return model
def retrain(output_filename): num_classes = 120 # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_blur(sigma_max=5.) img_aug.add_random_crop((224, 224)) img_aug.add_random_rotation(max_angle=25.) softmax = vgg16(softmax_size=num_classes, restore_softmax=False, data_preprocessing=img_prep, data_augmentation=img_aug) regression = tflearn.regression(softmax, optimizer='rmsprop', loss='categorical_crossentropy', learning_rate=0.001) model = tflearn.DNN(regression, checkpoint_path=output_filename, max_checkpoints=3, tensorboard_verbose=3) # Load pre-existing model, restoring all weights, except softmax layer ones model_file = 'vgg/vgg16.tflearn' if not os.path.exists(model_file): maybe_download(DATA_URL, 'vgg') model.load(model_file) # Start fine-tuning X, Y = grozi120.load_data() model.fit(X, Y, n_epoch=10, validation_set=0.1, shuffle=True, show_metric=True, batch_size=64, snapshot_step=200, snapshot_epoch=False, run_id=output_filename) model.save(output_filename)
def _build_network(self, n, image_size): # Define the input to the network. img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) # Real-time data augmentation. img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() net = tflearn.input_data(shape=[None, image_size[0], image_size[1], 3], data_preprocessing=img_prep, data_augmentation=img_aug) # Start with a normal convolutional layer. net = tflearn.conv_2d(net, 64, 3, regularizer='L2', weight_decay=0.0001) # Since this is a ResNet with <50 layers, we'll use regular residual blocks; # otherwise, we'd use residual bottleneck blocks instead. net = tflearn.residual_block(net, n, 64) net = tflearn.residual_block(net, 1, 128, downsample=True) net = tflearn.residual_block(net, n - 1, 128) net = tflearn.residual_block(net, 1, 256, downsample=True) net = tflearn.residual_block(net, n - 1, 256) # Perform batch normalization. net = tflearn.batch_normalization(net) # Activation at the end of the network pre-FC. net = tflearn.activation(net, 'relu') net = tflearn.global_avg_pool(net) net = tflearn.fully_connected(net, 2, activation='softmax') mom = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) net = tflearn.regression(net, optimizer=mom, loss='categorical_crossentropy') return net
def add_layer(net, lay): if lay[0] == 'down_conv_2d': net = tfl.conv_2d(net, nb_filter=lay[1], strides=[1, 2, 2, 1], filter_size=lay[2], activation=lay[3]) elif lay[0] == 'conv_2d': net = tfl.conv_2d(net, nb_filter=lay[1], filter_size=lay[2], activation=lay[3]) elif lay[0] == 'flatten': s = net.get_shape() net = tf.reshape(net, [tf.shape(net)[0], s[1] * s[2] * s[3]]) elif lay[0] == 'fully_connected': net = tfl.fully_connected(net, n_units=lay[1], activation=lay[2]) elif lay[0] == 'expand': net = tf.reshape(net, [ tf.shape(net)[0], lay[1], lay[2], net.get_shape()[1] / lay[1] / lay[2] ]) elif lay[0] == 'up_conv_2d': net = tfl.conv_2d_transpose(net, nb_filter=lay[1], filter_size=lay[2], strides=[1, 2, 2, 1], output_shape=[lay[3], lay[4]], activation=lay[5], padding="same") elif lay[0] == 'input_layer': image_prep = tfl.ImagePreprocessing() image_prep.add_featurewise_stdnorm(per_channel=True, std=0.24051991589344662) image_prep.add_featurewise_zero_center(per_channel=True, mean=0.14699117337640238) net = tfl.layers.input_data(shape=[None, lay[1], lay[2]], data_preprocessing=image_prep) net = tf.expand_dims(net, axis=-1) if lay[-1] == 'batch_norm': net = tfl.batch_normalization(net) return net
class ConvNeuralNetwork(): # Image preprocessing imgprep = tflearn.ImagePreprocessing() imgprep.add_featurewise_zero_center() imgprep.add_featurewise_stdnorm() # Image augmentation imgaug = tflearn.ImageAugmentation() imgaug.add_random_rotation() imgaug.add_random_flip_leftright() # Input layer convnet = input_data(shape=[None, settings.IMG_SIZE, settings.IMG_SIZE, 1], data_preprocessing=imgprep, data_augmentation=imgaug, name='input') # Hidden layers convnet = conv_2d(convnet, 32, 3, activation='relu') convnet = max_pool_2d(convnet, 2) convnet = conv_2d(convnet, 64, 3, activation='relu') convnet = max_pool_2d(convnet, 2) convnet = conv_2d(convnet, 128, 3, activation='relu') convnet = max_pool_2d(convnet, 2) convnet = conv_2d(convnet, 256, 3, activation='relu') convnet = max_pool_2d(convnet, 2) # Fully connected layer convnet = fully_connected(convnet, 1024, activation='relu') convnet = dropout(convnet, settings.DROPOUT_RATE) # Output layer convnet = fully_connected(convnet, 2, activation='softmax') convnet = regression(convnet, optimizer='adam', loss='categorical_crossentropy', learning_rate=settings.LEARNING_RATE, name='targets') model = tflearn.DNN(convnet, tensorboard_dir='log')
from tflearn.helpers.regularizer import add_weights_regularizer from tensorflow.contrib.slim import dataset from tensorflow.contrib.slim import dataset tflearn.input_data() tflearn.variable() tflearn.conv_2d() tflearn.single_unit() tflearn.lstm() tflearn.embedding() tflearn.batch_normalization() tflearn.merge() tflearn.regression() tflearn.tanh() tflearn.softmax_categorical_crossentropy() tflearn.SGD() tflearn.initializations.uniform() tflearn.losses.L1() tflearn.add_weights_regularizer() tflearn.metrics.Accuracy() tflearn.summaries() tflearn.ImagePreprocessing() tflearn.ImageAugmentation() tflearn.init_graph()
def train(env, epoch_num, learning_rate=0.01, clean_start=False): ''' a function that create input, create network, train network and report results :param env: local/AWS; environment that our system work on :param epoch_num: number of epochs to run :return: ''' #----------------------reading constants from config file--------------------------------- config = configparser.ConfigParser() config.read('config.ini') conf = config[env] image_size = conf['window_size'] mean_colors = [ float(conf['mean_r']), float(conf['mean_g']), float(conf['mean_b']) ] #----------------------------------------------------------------------------------------- #----------------------------------------input layer------------------------------------------ # read input http://tflearn.org/data_utils/#build-hdf5-image-dataset X_train, Y_train, X_test, Y_test = deep_learning.data_prep( conf, clean_start=clean_start) #prepare input layer http://tflearn.org/data_preprocessing/ img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(mean=mean_colors, per_channel=True) # http://tflearn.org/layers/core/#input-data input_layer = input_data(shape=[None, image_size, image_size, 3], name='input_layer') #,data_preprocessing=img_prep) #--------------------------------------------------------------------------------------------- #-------------------------------create model-------------------------------------------------------- # network softmax = deep_learning.inception(input_layer, 2) #softmax = deep_learning.VGGNet(input_layer, 2) # estimator layer f_score = tflearn.metrics.F2Score() network = tflearn.regression( softmax, optimizer='momentum', loss='categorical_crossentropy', learning_rate=learning_rate, metric=f_score) #if want to finetune give 'restore=False' # model http://tflearn.org/models/dnn/ model = tflearn.DNN(network, checkpoint_path='model_inception', max_checkpoints=1, tensorboard_verbose=0, tensorboard_dir="./logs2") if os.path.isfile('inception_ercis.model') and not clean_start: print 'load model learning_rate: ' + str(learning_rate) model.load('inception_ercis.model', weights_only=True) model.fit(X_train, Y_train, validation_set=(X_test, Y_test), n_epoch=epoch_num, shuffle=True, show_metric=True, batch_size=128, snapshot_step=200, snapshot_epoch=False, run_id='inception_ercis') #--------------------------------------------------------------------------------------------- model.save('inception_ercis.model')
import tflearn
def train(env, epoch_num, learning_rate = 0.01, clean_start = True, model_name = None): ''' a function that create input, create network, train network and report results :param env: local/AWS; environment that our system work on :param epoch_num: number of epochs to run :return: ''' print 'model_name: ', model_name #----------------------reading constants from config file--------------------------------- config = configparser.ConfigParser() config.read('config.ini') conf = config[env] image_size = conf['window_size'] mean_colors = [float(conf['mean_r']), float(conf['mean_g']), float(conf['mean_b'])] data_splitting_method = conf['data_splitting_method'] train_size = conf['train_size'] #----------------------------------------------------------------------------------------- #----------------------------------------input layer------------------------------------------ # read input http://tflearn.org/data_utils/#build-hdf5-image-dataset X_train, Y_train, X_test, Y_test = data_prep(conf, clean_start = clean_start, method=data_splitting_method, training_size=train_size) #prepare input layer http://tflearn.org/data_preprocessing/ img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(mean=mean_colors,per_channel=True) # http://tflearn.org/layers/core/#input-data input_layer = input_data(shape=[None, image_size, image_size, 3], name = 'input_layer') #,data_preprocessing=img_prep) #--------------------------------------------------------------------------------------------- #-------------------------------create model-------------------------------------------------------- # network #softmax = deep_learning.inception(input_layer, 2) #softmax = deep_learning.VGGNet(input_layer, 2) if model_name.split('.')[0].split('-')[0] == 'inception': softmax = deep_learning.inception(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'ResNet': softmax = deep_learning.ResNet(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'VGGNet': softmax = deep_learning.VGGNet(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'NiN': softmax = deep_learning.NiN(input_layer, 2) else: return # estimator layer f_score = tflearn.metrics.F2Score() momentum = Momentum(learning_rate=0.1, lr_decay=0.9, decay_step=250) network = tflearn.regression(softmax, optimizer='adam', loss='categorical_crossentropy',metric=f_score) #if want to finetune give 'restore=False' # model http://tflearn.org/models/dnn/ model = tflearn.DNN(network, checkpoint_path='./models', best_checkpoint_path='./models/best', max_checkpoints=1, tensorboard_verbose=0, tensorboard_dir="./logs", best_val_accuracy=0.0) if model_name != None: if os.path.isfile(model_name) and not clean_start: print 'load model learning_rate: ' + str(learning_rate) model.load(model_name,weights_only=True) model.fit(X_train, Y_train, validation_set = (X_test, Y_test),n_epoch=epoch_num, shuffle=True, show_metric=True, batch_size=128, snapshot_epoch=True, run_id=model_name) #--------------------------------------------------------------------------------------------- print 'saving model.' model.save( model_name) print 'model: ', model_name, 'saved.' return model_name
def return2img(): n = 5 # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True) # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([32, 32], padding=4) inp = tflearn.input_data(shape=[None, 32, 32, 1], data_preprocessing=img_prep, data_augmentation=img_aug, name='input') conv1_1 = tflearn.conv_2d(inp, 64, 3, activation='relu', name="conv1_1") conv1_2 = tflearn.conv_2d(conv1_1, 64, 3, activation='relu', name="conv1_2") pool1 = tflearn.max_pool_2d(conv1_2, 2, strides=2) conv2_1 = tflearn.conv_2d(pool1, 128, 3, activation='relu', name="conv2_1") conv2_2 = tflearn.conv_2d(conv2_1, 128, 3, activation='relu', name="conv2_2") pool2 = tflearn.max_pool_2d(conv2_2, 2, strides=2) conv3_1 = tflearn.conv_2d(pool2, 256, 3, activation='relu', name="conv3_1") conv3_2 = tflearn.conv_2d(conv3_1, 256, 3, activation='relu', name="conv3_2") conv3_3 = tflearn.conv_2d(conv3_2, 256, 3, activation='relu', name="conv3_3") pool3 = tflearn.max_pool_2d(conv3_3, 2, strides=2) conv4_1 = tflearn.conv_2d(pool3, 512, 3, activation='relu', name="conv4_1") conv4_2 = tflearn.conv_2d(conv4_1, 512, 3, activation='relu', name="conv4_2") conv4_3 = tflearn.conv_2d(conv4_2, 512, 3, activation='relu', name="conv4_3") pool4 = tflearn.max_pool_2d(conv4_3, 2, strides=2) conv5_1 = tflearn.conv_2d(pool4, 512, 3, activation='relu', name="conv5_1") conv5_2 = tflearn.conv_2d(conv5_1, 512, 3, activation='relu', name="conv5_2") conv5_3 = tflearn.conv_2d(conv5_2, 512, 3, activation='relu', name="conv5_3") pool5 = tflearn.max_pool_2d(conv5_3, 2, strides=2) fc6 = tflearn.fully_connected(pool5, 4096, activation='relu', name="fc6") fc6_dropout = tflearn.dropout(fc6, 0.5) fc7 = tflearn.fully_connected(fc6_dropout, 4096, activation='relu', name="fc7") fc7_droptout = tflearn.dropout(fc7, 0.5) fc8 = tflearn.fully_connected(fc7_droptout, 3, activation='softmax', name="fc8") mm = tflearn.Momentum(learning_rate=0.01, momentum=0.9, lr_decay=0.1, decay_step=1000) network = tflearn.regression(fc8, optimizer=mm, loss='categorical_crossentropy', restore=False) # Training model = tflearn.DNN(network) model.load("model_resnet_+-------cifar10-14000") img = load_img_label('/home/bai/最新数据/验证数据/经过预处理的原始图像') livermask = load_mask('/home/bai/最新数据/验证数据/mask') abc = [] np.array(abc) for i in range(img.shape[0]): a = np.zeros((512, 512, 3, 3), dtype=np.float32) #最后一项表示第几个分割方式,倒数第二项表示预测的三个结果 for j in range(0, 3): this_mask = livermask[i, :, :, j] this_mask_num = int(np.max(this_mask)) for k in range(1, this_mask_num + 1): if os.path.exists('/home/bai/最新数据/验证数据/超像素块/' + str(i) + '_' + str(j) + '_' + str(k) + '.jpg'): this_img = io.imread('/home/bai/最新数据/验证数据/超像素块/' + str(i) + '_' + str(j) + '_' + str(k) + '.jpg') this_img = np.reshape(this_img, (1, 32, 32, 1)) this_img = this_img.astype(np.float32) result = model.predict(this_img) # print(result) abc.append(result) thisPartLoc = np.where(this_mask == k) for num in range(len(thisPartLoc[1])): a[thisPartLoc[0][num], thisPartLoc[1][num], 0, j] = result[0, 0] a[thisPartLoc[0][num], thisPartLoc[1][num], 1, j] = result[0, 1] a[thisPartLoc[0][num], thisPartLoc[1][num], 2, j] = result[0, 2] b = np.max(a, axis=3) final = np.argmax(b, axis=2) misc.imsave( '/home/bai/PycharmProjects/DeepRESIDUALNETWORKS/result/' + str(i) + '.jpg', final)
def train_nn_tflearn(data_handler, num_epochs=50): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5) batch_size = data_handler.mini_batch_size img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center() img_prep.add_featurewise_stdnorm() img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_rotation(max_angle=25) img_aug.add_random_crop([32, 32], padding=4) x = tflearn.input_data(shape=[None, 32, 32, 3], dtype='float', data_preprocessing=img_prep, data_augmentation=img_aug) # x = tf.placeholder('float', [None, 32, 32, 3]) #y = tf.placeholder('float', [None, 10]) # test_data, test_labels = data_handler.get_test_data() # test_data = test_data.reshape([-1,32,32,3]) ntrain = data_handler.train_size ntest = data_handler.meta['num_cases_per_batch'] # from tflearn.datasets import cifar10 # (X, Y), (X_test, Y_test) = cifar10.load_data(dirname="/home/hamza/meh/bk_fedora24/Documents/tflearn_example/cifar-10-batches-py") # X, Y = tflearn.data_utils.shuffle(X, Y) # Y = tflearn.data_utils.to_categorical(Y, 10) # Y_test = tflearn.data_utils.to_categorical(Y_test, 10) X, Y = data_handler.get_all_train_data() X, Y = tflearn.data_utils.shuffle(X, Y) X = np.dstack((X[:, :1024], X[:, 1024:2048], X[:, 2048:])) X = X / 255.0 X = X.reshape([-1, 32, 32, 3]) Y = tflearn.data_utils.to_categorical(Y, 10) X_test, Y_test = data_handler.get_test_data() X_test = np.dstack((X_test[:, :1024], X_test[:, 1024:2048], X_test[:, 2048:])) X_test = X_test / 255.0 X_test = X_test.reshape([-1, 32, 32, 3]) #network = tflearn.regression(net3(x),optimizer='adam',loss='categorical_crossentropy',learning_rate=0.001) mom = tflearn.Momentum(0.1, lr_decay=0.1, decay_step=32000, staircase=True) network = tflearn.regression(resnet1(x), optimizer=mom, loss='categorical_crossentropy') print np.shape(X) print np.shape(Y) print network model = tflearn.DNN(network, tensorboard_verbose=0) model.fit(X, Y, n_epoch=50, shuffle=True, validation_set=(X_test, Y_test), show_metric=True, batch_size=data_handler.mini_batch_size, run_id='cifar10_cnn')
def test(env, model_name, clean_start=False): ''' a function that create input, create network, train network and report results :param env: local/AWS; environment that our system work on :param epoch_num: number of epochs to run :return: ''' #----------------------reading constants from config file--------------------------------- config = configparser.ConfigParser() config.read('config.ini') conf = config[env] image_size = conf['window_size'] mean_colors = [ float(conf['mean_r']), float(conf['mean_g']), float(conf['mean_b']) ] #----------------------------------------------------------------------------------------- #----------------------------------------input layer------------------------------------------ # read input http://tflearn.org/data_utils/#build-hdf5-image-dataset X_train, Y_train, X_test, Y_test = data_prep(conf) #prepare input layer http://tflearn.org/data_preprocessing/ img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(mean=mean_colors, per_channel=True) # http://tflearn.org/layers/core/#input-data input_layer = input_data(shape=[None, image_size, image_size, 3], name='input_layer') #,data_preprocessing=img_prep) #--------------------------------------------------------------------------------------------- #-------------------------------create model-------------------------------------------------------- # network if model_name.split('.')[0].split('-')[0] == 'inception': softmax = deep_learning.inception(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'ResNet': softmax = deep_learning.ResNet(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'VGGNet': softmax = deep_learning.VGGNet(input_layer, 2) elif model_name.split('.')[0].split('-')[0] == 'NiN': softmax = deep_learning.NiN(input_layer, 2) else: softmax = deep_learning.inception(input_layer, 2) #softmax = deep_learning.inception(input_layer, 2) #softmax = deep_learning.VGGNet(input_layer, 2) # estimator layer f_score = tflearn.metrics.F2Score() momentum = Momentum(learning_rate=0.1, lr_decay=0.9, decay_step=250) network = tflearn.regression( softmax, optimizer='adam', loss='categorical_crossentropy', learning_rate=0.0001, metric=f_score) #if want to finetune give 'restore=False' # model http://tflearn.org/models/dnn/ model = tflearn.DNN(network, checkpoint_path='model_' + model_name, max_checkpoints=1, tensorboard_verbose=0, tensorboard_dir="./logs_test") if os.path.isfile(model_name) and not clean_start: model.load(model_name) #model.fit(X_train, Y_train, validation_set = (X_test, Y_test),n_epoch=epoch_num, shuffle=True, # show_metric=True, batch_size=100, snapshot_step=100, snapshot_epoch=False, run_id='inception_ercis') #--------------------------------------------------------------------------------------------- #model.save('inception.model') temp = [] counter = 0 for x in X_test: temp.append(model.predict(x.reshape(1, 40, 40, 3))[0]) counter += 1 print '{0}\r'.format(counter), #print temp predict = temp with open('results/test_pred_{0}.pik'.format(gettime()), 'w') as f: pickle.dump(predict, f) target = np.argmax(Y_test[()], axis=1) pred = np.argmax(predict, axis=1) #print Y_test.shape #for x,y in zip(target, pred): # print x, y print type(target) print target.shape print type(pred) print pred.shape #for y in Y_test: # print y #try reporting #try: print 'accuracy_score: ', accuracy_score(target, pred) print 'recall_score: ', recall_score(target, pred) print 'precision_score: ', precision_score(target, pred) print 'f2_score: ', fbeta_score(target, pred, 2) print 'confusion_matrix: ' print confusion_matrix(target, pred) with open('results/results.txt', 'a+') as f: f.write('# ' + model_name.split('_')[0] + '_' + gettime() + '\n') f.write('accuracy_score: {0}\n'.format(accuracy_score(target, pred))) f.write('recall_score: {0}\n'.format(recall_score(target, pred))) f.write('precision_score: {0}\n'.format(precision_score(target, pred))) f.write('f2_score: {0}\n'.format(fbeta_score(target, pred, 2))) f.write('confusion_matrix: \n') f.write(str(confusion_matrix(target, pred))) f.write('\n\n\n')
import tensorflow as tf # import data (x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar100.load_data(label_mode='fine') # data setting y_train = y_train.reshape(50000,) y_test = y_test.reshape(10000,) train_data = np.asarray(x_train, dtype=np.float32) train_labels =np.asarray(y_train, dtype=np.float32) eval_data = np.asarray(x_test, dtype=np.float32) eval_labels = np.asarray(y_test, dtype=np.float32) # one hot encoding y_train = tflearn.data_utils.to_categorical(y_train, 100) y_test = tflearn.data_utils.to_categorical(y_test, 100) # image argumentation image_preprocessing = tflearn.ImagePreprocessing() image_preprocessing.add_featurewise_zero_center(per_channel=True) image_argumentation = tflearn.ImageAugmentation() image_argumentation.add_random_flip_leftright() image_argumentation.add_random_crop([32, 32], padding=4) # build 56 layers residual layers n = 9 net = tflearn.input_data(shape=[None, 32, 32, 3], data_preprocessing=image_preprocessing, data_augmentation=image_argumentation) net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001) net = tflearn.residual_block(net, n, 16) net = tflearn.residual_block(net, 1, 32, downsample=True) net = tflearn.residual_block(net, n-1, 32) net = tflearn.residual_block(net, 1, 64, downsample=True) net = tflearn.residual_block(net, n-1, 64)
def image_prep(self, stdn = True, mean = True): image_prep = tfl.ImagePreprocessing() if stdn: image_prep.add_featurewise_stdnorm(per_channel=True) if mean: image_prep.add_featurewise_zero_center(per_channel=True) return image_prep
def cnn_model_ic(features, labels, mode): """Model function for CNN.""" # Real-time data preprocessing print("Doing preprocessing...") img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True, mean=[0.573364,0.44924123,0.39455055]) # Real-time data augmentation print("Building augmentation...") img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([128, 128], padding=4) # Input Layer # Reshape X to 4-D tensor: [batch_size, width, height, channels] # 61326 images are 4160x3120 pixels, i resize to 128*128 and have three color channel input_layer = tflearn.input_data(shape=[-1, 128, 128, 3], data_preprocessing=img_prep, data_augmentation=img_aug) input_layer = tf.reshape(features["x"], [-1, 128, 128, 3]) # Convolutional Layer #1 # Computes 32 features using a 5x5 filter with ReLU activation. # Padding is added to preserve width and height. # Input Tensor Shape: [batch_size, 128, 128, 1] # Output Tensor Shape: [batch_size, 128, 128, 32] conv1 = tf.layers.conv2d( inputs=input_layer, filters=32, kernel_size=[5, 5], padding="same", activation=tf.nn.relu) print "Conv1 is completed" # Pooling Layer #1 # First max pooling layer with a 2x2 filter and stride of 2 # Input Tensor Shape: [batch_size, 128, 128, 32] # Output Tensor Shape: [batch_size, 64, 64, 32] pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2) # Convolutional Layer #2 # Computes 64 features using a 5x5 filter. # Padding is added to preserve width and height. # Input Tensor Shape: [batch_size, 64, 64, 32] # Output Tensor Shape: [batch_size, 64, 64, 64] print "Conv2 is in progress" conv2 = tf.layers.conv2d( inputs=pool1, filters=64, kernel_size=[5, 5], padding="same", activation=tf.nn.relu) # Pooling Layer #2 # Second max pooling layer with a 2x2 filter and stride of 2 # Input Tensor Shape: [batch_size, 64, 64, 64] # Output Tensor Shape: [batch_size, 32, 32, 64] print "Conv2 is completed" pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2) # Flatten tensor into a batch of vectors # Input Tensor Shape: [batch_size, 32, 32, 64] # Output Tensor Shape: [batch_size, 32 * 32 * 64] print "pool2 is in processing" pool2_flat = tf.reshape(pool2, [-1, 32 * 32 * 64]) print "pool2 is completed" # Dense Layer # Densely connected layer with 1024 neurons # Input Tensor Shape: [batch_size, 32 * 32 * 64] # Output Tensor Shape: [batch_size, 1024] dense = tf.layers.dense(inputs=pool2_flat, units=1024, activation=tf.nn.relu) # Add dropout operation; 0.6 probability that element will be kept dropout = tf.layers.dropout( inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN) # Logits layer # Input Tensor Shape: [batch_size, 1024] # Output Tensor Shape: [batch_size, 6] logits = tf.layers.dense(inputs=dropout, units=7) predictions = { # Generate predictions (for PREDICT and EVAL mode) "classes": tf.argmax(input=logits, axis=1), # Add `softmax_tensor` to the graph. It is used for PREDICT and by the # `logging_hook`. "probabilities": tf.nn.softmax(logits, name="softmax_tensor") } if mode == tf.estimator.ModeKeys.PREDICT: return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions) # Calculate Loss (for both TRAIN and EVAL modes) loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits) # Configure the Training Op (for TRAIN mode) if mode == tf.estimator.ModeKeys.TRAIN: optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001) train_op = optimizer.minimize( loss=loss, global_step=tf.train.get_global_step()) return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op) # Add evaluation metrics (for EVAL mode) eval_metric_ops = { "accuracy": tf.metrics.accuracy( labels=labels, predictions=predictions["classes"])} return tf.estimator.EstimatorSpec( mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
def AudioPredict(soundfile, class_test,threshold): import argparse import tensorflow as tf import tflearn from tflearn.layers.core import input_data, dropout, fully_connected from tflearn.layers.conv import conv_2d, max_pool_2d from tflearn.layers.normalization import local_response_normalization from tflearn.layers.estimator import regression import os import numpy as np import cv2 from skimage.util.shape import view_as_blocks from skimage.util.shape import view_as_windows np.random.seed(1001) import librosa from pytictoc import TicToc os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' tf.logging.set_verbosity(tf.logging.ERROR) patchscore = float(threshold.decode('base64', 'strict')) timet = TicToc() timet.tic() goobeps=0.82 islandps=0.82 mlworldps=0.82 bootps=0.82 tpcount=2e9 tt=0 classtestlist=['boot','goobe','island', 'mlworld'] for p in range(len(classtestlist)): if class_test==classtestlist[p]: tt+=1 if tt==0: print('class_test ', class_test, ' entered is not valid') print('acceptable class entries: ', classtestlist) print('loading audio file') #load sound file, get melspectrogram, crop overlapping tiles and save tensor X=np.random.random((1,128,128,1)) wav1, sr = librosa.core.load(soundfile) stepper=int(np.ceil(len(wav1)/sr/6)) Sxx=librosa.feature.melspectrogram(wav1) Sxx2 = np.log10(1+10*abs(Sxx)) Sxx2norm=255*(Sxx2-Sxx2.min())/(Sxx2.max()-Sxx2.min()); Sxx2norm=np.round_(Sxx2norm, decimals=0, out=None).astype(int) Sxx2norm=Sxx2norm.astype(np.uint8) if Sxx2norm.shape[1]>=128: s1=int(np.floor(Sxx2norm.shape[1]/128)*128) B = view_as_windows(Sxx2norm, window_shape=(128, 128),step=stepper) for index in range(B.shape[1]): x=B[0][index] x = np.expand_dims(x, axis=0) x = np.expand_dims(x, axis=3) X = np.concatenate((X,x),axis=0) # remove random start X = X[1:,:,:,:] tf.reset_default_graph() # number of classes y=2 # image preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center()# Zero Center (With mean computed over the whole dataset) img_prep.add_featurewise_stdnorm() #STD Normalization (With std computed over the whole dataset) # Building 'AlexNet' network = input_data(shape=[None, 128, 128, 1],data_preprocessing=img_prep) network = conv_2d(network, 96, 11, strides=4, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = conv_2d(network, 256, 5, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = conv_2d(network, 384, 3, activation='relu') network = conv_2d(network, 384, 3, activation='relu') network = conv_2d(network, 256, 3, activation='relu') network = max_pool_2d(network, 3, strides=2) network = local_response_normalization(network) network = fully_connected(network, 4096, activation='tanh') network = dropout(network, 0.5) network = fully_connected(network, 4096, activation='tanh') network = dropout(network, 0.5) network = fully_connected(network, y, activation='softmax') network = regression(network, optimizer='momentum', loss='categorical_crossentropy', learning_rate=0.0001) model = tflearn.DNN(network, checkpoint_path='model_alexnet', max_checkpoints=1, tensorboard_verbose=2) # set up paramaters for model if class_test=='boot': classmodel='AudioModels/model_Alexnet_bootnet1/Alexnet_bootnet1' patchscore=bootps tilepasscount=np.floor(tpcount/(len(wav1)*len(X))) if tilepasscount>len(X): tilepasscount=np.floor(0.75*len(X)) print('loading boot test') elif class_test=='goobe': print('loading goobe test') classmodel='AudioModels/model_Alexnet_goobenet1/Alexnet_goobenet1' patchscore=goobeps tilepasscount=np.floor(tpcount/(len(wav1)*len(X))) if tilepasscount>len(X): tilepasscount=np.floor(0.25*len(X)) elif class_test=='island': print('loading island test') classmodel='AudioModels/model_Alexnet_islandnet1/Alexnet_islandnet1' patchscore=islandps tilepasscount=np.floor(tpcount/(len(wav1)*len(X))) if tilepasscount>len(X): tilepasscount=np.floor(0.25*len(X)) elif class_test=='mlworld': print('loading mlworld test') classmodel='AudioModels/model_Alexnet_mlworldnet1/Alexnet_mlworldnet1' patchscore=mlworldps tilepasscount=np.floor(tpcount/(len(wav1)*len(X))) if tilepasscount>len(X): tilepasscount=np.floor(0.25*len(X)) model.load(classmodel) print("totaltilecount", len(X)) print("tilepasscount", tilepasscount) lastPF=[] # Get prediction of tile list res=model.predict(X) print(res) # method 1: PASS if any one tile gets 99% or better topmatch=0 for k in range(len(res[:,0])): if res[k,0]>=0.99: topmatch+=1 # tally consecutive tiles that meet the threshold z = np.where((res[:,0]-patchscore)>0) z=z[0] tally=[0] for j in range(len(z)-1): if z[j+1]-z[j]==1: tally.append(1) if(sum(tally)!=0): tally.append(1) timet.toc() if(sum(tally)>=tilepasscount or topmatch>=1): lastPF.append(1) print(sum(tally),'/',len(X)) else: lastPF.append(0) print(sum(tally),'/',len(X)) if np.sum(lastPF)>=1: print('PASS') ret ='PASS' return ret else: print('FAIL') ret = 'FAIL' return ret
import csv from os import listdir from tifffile import imread from math import ceil, log import pickle class_map = {0:'building', 1:'barren_land',2:'trees',3:'grassland',4:'road',5:'water'} tflearn.config.init_graph (num_cores=1, gpu_memory_fraction=0.3) # Residual blocks # 256 layers: n=5, 256 layers: n=9, 110 layers: n=18 n = 5 # Real-time data preprocessing img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center([112.3256420256,1256.6802564592,1256.1983022562], per_channel=True) # Building Residual Network net = tflearn.input_data(shape=[None, 28, 28, 3], data_preprocessing=img_prep) net = tflearn.conv_2d(net, 16, 3, regularizer='L2', weight_decay=0.0001) net = tflearn.residual_block(net, n, 16) net = tflearn.residual_block(net, 1, 32, downsample=True) net = tflearn.residual_block(net, n-1, 32) net = tflearn.residual_block(net, 1, 64, downsample=True) net = tflearn.residual_block(net, n-1, 64) net = tflearn.batch_normalization(net) net = tflearn.activation(net, 'relu') net = tflearn.global_avg_pool(net)
def main(args): # Data loading fid = args.fid + "train" data = unpickle(fid) n_class = args.nclass train_feats, train_labs = load_data(args, "train") test_feats, test_labs = load_data(args, "test") # Real-time data preprocessing mean = [129.30416561, 124.0699627, 112.43405006] std = [51.20360335, 50.57829831, 51.56057865] img_prep = tflearn.ImagePreprocessing() img_prep.add_featurewise_zero_center(per_channel=True, mean=mean) img_prep.add_featurewise_stdnorm(per_channel=True, std=std) # Real-time data augmentation img_aug = tflearn.ImageAugmentation() img_aug.add_random_flip_leftright() img_aug.add_random_crop([32, 32], padding=4) # DenseNet depth = args.depth filters = args.growth_rate nb_blocks = 3 #nb_layers_list = [6,12,48,32] nb_layers_list = [(depth - (nb_blocks + 1)) // (2 * nb_blocks) for i in range(nb_blocks)] print(nb_layers_list) net = tflearn.input_data(shape=[None, 32, 32, 3], data_preprocessing=img_prep, data_augmentation=img_aug) print("input", net) net = tflearn.conv_2d(net, nb_filter=2 * filters, filter_size=3, strides=1, padding='same', activation='linear', bias=False, name='conv0', regularizer='L2', weight_decay=1e-4) # net = tflearn.max_pool_2d(net, kernel_size=3, strides=2, padding='valid') print("init_layer", net) for i in range(nb_blocks - 1): net = dense_block(net, filters, nb_layers=nb_layers_list[i], layer_name='dense_' + str(i + 1)) net = transition_layer(net, scope='trans_' + str(i + 1)) net = dense_block(net, filters, nb_layers=nb_layers_list[-1], layer_name='dense_final') # Global Avg + FC net = tflearn.batch_normalization(net, scope='linear_batch') net = tf.nn.relu(net) net = tflearn.global_avg_pool(net) if args.finetune == 1: net = tflearn.fully_connected(net, n_class, activation='softmax', regularizer='L2', weight_decay=1e-4, restore=False) else: net = tflearn.fully_connected(net, n_class, activation='softmax', regularizer='L2', weight_decay=1e-4) # Optimizer opt = tf.train.MomentumOptimizer(learning_rate=args.lr, momentum=0.9, use_nesterov=True) epsilon = 1e-4 learning_rate = 1e-4 # opt = tf.train.AdamOptimizer(learning_rate=learning_rate, epsilon=epsilon) # Regression net = tflearn.regression(net, optimizer=opt, loss='categorical_crossentropy', restore=False) # Training config = tf.ConfigProto() config.allow_soft_placement = True config.gpu_options.allow_growth = True tf.add_to_collection(tf.GraphKeys.GRAPH_CONFIG, config) model = tflearn.DNN(net, checkpoint_path='/data/srd/models/image/model_' + args.model_name + '/model', tensorboard_dir='/data/srd/logs/image/log_' + args.model_name, max_checkpoints=3, tensorboard_verbose=0, clip_gradients=0.0) if args.onlyevalue == 1: model.load("/data/srd/models/image/" + args.pre_train + "/model.tfl") n_test = len(test_feats) n_batch = 10 batch_size = n_test / 10 labsp = model.predict(test_feats[0:batch_size]) for i in range(1, 10): labsp = np.vstack([ labsp, model.predict(test_feats[i * batch_size:(i + 1) * batch_size]) ]) print(metrics.classification_report(test_labs, np.argmax(labsp, 1))) print("acc:", metrics.accuracy_score(test_labs, np.argmax(labsp, 1))) np.argmax(labsp, 1).tofile("/data/srd/data/cifar/" + args.pre_train + ".bin") return # pre-train model if args.pre_train: model.load("/data/srd/models/image/" + args.pre_train + "/model.tfl", weights_only=True) try: model.fit(train_feats, train_labs, n_epoch=args.epoch, validation_set=(test_feats, test_labs), snapshot_epoch=False, snapshot_step=500, show_metric=True, batch_size=64, shuffle=True, run_id=args.model_name) except KeyboardInterrupt: print("Keyboard Interrupt") model.save("/data/srd/models/image/" + args.model_name + "/model.tfl")