# 200 print('np.prod(new_gt_IN.shape[:2]:', np.prod(new_gt_IN.shape[:2])) # 21025 data = data_IN.reshape(np.prod(data_IN.shape[:2]), np.prod(data_IN.shape[2:])) gt = new_gt_IN.reshape(np.prod(new_gt_IN.shape[:2]), ) data = preprocessing.scale(data) print('data.shape:', data.shape) # (21025, 200) data_ = data.reshape(data_IN.shape[0], data_IN.shape[1], data_IN.shape[2]) # (145, 145, 200) whole_data = data_ padded_data = zeroPadding.zeroPadding_3D(whole_data, PATCH_LENGTH) print('padded_data.shape:', padded_data.shape) ITER = 1 CATEGORY = 9 # 16 train_data = np.zeros((TRAIN_SIZE, 2 * PATCH_LENGTH + 1, 2 * PATCH_LENGTH + 1, INPUT_DIMENSION_CONV)) print('train_data.shape:', train_data.shape) # (2055, 11, 11, 200) test_data = np.zeros((TEST_SIZE, 2 * PATCH_LENGTH + 1, 2 * PATCH_LENGTH + 1, INPUT_DIMENSION_CONV)) print('test_data.shape:', test_data.shape) # (8194, 11, 11, 200) KAPPA_3D_ResNeXt = []
print('data.shape:', data.shape) data1 = data_IN1.reshape(np.prod(data_IN1.shape[:2]), np.prod(data_IN1.shape[2:])) print('data.shape:', data1.shape) gt = new_gt_IN.reshape(np.prod(new_gt_IN.shape[:2]),) print('gt.shape:', gt.shape) data = preprocessing.scale(data) data_ = data.reshape(data_IN.shape[0], data_IN.shape[1],data_IN.shape[2]) data1 = preprocessing.scale(data1) data1_ = data1.reshape(data_IN1.shape[0], data_IN1.shape[1],data_IN1.shape[2]) whole_data = data_ whole_data1 = data1_ padded_data = zeroPadding.zeroPadding_3D(whole_data, PATCH_LENGTH) # 1 print("whole_data.shape:", whole_data.shape) padded_data1 = zeroPadding.zeroPadding_3D(whole_data1, PATCH_LENGTH1) # 13 print("whole_data.shape:", whole_data1.shape) ITER = 1 CATEGORY = 13 train_data = np.zeros((TRAIN_SIZE, 2*PATCH_LENGTH + 1, 2*PATCH_LENGTH + 1, INPUT_DIMENSION_CONV)) train_data1 = np.zeros((TRAIN_SIZE, 2*PATCH_LENGTH1 + 1, 2*PATCH_LENGTH1 + 1, INPUT_DIMENSION_CONV1)) test_data = np.zeros((TEST_SIZE, 2*PATCH_LENGTH + 1, 2*PATCH_LENGTH + 1, INPUT_DIMENSION_CONV)) test_data1 = np.zeros((TEST_SIZE, 2*PATCH_LENGTH1 + 1, 2*PATCH_LENGTH1 + 1, INPUT_DIMENSION_CONV1))
def run_training(): # load the data print (150*'*') uPavia = sio.loadmat('/home/amax/xibobo/data/UP/PaviaU.mat') gt_uPavia = sio.loadmat('/home/amax/xibobo/data/UP/PaviaU_combinedGt.mat') data_IN = uPavia['paviaU'] gt_IN = gt_uPavia['combinedGt'] print (data_IN.shape) data = data_IN.reshape(np.prod(data_IN.shape[:2]),np.prod(data_IN.shape[2:])) gt = gt_IN.reshape(np.prod(gt_IN.shape[:2]),) #[2]: trainingIndexf = '/home/amax/xibobo/data/DisjointUPtrainingIndexMix.mat' train_indices = sio.loadmat(trainingIndexf)['trainingIndexMix'] train_indices_rows = sio.loadmat(trainingIndexf)['trainingIndexMix_rows'] train_indices_cols = sio.loadmat(trainingIndexf)['trainingIndexMix_cols'] testingIndexf = '/home/amax/xibobo/data/DisjointUPtestingIndexMix.mat' test_indices = sio.loadmat(testingIndexf)['testingIndexMix'] test_indices_rows = sio.loadmat(testingIndexf)['testingIndexMix_rows'] test_indices_cols = sio.loadmat(testingIndexf)['testingIndexMix_cols'] train_indices = np.squeeze(train_indices-1) test_indices = np.squeeze(test_indices-1) height = gt_IN.shape[0] width = gt_IN.shape[1] Y=gt_IN.T Y = Y.reshape(height*width,) train_y = Y[train_indices]-1 y_train = to_categorical(np.asarray(train_y)) test_y = Y[test_indices] - 1 y_test = to_categorical(np.asarray(test_y)) TRAIN_SIZE = train_indices.shape[0] TEST_SIZE = test_indices.shape[0] classes_num = np.max(gt) data = preprocessing.scale(data) whole_data = data.reshape(data_IN.shape[0], data_IN.shape[1], data_IN.shape[2]) whole_data,pca = applyPCA(whole_data, numComponents = numComponents) img_channels= whole_data.shape[2] padded_data = zeroPadding.zeroPadding_3D(whole_data, PATCH_LENGTH) train_data = np.zeros((TRAIN_SIZE, 2*PATCH_LENGTH + 1, 2*PATCH_LENGTH + 1, img_channels)) test_data = np.zeros((TEST_SIZE, 2*PATCH_LENGTH + 1, 2*PATCH_LENGTH + 1, img_channels)) train_assign = indexToAssignment(np.squeeze(train_indices_rows-1), np.squeeze(train_indices_cols-1), PATCH_LENGTH) for i in range(len(train_assign)): train_data[i] = selectNeighboringPatch(padded_data,train_assign[i][0],train_assign[i][1],PATCH_LENGTH) # test_assign = indexToAssignment(np.squeeze(test_indices_rows-1), np.squeeze(test_indices_cols-1), PATCH_LENGTH) for i in range(len(test_assign)): test_data[i] = selectNeighboringPatch(padded_data,test_assign[i][0],test_assign[i][1],PATCH_LENGTH) Xtrain = train_data.reshape(train_data.shape[0], train_data.shape[1], train_data.shape[2],img_channels) Xtest = test_data.reshape(test_data.shape[0], test_data.shape[1], test_data.shape[2], img_channels) train_x = Xtrain.reshape(-1,window_size,window_size,img_channels,1) test_x = Xtest.reshape(-1, window_size,window_size,img_channels,1) train_num = train_x.shape[0] test_num = test_x.shape[0] # construct the computation graph images = tf.placeholder(tf.float32, shape=[None,window_size,window_size,img_channels,1]) labels = tf.placeholder(tf.int32, shape=[None]) lr= tf.placeholder(tf.float32) features,_ = res4_model_ss(images,classes_num,[1],[1]) centers = func.construct_center(features, classes_num, 1) loss1 = func.dce_loss(features, labels, centers, FLAGS.temp) # loss2 = func.mcl_loss(features, labels, centers, 0.9) # loss2 = func.gmcl_loss(features, labels, centers, 0.9) loss2 = func.dis_loss(features, labels, centers) # loss=loss1 loss = loss1 + FLAGS.weight_pl * loss2 # eval_correct = func.evaluation(features, labels, centers) train_op = func.training(loss, lr) #counts = tf.get_variable('counts', [FLAGS.classes_num], dtype=tf.int32, # initializer=tf.constant_initializer(0), trainable=False) #add_op, count_op, average_op = net.init_centers(features, labels, centers, counts) init = tf.global_variables_initializer() # initialize the variables sess = tf.Session() sess.run(init) #compute_centers(sess, add_op, count_op, average_op, images, labels, train_x, train_y) # run the computation graph (train and test process) epoch = 1 index = list(range(train_num)) np.random.shuffle(index) batch_size = FLAGS.batch_size batch_num = train_num//batch_size if train_num % batch_size==0 else train_num//batch_size+1 #saver = tf.train.Saver(max_to_keep=1) train_start= time.time() # train the framework with the training data # while stopping<FLAGS.stop: while epoch<epoch_num: time1 = time.time() loss_now = 0.0 score_now = 0.0 for i in range(batch_num): batch_x = train_x[index[i*batch_size:(i+1)*batch_size]] batch_y = train_y[index[i*batch_size:(i+1)*batch_size]] result = sess.run([train_op, loss, eval_correct], feed_dict={images:batch_x, labels:batch_y, lr:FLAGS.learning_rate}) # init_logits_value = sess.run(logits) loss_now += result[1] score_now += result[2][1] score_now /= train_num print ('epoch {}: training: loss --> {:.3f}, acc --> {:.3f}%'.format(epoch, loss_now, score_now*100)) #print sess.run(centers) #checkpoint_file = os.path.join(FLAGS.log_dir, 'model.ckpt') #saver.save(sess, checkpoint_file, global_step=epoch) # FLAGS.learning_rate*=FLAGS.decay FLAGS.learning_rate-=FLAGS.decay # FLAGS.learning_rate*= (1. / (1. + FLAGS.decay * epoch)) epoch += 1 np.random.shuffle(index) time2 = time.time() print ('time for this epoch: {:.3f} minutes'.format((time2-time1)/60.0)) print() print('time for the whole training phase: '+str(time.time()-train_start)+' s') # test the framework with the test data init_centers_value = sess.run(centers) test_start= time.time() pred_labels, test_score = do_eval(sess, eval_correct, images, labels, test_x, test_y) print('time for the whole testing phase: '+str(time.time()-test_start)+' s') sess.close() pred_labels = np.int8(pred_labels) test_y = np.int8(test_y) # confusion matrix matrix = np.zeros((classes_num, classes_num)) with open('prediction_DPN_HRA.txt', 'w') as f: for i in range(test_num): pre_label = pred_labels[i] f.write(str(pre_label)+'\n') matrix[pre_label, test_y[i]] += 1 f.closed print() print('The confusion matrix is:') print(np.int_(matrix)) # overall accuracy OA=np.sum(np.trace(matrix)) / float(test_num) # print('OA = '+str(OA)+'\n') # average accuracy # print('ua =') ua = np.diag(matrix)/np.sum(matrix, axis=1) # precision # print('precision =') precision = np.diag(matrix)/np.sum(matrix, axis=0) # Kappa matrix = np.mat(matrix); Po = OA; xsum = np.sum(matrix, axis=1); ysum = np.sum(matrix,axis = 0); Pe = float(ysum*xsum)/(np.sum(matrix)**2); Kappa = float((Po-Pe)/(1-Pe)); for i in ua: print(i) print(str(np.sum(ua)/matrix.shape[0])) print(str(OA)) print(str(Kappa)); print() for i in precision: print(i) print(str(np.sum(precision)/matrix.shape[0]))
data = data_IN.reshape(np.prod(data_IN.shape[:2]), np.prod(data_IN.shape[2:])) gt = gt_IN.reshape(np.prod(gt_IN.shape[:2]), ) #data = normalization.Normalization(data) #data_ = data.reshape(data_UP.shape[0], data_UP.shape[1],data_UP.shape[2]) # data_trans = data.transpose() # whole_pca = doPCA.dimension_PCA(data_trans, data_UP, INPUT_DIMENSION) # # print (whole_pca.shape) data_trans = data.transpose() data_ = doPCA.dimension_PCA(data_trans, data_IN, INPUT_DIMENSION) padded_data = zeroPadding.zeroPadding_3D(data_, PATCH_LENGTH) print(padded_data.shape) ITER = 1 CATEGORY = 16 KAPPA_CONV = [] OA_CONV = [] AA_CONV = [] TRAINING_TIME_CONV = [] TESTING_TIME_CONV = [] ELEMENT_ACC_CONV = np.zeros((ITER, CATEGORY)) for index_iter in range(ITER): print("# %d Iteration" % (index_iter + 1))
VERIFICATION_SIZE = 1500 TOTAL_SIZE = TRAIN_SIZE + TEST_SIZE img_channels_HSI = 144 img_channels_HSIEPLBP = 815 img_channels_LiDAREPLBP = 134 CATEGORY = 15 ######### Data normalization ######## data = data_Houston_HSI.reshape(np.prod(data_Houston_HSI.shape[:2]), np.prod( data_Houston_HSI.shape[2:])) # 3D to 2D data = preprocessing.scale(data) #normalization whole_data_HSI = data.reshape(data_Houston_HSI.shape[0], data_Houston_HSI.shape[1], data_Houston_HSI.shape[2]) padded_data_HSI = zeroPadding.zeroPadding_3D(whole_data_HSI, PATCH_LENGTH) del data, data_Houston_HSI data = data_Houston_HSIEPLBP.reshape( np.prod(data_Houston_HSIEPLBP.shape[:2]), np.prod(data_Houston_HSIEPLBP.shape[2:])) # 3维矩阵转换为2维矩阵 data = preprocessing.scale(data) #normalization whole_data_HSIEPLBP = data.reshape(data_Houston_HSIEPLBP.shape[0], data_Houston_HSIEPLBP.shape[1], data_Houston_HSIEPLBP.shape[2]) padded_data_HSIEPLBP = zeroPadding.zeroPadding_3D(whole_data_HSIEPLBP, PATCH_LENGTH) del data, data_Houston_HSIEPLBP data = data_Houston_LiDAREPLBP.reshape( np.prod(data_Houston_LiDAREPLBP.shape[:2]),
def run_training(): # load the data print (150*'*') HU2012 = sio.loadmat('./data/HU2012/2012_Houston.mat') data_IN = HU2012['spectraldata'] gt_IN = HU2012['gt_2012'] print (data_IN.shape) data = data_IN.reshape(np.prod(data_IN.shape[:2]),np.prod(data_IN.shape[2:])) gt = gt_IN.reshape(np.prod(gt_IN.shape[:2]),) trainingIndexf = './data/Houston2012trainingIndex.mat' train_indices = sio.loadmat(trainingIndexf)['trainingIndex'] train_indices_rows = sio.loadmat(trainingIndexf)['trainingIndex_rows'] train_indices_cols = sio.loadmat(trainingIndexf)['trainingIndex_cols'] testingIndexf = './data/Houston2012testingIndex.mat' test_indices = sio.loadmat(testingIndexf)['testingIndex'] test_indices_rows = sio.loadmat(testingIndexf)['testingIndex_rows'] test_indices_cols = sio.loadmat(testingIndexf)['testingIndex_cols'] train_indices = np.squeeze(train_indices-1) test_indices = np.squeeze(test_indices-1) height, width = gt_IN.shape Y=gt_IN.T Y = Y.reshape(height*width,) train_y = Y[train_indices]-1 test_y = Y[test_indices] - 1 classes_num = np.max(gt) data = preprocessing.scale(data) whole_data = data.reshape(data_IN.shape[0], data_IN.shape[1], data_IN.shape[2]) whole_data, pca = applyPCA(whole_data, numComponents = FLAGS.numComponents) img_channels = whole_data.shape[2] PATCH_LENGTH = int((FLAGS.window_size-1)/2) padded_data = zeroPadding.zeroPadding_3D(whole_data, PATCH_LENGTH) train_data = np.zeros((train_indices.shape[0], FLAGS.window_size, FLAGS.window_size, img_channels)) test_data = np.zeros((test_indices.shape[0], FLAGS.window_size, FLAGS.window_size, img_channels)) train_assign = indexToAssignment(np.squeeze(train_indices_rows-1), np.squeeze(train_indices_cols-1), PATCH_LENGTH) for i in range(len(train_assign)): train_data[i] = selectNeighboringPatch(padded_data,train_assign[i][0],train_assign[i][1],PATCH_LENGTH) test_assign = indexToAssignment(np.squeeze(test_indices_rows-1), np.squeeze(test_indices_cols-1), PATCH_LENGTH) for i in range(len(test_assign)): test_data[i] = selectNeighboringPatch(padded_data,test_assign[i][0],test_assign[i][1],PATCH_LENGTH) Xtrain = train_data.reshape(train_data.shape[0], train_data.shape[1], train_data.shape[2],img_channels) Xtest = test_data.reshape(test_data.shape[0], test_data.shape[1], test_data.shape[2], img_channels) train_x = Xtrain.reshape(-1,train_data.shape[1], train_data.shape[2],img_channels,1) test_x = Xtest.reshape(-1, test_data.shape[1], test_data.shape[2],img_channels,1) train_num = train_x.shape[0] test_num = test_x.shape[0] # construct the computation graph images = tf.placeholder(tf.float32, shape=[None,FLAGS.window_size,FLAGS.window_size,img_channels,1]) labels = tf.placeholder(tf.int32, shape=[None]) lr= tf.placeholder(tf.float32) features = res4_model_ss(images,[1],[1]) prototypes = func.construct_center(features, classes_num, 1) loss1 = func.dce_loss(features, labels, prototypes, FLAGS.temp) loss2 = func.dis_loss(features, labels, prototypes) loss = loss1 + FLAGS.weight_dis * loss2 eval_correct = func.evaluation(features, labels, prototypes) train_op = func.training(loss, lr) # initialize the variables init = tf.global_variables_initializer() sess = tf.Session() sess.run(init) # run the computation graph (train and test process) epoch = 1 index = list(range(train_num)) np.random.shuffle(index) batch_size = FLAGS.batch_size batch_num = train_num//batch_size if train_num % batch_size ==0 else train_num//batch_size+1 train_start= time.time() # train the framework with the training data while epoch<FLAGS.epoch_num: time1 = time.time() loss_now = 0.0 score_now = 0.0 for i in range(batch_num): batch_x = train_x[index[i*batch_size:(i+1)*batch_size]] batch_y = train_y[index[i*batch_size:(i+1)*batch_size]] result = sess.run([train_op, loss, eval_correct], feed_dict={images:batch_x, labels:batch_y, lr:FLAGS.learning_rate}) loss_now += result[1] score_now += result[2][1] score_now /= train_num print ('epoch {}: training: loss --> {:.3f}, acc --> {:.3f}%'.format(epoch, loss_now, score_now*100)) FLAGS.learning_rate-=FLAGS.decay epoch += 1 np.random.shuffle(index) time2 = time.time() print ('time for this epoch: {:.3f} minutes'.format((time2-time1)/60.0)) print() print('time for the whole training phase: '+str(time.time()-train_start)+' s') # test the framework with the test data # init_prototypes_value = sess.run(prototypes) # get the variable of prototypes test_start= time.time() pred_labels, test_score = do_eval(sess, eval_correct, images, labels, test_x, test_y) print('time for the whole testing phase: '+str(time.time()-test_start)+' s') sess.close() pred_labels = np.int8(pred_labels) test_y = np.int8(test_y) # confusion matrix matrix = np.zeros((classes_num, classes_num)) with open('prediction.txt', 'w') as f: for i in range(test_num): pre_label = pred_labels[i] f.write(str(pre_label)+'\n') matrix[pre_label, test_y[i]] += 1 f.closed print() print('The confusion matrix is:') print(np.int_(matrix)) # calculate the overall accuracy OA = np.sum(np.trace(matrix)) / float(test_num) # print('OA = '+str(OA)+'\n') # calculate the per-class accuracy # print('ua =') ua = np.diag(matrix)/np.sum(matrix, axis=0) # calculate the precision # print('precision =') precision = np.diag(matrix)/np.sum(matrix, axis=1) # calculate the Kappa coefficient matrix = np.mat(matrix) Po = OA xsum = np.sum(matrix, axis=1) ysum = np.sum(matrix, axis=0) Pe = float(ysum*xsum)/(np.sum(matrix)**2) Kappa = float((Po-Pe)/(1-Pe)) ## print the classification result for i in ua: print(i) print(str(np.sum(ua)/matrix.shape[0])) print(str(OA)) print(str(Kappa)) print() for i in precision: print(i) print(str(np.sum(precision)/matrix.shape[0]))