def generateCompositeProducts(self, dataset, out_path): """ Placeholder """ # create product path product_path = os.path.join(out_path, 'composite') if not os.path.exists(product_path): os.makedirs(product_path, 0o755) # get channel images pertaining to product print('Creating composite products: {}'.format(product_path)) for product in self._products['composite']: rgb = [] for index in product['channels']: rgb.append(self.getChannelData(dataset, index)) # save rgb image rgb_pathname = os.path.join(product_path, product['name'] + '.jpg') save_rgb(rgb_pathname, np.dstack(rgb), stretch=(0.02, 0.98)) # save decorrelation stretch version of rgb image dcs_pathname = rgb_pathname.replace('.jpg', '-dcs.jpg') execute( os.path.join(os.path.dirname(sys.path[0]), '../bin/dstretch'), [rgb_pathname, dcs_pathname]) # copy dcs image into geotiff self.writeGeoImage(dcs_pathname, dataset['srs']) return
def getClassificationImages(model, X, y, filename, PATCH_SIZE=5, isSave=True, isShow=False): height = y.shape[0] width = y.shape[1] outputs = np.zeros((height, width)) for i in range(height - PATCH_SIZE + 1): for j in range(width - PATCH_SIZE + 1): target = int(y[i + int(PATCH_SIZE / 2), j + int(PATCH_SIZE / 2)]) if target == 0: continue else: image_patch = Patch(X, i, j) X_test_image = image_patch.reshape( 1, image_patch.shape[2], image_patch.shape[0], image_patch.shape[1]).astype('float32') prediction = (model.predict_classes(X_test_image)) outputs[i + int(PATCH_SIZE / 2)][j + int(PATCH_SIZE / 2)] = prediction + 1 if isSave == True: spectral.save_rgb(filename, data=outputs.astype(int), colors=spectral.spy_colors) if isShow == True: predict_image = spectral.imshow(classes=outputs.astype(int), figsize=(5, 5))
def avg_accuracy(): total = 0 loss = 0 model = load_model(os.getcwd()+'/mymodel.h5') data_path = os.path.join(os.getcwd(),'test_sar') label_path = os.path.join(os.getcwd(),'test_optical') input_images = os.listdir(data_path) label_images = os.listdir(label_path) i = 0 for image in input_images: #print(image.type) X_test = imageio.imread(os.getcwd()+'/test_sar/{}'.format(image)) y_test = imageio.imread(os.getcwd()+'/test_optical/{}'.format(image)) #print(y) y_test = label_creator(y_test) X_test,y_test= createPatches(X_test, y_test, windowSize=5) #X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[3], X_test.shape[1], X_test.shape[2])) y_test = to_categorical(y_test) os.chdir(os.getcwd()) classification, confusion, Test_loss, Test_accuracy = reports(X_test,y_test) Y_pred = model.predict(X_test) y_pred = np.argmax(Y_pred, axis=1) img = np.zeros((256,256)) j = 0 for col in range(256): for row in range(256): img[col][row] = (y_pred[j]) j+=1 res = Image.fromarray(img, mode = 'RGB') with open(os.path.join(os.getcwd()+'/predicts', '{}'.format(image)), 'w') as f: res.save(f) #predict_image = spectral.imshow(classes = img.astype(int),figsize =(5,5)) spectral.save_rgb(os.getcwd()+'/pred/{}'.format(image),img) if i==0: acc = Test_accuracy loss = Test_loss acc = float((acc+Test_accuracy)/2) loss = float((loss+Test_loss)/2) print(i,'--------------') print(image) print('Average Test Accuracy: ' + str(acc)) print('Average Test Loss: ' + str(loss)) i+=1 #acc = float(total/200) #avg_Loss = float(loss/200) return acc,loss
def process2(index1,index2,index3): global m l=[] print(b[index1],b[index2],b[index3]) l.append(b[index1]) l.append(b[index2]) l.append(b[index3]) m+=1 Raster_data = HSI[:,:,:] hsi_rgb_file_name = 'G:/Hyperspectral/slice/D7_triple_band/d7_{}_{}_{}.jpg'.format(b[index1],b[index2],b[index3])#要保存RGB图像的名称 spectral.save_rgb(hsi_rgb_file_name, Raster_data,l) l.clear()
def select_roi(input_path, output_path, output_path_rgb, rgb_bands): img = envi.open(input_path) # Make RGB image spectral.save_rgb(output_path_rgb, img, bands=rgb_bands) # Select ROI with cv2 im = cv2.imread(output_path_rgb) from_center = False # We use this variable for parameter clarification in cv2.selectROI() r = cv2.selectROI("Image", im, from_center) return input_path, output_path, output_path_rgb, rgb_bands, r
def process1(index1,index2): global n l=[] print(a[index1],a[index2]) l.append(a[index1]) l.append(a[index2]) l.append(0) n+=1 Raster_data = HSI[:,:,:] hsi_rgb_file_name = 'G:/Hyperspectral/slice/D7_double_band/d7_{}_{}.jpg'.format(a[index1],a[index2])#要保存RGB图像的名称 spectral.save_rgb(hsi_rgb_file_name, Raster_data,l) l.clear()
def hyperspectral(image): img = sp.open_image(image) view = sp.imshow(img, (4, 3, 2)) sp.save_rgb('false_color.jpg', img, (4, 3, 2)) print(img.shape) print(view) print(img) red = img[:, :, 2] nir = img[:, :, 3] ndvi = ((nir - red) / (nir + red + 0.00001)) sp.imshow(ndvi) sp.save_rgb('ndvi.jpg', ndvi) sp.imshow(img, (6, 6, 0))
def mapping(model): X, y = loadTiff() X, _sclaer = standartizeData(X) height = y.shape[0] width = y.shape[1] PATCH_SIZE = windowSize outputs = np.zeros((height, width)) time_start = time.time() for i in range(height - PATCH_SIZE + 1): # print(i / (height - PATCH_SIZE + 1)) patch1 = Patch(X, 1, 1, PATCH_SIZE) pred_line = np.zeros((width - PATCH_SIZE + 1, patch1.shape[0], patch1.shape[1], patch1.shape[2], 1)) for j in range(width - PATCH_SIZE + 1): target = int(y[i + PATCH_SIZE // 2, j + PATCH_SIZE // 2]) # 要不要预测无标签区域? # if target == 0: # continue # else: image_patch = Patch(X, i, j, PATCH_SIZE) # print (image_patch.shape) X_test_image = image_patch.reshape(1, image_patch.shape[0], image_patch.shape[1], image_patch.shape[2], 1).astype('float32') pred_line[j, :, :, :, :] = X_test_image prediction = model.predict_classes(pred_line) # print(prediction) outputs[i + PATCH_SIZE // 2][PATCH_SIZE // 2:width - PATCH_SIZE // 2] = prediction + 1 end_time = time.time() print("Prediction Time", end_time - time_start) ground_truth = spectral.imshow(classes=y, figsize=(5, 5)) spectral.save_rgb("ground_truth.png", y, colors=spectral.spy_colors) predict_image = spectral.imshow(classes=outputs.astype(int), figsize=(5, 5)) results_name = '3D' + 'INSize' + str(windowSize) + \ 'testRatio' + str(testRatio) + 'kdepth' + str(kdepth) + 'vol_num' + str(vol_num) + \ '.png' if is_1d: results_name = '3D-1d' + 'INSize' + str(windowSize) + \ 'testRatio' + str(testRatio) + 'kdepth' + str(kdepth) + 'vol_num' + str(vol_num) + \ '.png' spectral.save_rgb("results/" + results_name, outputs.astype(int), colors=spectral.spy_colors)
def view_clz_map_spyversion4single_img(self, gt, y_test_index, y_predicted, save_path=None, show_error=False, show_axis=False): """ view HSI classification results :param gt: :param y_test_index: test index of excluding 0th classes :param y_predicted: :param show_error: :return: """ n_row, n_column = gt.shape gt_1d = gt.reshape(-1).copy() nonzero_index = gt_1d.nonzero() gt_corrected = gt_1d[nonzero_index] if show_error: t = y_predicted.copy() correct_index = np.nonzero( y_predicted == gt_corrected[y_test_index]) t[correct_index] = 0 # leave error gt_corrected[:] = 0 gt_corrected[y_test_index] = t gt_1d[nonzero_index] = t else: gt_corrected[y_test_index] = y_predicted gt_1d[nonzero_index] = gt_corrected gt_map = gt_1d.reshape((n_row, n_column)).astype('uint8') spy.imshow(classes=gt_map) if save_path != None: import matplotlib.pyplot as plt spy.save_rgb('temp.png', gt_map, colors=spy.spy_colors) if show_axis: plt.savefig(save_path, format='eps', bbox_inches='tight') else: plt.axis('off') plt.savefig(save_path, format='eps', bbox_inches='tight') # self.classification_map(gt_map, gt, 24, save_path) print('the figure is saved in ', save_path)
def classify(model_path='my_model.h5', data_path='data', ground_path='ground_truth.jpg', classification_path='classification.jpg', patch_size=5, numComponents=30): model = loadModel(path=model_path) X, y = loadIndianPinesData(data_path=data_path) outputs = classifyModel(model, X, y, PATCH_SIZE=patch_size, numComponents=numComponents) spectral.save_rgb(ground_path, y, colors=spectral.spy_colors) spectral.save_rgb(classification_path, outputs.astype(int), colors=spectral.spy_colors) return ground_path, classification_path
def classify(datasetname, data_process_method=1, model_method=1): if datasetname == "Indian_pines": dataset = Indian_pines labelset = Indian_pines_gt elif datasetname == "PaviaU": dataset = PaviaU labelset = PaviaU_gt else: print("输入参数错误,程序即将退出") return row = labelset.shape[0] col = labelset.shape[1] # 数据预处理 new_data_set,training_data, test_data, training_label, test_label,feature_num,num_class=data_process(dataset, labelset,method=data_process_method) # 预测 predict_label,classes=set_model(datasetname, new_data_set, training_data, test_data, training_label, test_label, num_class, feature_num, method=model_method) # 绘图 result = np.reshape(predict_label, (row, col)) #result = result.astype(int) image = Image.fromarray(result) image.save(datasetname+"_predict.tif") print("预测结果已保存为:"+datasetname+"_predict.tif") sp.save_rgb(datasetname+"_predict.jpg", result, colors=sp.spy_colors) if datasetname=="Indian_pines": sp.save_rgb(datasetname+".jpg", Indian_modify_gt, colors=sp.spy_colors) unit.performence_get(datasetname+"_predict.tif",dataset_id=0) else: sp.save_rgb(datasetname+".jpg", Pavia_modify_gt, colors=sp.spy_colors) unit.performence_get(datasetname+"_predict.tif",dataset_id=1) print("预测效果可查看图片:"+datasetname+"_predict.jpg")
def save_image(image_numpy, image_path, aspect_ratio=1.0): """Save a numpy image to the disk Parameters: image_numpy (numpy array) -- input numpy array image_path (str) -- the path of the image """ h, w, c = image_numpy.shape if c == 1: spectral.save_rgb(image_path, image_numpy.astype(int), colors=spectral.spy_colors) else: image_pil = Image.fromarray(image_numpy) if aspect_ratio > 1.0: image_pil = image_pil.resize((h, int(w * aspect_ratio)), Image.BICUBIC) if aspect_ratio < 1.0: image_pil = image_pil.resize((int(h / aspect_ratio), w), Image.BICUBIC) image_pil.save(image_path)
def generatePrincipalComponentProducts(self, dataset, out_path): """ Placeholder """ # create product path product_path = os.path.join(out_path, 'pca') if not os.path.exists(product_path): os.makedirs(product_path, 0o755) # get channel images pertaining to product print('Creating principal component products: {}'.format(product_path)) for product in self._products['pca']: channels = [] for index in product['channels']: channels.append(self.getChannelData(dataset, index)) img = np.dstack(channels) # compute pca transformation pc = principal_components(img) img_pc = pc.transform(img) # save rgb image rgb_pathname = os.path.join(product_path, product['name'] + '.jpg') save_rgb(rgb_pathname, img_pc[:, :, :3], stretch=(0.05, 0.95)) # save decorrelation stretch version of rgb image dcs_pathname = rgb_pathname.replace('.jpg', '-dcs.jpg') execute( os.path.join(os.path.dirname(sys.path[0]), '../bin/dstretch'), [rgb_pathname, dcs_pathname]) # copy dcs image into geotiff self.writeGeoImage(dcs_pathname, dataset['srs']) return
confusion_matrix_mss=metrics.confusion_matrix(gt_test[:-VAL_SIZE],pred_test) print(confusion_matrix_mss) average_acc=averageAccuracy.AA_andEachClassAccuracy(confusion_matrix_mss) kappa_value=Kappa.kappa(confusion_matrix_mss) print("training finished.") print('Training Time: ', toc6 - tic6) print('Test time:', toc7 - tic7) print('each_acc', each_acc_res4) print("aa", average_acc_res4) print("oa", overall_acc) print("kappa", kappa) gt[test_indices[:-VAL_SIZE]] = pred_test + 1 gt = gt.reshape(145, 145) save_rgb('IN-DBDA.jpg', gt, colors=spy_colors) # color = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [0.5, 0.5, 1], [0.65, 0.35, 1], [0.75, 0.5, 0.75], [0.75, 1, 0.5], [0.5, 1, 0.65], [0.65, 0.65, 0], [0.75, 1, 0.65], [0, 0, 0.5], [0, 1, 0.75], [0.5, 0.75, 1]]) # color = color*255 newcmap = ListedColormap(color) view = pyplot.imshow(gt.astype(int), cmap=newcmap) bar = pyplot.colorbar() bar.set_ticks(np.linspace(0, 16, 17)) bar.set_ticklabels(('', 'Alfalfa', 'Corn-notill', 'Corn-mintill', 'Corn', 'Grass-pasture', 'Grass-tree', 'Grass-pasture-mowed', 'Hay-windrowed', 'Oats', 'Soybean-notill', 'Soybean-mintill', 'Soybean-clean', 'Wheat', 'Woods', 'Buildings-Grass-Trees-Drives', 'Stone-Steel-Towers')) pyplot.show()
height = y.shape[0] width = y.shape[1] PATCH_SIZE = windowSize X = padWithZeros(X, PATCH_SIZE // 2) # calculate the predicted image outputs = np.zeros((height, width)) for i in range(height): for j in range(width): target = int(y[i, j]) if target == 0: continue else: image_patch = Patch(X, i, j) X_test_image = image_patch.reshape( 1, image_patch.shape[0], image_patch.shape[1], image_patch.shape[2]).astype('float32') np.save('WholePic.npy', X_test_image) Datapath = 'WholePic.npy' Labelpath = 'WholePic.npy' prediction = predict(encoder, model_SVM, Datapath, Labelpath) prediction = int(prediction[0]) outputs[i][j] = prediction + 1 ground_truth = spectral.imshow(classes=y, figsize=(7, 7)) predict_image = spectral.imshow(classes=outputs.astype(int), figsize=(7, 7)) spectral.save_rgb("predictions.jpg", outputs.astype(int), colors=spectral.spy_colors) spectral.save_rgb(str(dataset) + "_ground_truth.jpg", y, colors=spectral.spy_colors) torch.cuda.empty_cache()
def patchify_folds( folds_folders: list, destination: str, patch_size: int = 64, ): """ Performs image patching on the folds. Parameters ---------- folds_folders: list The image folders of the folds destination: str Destination path to save the patches. patch_size: int, optional, default = 64 The size of each patch (`patch_size * patch_size`) """ # If already exists, delete entire tree if os.path.exists(destination): # Force delete shutil.rmtree(destination, ignore_errors=True) for fold_folder in folds_folders: # Grab name of current fold current_fold = fold_folder.split("\\")[1] # Search for folder contents fold_images = glob.glob(fold_folder + "/*") # Iterate over each image folder present in the current fold for image_folder in fold_images: # Get file name file_name = image_folder.split("\\")[-1].split(".hdr")[0] print(f"File {file_name}:") # Search folder contents image_folder_contents = sorted(glob.glob(image_folder + "/*")) # Get the .hdr file image_file = list( filter(lambda file: ".hdr" in file, image_folder_contents) )[0] # Load the .hdr file image = spectral.open_image(image_file).load() # Generate patches image_patches = _patchify(image, patch_size) print( f"\tGenerated {len(image_patches)} patches of size ({patch_size}, {patch_size})" ) for i, patch in enumerate(image_patches): # Generate new format name, ie: "IMAGE_1_PATCH_2_NORMAL" new_image_name = f"{file_name}_PATCH_{i+1}" # Generate path path = f"{destination}/{current_fold}/{new_image_name}/" # Create folders os.makedirs(path) # Create final path final_path = f"{path}{new_image_name}" # Save the patch spectral.envi.save_image(final_path + ".hdr", patch, dtype=np.float32) # Save rgb version spectral.save_rgb(final_path + ".jpg", patch, [29, 19, 9]) print("**" * 30)
def Rnn(self, best_parameters, data, X_train, y_train, X, accuracy): model = Sequential() model.add( LSTM(data[0][best_parameters[0]], input_shape=self.input_shape, return_sequences=False)) model.add(Dropout(0.25)) model.add(Dense(self.number_of_classes, activation='softmax')) model.compile(loss=self.loss, optimizer='adam', metrics=self.metrics) model.summary() model.fit(X_train, np.array(y_train), validation_data=(self.xx_val, np.array(self.yy_val)), epochs=50, verbose=1) prediction = model.predict(X) if not self.state.one_hot_encoding: self.y_test = [x + 1 for x in self.y_test] self.y_train = [x + 1 for x in self.y_train] if len(prediction.shape) == 2: predicted_gt_1 = np.argmax(prediction, axis=1) predicted_gt_1_list = list(predicted_gt_1) predicted_gt_1_list = [x + 1 for x in predicted_gt_1_list] else: predicted_gt_1_list = prediction for i in self.zero_data: predicted_gt_1_list.insert(i, 0) self.predicted_gt_1_list = np.array(predicted_gt_1_list).reshape( self.image_shape[0], self.image_shape[1]) sp.save_rgb('predicted_gt.jpg', self.predicted_gt_1_list, colors=sp.spy_colors) self.predicted_gt = Image.open('predicted_gt.jpg') self.predicted_gt = self.predicted_gt.resize((250, 250), Image.ANTIALIAS) self.predicted_gt = ImageTk.PhotoImage(self.predicted_gt) self.output_detail_frame = tk.Frame(self.output_frame) self.output_detail_frame.grid(row=0, column=0, sticky='nsew') self.accuracy = tk.Label(self.output_detail_frame, text='Accuracy: ' + str(accuracy), background='green') self.accuracy_0 = tk.Label(self.output_detail_frame, background='green') self.accuracy.grid(row=0, column=0, sticky='nsew') self.accuracy_0.grid(row=0, column=1, sticky='nsew') for count, i in enumerate(model.layers): name = i.output.name.split('/')[0].split('_') if len(name) > 2: name = name[0] + '_' + name[1] else: name = name[0] self.label1 = tk.Label(self.output_detail_frame, text=str(name)) self.label2 = tk.Label(self.output_detail_frame, text=str(i.output.shape)) self.label1.grid(row=count + 1, column=0, sticky='nsew') self.label2.grid(row=count + 1, column=1, sticky='nsew') self.output_detail_frame.columnconfigure((0, 1), weight=1)
def clean(dataset_folder, masks_folder): """ Cleans the dataset. """ # Grab the image folders dirs image_folders = sorted(glob.glob(dataset_folder + "/*", )) # Grab the mask dirs mask_dirs = glob.glob( masks_folder + "/**/mask.*", recursive=True, ) # Mask dirs contains .psd files. Use list comprehension to remove them. Sort them by number (ascending). # This is important so mask order matches image folder order mask_dirs = list(filter(lambda path: ".psd" not in path, mask_dirs)) mask_dirs = sorted( mask_dirs, key=lambda file: int(file.split("\\")[-2].split("_")[1])) base_dir = "cleaned_dataset/" # Ensure that new directory is created if os.path.exists(base_dir): shutil.rmtree(base_dir, ignore_errors=True) # Lambda function to process mask (Make it binary) process_mask = lambda mask: np.where(mask > 0, 255, 0) / 255 for i, folder in enumerate(image_folders): # Get the folder name current_folder_name = folder.split("\\")[-1] # Extract the label. 1 is 'pos' in folder name, 0 otherwise label = "INFECTED" if "pos" in current_folder_name else "NORMAL" # Build new folder name new_folder_name = f"{current_folder_name.split('_')[0]}_{label}" # If folder does not exist, create it os.makedirs(base_dir + new_folder_name) # Find the contents of the folder folder_files = glob.glob(folder + "/**") # Filter for the .hdr file image_file = list(filter(lambda file: ".hdr" in file, folder_files))[0] # Load the .hdr file image = spectral.open_image(image_file).load() # Load the mask and process it mask = process_mask(cv2.imread(mask_dirs[i], 0)).astype(np.int8) # Apply mask to image print(f"Image {current_folder_name}:") print(f"\tApplying binary mask ({mask_dirs[i]})") image = cv2.bitwise_and(image, image, mask=mask) # Get final path path = base_dir + new_folder_name # Save .hdr image in final path print(f"\tSaving raw version ({path})") spectral.envi.save_image(path + "/" + new_folder_name + ".hdr", image, dtype=np.float32) # Save .jpg version with 3 random bands print(f"\tSaving jpg version ({path})") spectral.save_rgb(path + "/" + new_folder_name + ".jpg", image, [29, 19, 9]) print("**" * 50)
else: pass margin = int((opt.WINDOW_SIZE - 1) / 2) raw_data_padded = pad_zeros(raw_data, margin=margin) '''calculate the predicted image''' pred_map = np.zeros((raw_label.shape[0], raw_label.shape[1])) for row in range(raw_label.shape[0]): for col in range(raw_label.shape[1]): target = int(raw_label[row, col]) if target == 0: continue else: img_patch = patch(raw_data_padded, row, col) data_te_img = img_patch.reshape(1, img_patch.shape[0], img_patch.shape[1], img_patch.shape[2], 1).astype('float32') _, prediction = classifier.predict(data_te_img) prediction = np.argmax(prediction, axis=1) pred_map[row][col] = prediction + 1 spectral.save_rgb(os.path.join( opt.RESULT, str(opt.DATASET) + "_" + str(opt.ACQUISITION) + "_predictions.jpg"), pred_map.astype(int), colors=spectral.spy_colors) spectral.save_rgb(os.path.join(opt.RESULT, str(opt.DATASET) + "_groundtruth.jpg"), raw_label, colors=spectral.spy_colors)
def __init__(self, master): self.master = master self.state = State() self.population = int(self.state.population) self.generation = int(self.state.generation) self.mutation = float(self.state.mutation) self.crossover = float(self.state.crossover) self.image = np.array(self.load_data(self.state.image_file)) self.image_shape = self.image.shape self.gt = np.array(self.load_data(self.state.gt_file)) sp.save_rgb('image.jpg', self.image, [43, 21, 11]) sp.save_rgb('gt.jpg', self.gt, colors=sp.spy_colors) self.display_input_image() resize_data = self.resize_data(self.image, self.gt) cleaned_data = self.drop_if_gt_zero(resize_data) self.X, y = self.feature_target(cleaned_data) self.number_of_classes = len(np.unique(y)) if self.state.feature_selection: self.X = self.feature_selection(self.X, y) if self.state.one_hot_encoding: y = self.one_hot_encoding(y) if self.state.normalization: self.X = self.standardizing(self.X) if self.state.feature_extraction: self.X = self.feature_extraction(self.X) self.X_train, self.X_test, self.y_train, self.y_test = self.split_data( self.X, y, float(self.state.test_set)) if self.state.model == 'Convolutional Neural Network': number = int(self.X_test.shape[0] / 2) self.xx_test = self.X_test[:number, :] self.xx_val = self.X_test[number:, :] if self.state.one_hot_encoding: self.loss = tensorflow.keras.losses.categorical_crossentropy self.metrics = ['accuracy'] self.yy_test = self.y_test[:number, :] self.yy_val = self.y_test[number:, :] else: self.loss = tensorflow.keras.losses.sparse_categorical_crossentropy self.metrics = ['sparse_categorical_accuracy'] self.y_test = [x - 1 for x in self.y_test] self.y_train = [x - 1 for x in self.y_train] self.yy_test = self.y_test[:number] self.yy_val = self.y_test[number:] feature = self.X.shape[1] if K.image_data_format() == 'channels_first': self.X = self.X.reshape(self.X.shape[0], 1, feature) print('x is reshaped to', self.X.shape) self.X_train = self.X_train.reshape(self.X_train.shape[0], 1, feature) self.xx_test = self.xx_test.reshape(self.xx_test.shape[0], 1, feature) self.xx_val = self.xx_val.reshape(self.xx_val.shape[0], 1, feature) self.input_shape = (1, feature) else: self.X = self.X.reshape(self.X.shape[0], feature, 1) print('x is reshaped to', self.X.shape) self.X_train = self.X_train.reshape(self.X_train.shape[0], feature, 1) self.xx_test = self.xx_test.reshape(self.xx_test.shape[0], feature, 1) self.xx_val = self.xx_val.reshape(self.xx_val.shape[0], feature, 1) self.input_shape = (feature, 1) if self.state.model == 'Recurrent Neural Network': number = int(self.X_test.shape[0] / 2) self.xx_test = self.X_test[:number, :] self.xx_val = self.X_test[number:, :] if self.state.one_hot_encoding: self.loss = tensorflow.keras.losses.categorical_crossentropy self.metrics = ['accuracy'] self.yy_test = self.y_test[:number, :] self.yy_val = self.y_test[number:, :] else: self.loss = tensorflow.keras.losses.sparse_categorical_crossentropy self.metrics = ['sparse_categorical_accuracy'] self.y_test = [x - 1 for x in self.y_test] self.y_train = [x - 1 for x in self.y_train] self.yy_test = self.y_test[:number] self.yy_val = self.y_test[number:] feature = self.X.shape[1] self.X = self.X.reshape(self.X.shape[0], 1, feature) print('x is reshaped to', self.X.shape) self.X_train = self.X_train.reshape(self.X_train.shape[0], 1, feature) self.xx_test = self.xx_test.reshape(self.xx_test.shape[0], 1, feature) self.xx_val = self.xx_val.reshape(self.xx_val.shape[0], 1, feature) self.input_shape = (1, feature) self.model = self.genetic_algorithm(population=self.population, generation=self.generation, crossover=self.crossover, mutation=self.mutation) self.my_thread = threading.Thread(target=self.run_in_thread, args=(self.X_train, self.y_train, self.X)) self.my_thread.start()
gt_corrected = gt_1d[nonzero_index] if show_error: t = y_predicted.copy() correct_index = np.nonzero(y_predicted == gt_corrected[y_test_index]) t[correct_index] = 0 # leave error gt_corrected[:] = 0 gt_corrected[y_test_index] = t gt_1d[nonzero_index] = t else: gt_corrected[y_test_index] = y_predicted gt_1d[nonzero_index] = gt_corrected gt_map = gt_1d.reshape((n_row, n_column)).astype('uint8') spy.imshow(classes=gt_map) if save_path != None: import matplotlib.pyplot as plt spy.save_rgb('temp.png', gt_map, colors=spy.spy_colors) if show_axis: plt.savefig(save_path, format='eps', bbox_inches='tight') else: plt.axis('off') plt.savefig(save_path, format='eps', bbox_inches='tight') # self.classification_map(gt_map, gt, 24, save_path) print('the figure is saved in ', save_path) def classification_map(self, map, groundTruth, dpi, savePath): import matplotlib.pyplot as plt fig = plt.figure(frameon=False) fig.set_size_inches(groundTruth.shape[1] * 2.0 / dpi, groundTruth.shape[0] * 2.0 / dpi) ax = plt.Axes(fig, [0., 0., 1., 1.]) ax.set_axis_off() ax.xaxis.set_visible(False)
'each_acc', each_acc_res4, ) print("oa", overall_acc_res4) print("aa", average_acc_res4) print("kappa", kappa) # modelStatsRecord.outputStats(KAPPA_RES_SS4, OA_RES_SS4, AA_RES_SS4, ELEMENT_ACC_RES_SS4, # TRAINING_TIME_RES_SS4, TESTING_TIME_RES_SS4, # history_res4_SS_BN, loss_and_metrics_res4_SS_BN, CATEGORY, # '/home/zilong/SSRN/records/IN_train_SS_10.txt', # '/home/zilong/SSRN/records/IN_train_SS_element_10.txt') gt1[test_indices[:-VAL_SIZE]] = pred_test_res4 + 1 gt1 = gt1.reshape(349, 1905) save_rgb('houston-SSRN.jpg', gt1, colors=spy_colors) # color = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [0.5, 0.5, 1], [0.65, 0.35, 1], [0.75, 0.5, 0.75], [0.75, 1, 0.5], [0.5, 1, 0.65], [0.65, 0.65, 0], [0.75, 1, 0.65], [0, 0, 0.5], [0, 1, 0.75]]) # color = color*255 newcmap = ListedColormap(color) view = pyplot.imshow(gt1.astype(int), cmap=newcmap) bar = pyplot.colorbar() bar.set_ticks(np.linspace(0, 15, 16)) pyplot.show()
def create_test(config): # Configurable parameters # config = {} # config['patch_size'] = 9 # config['kernel_size'] = 3 # config['conv1_channels'] = 32 # config['conv2_channels'] = 64 # config['fc1_units'] = 1024 # config['batch_size'] = 64 # config['max_epochs'] = 100 # config['train_dropout'] = 0.5 # config['initial_learning_rate'] = 0.01 # config['decaying_lr'] = True log_dir = 'app/static/data/models/' + config['image_name'] + "/" config['log_dir'] = log_dir # Input data if (config['image_name'] == "indianpines"): input = IndianPines_Input.IndianPines_Input() else: input = Salinas_Input.Salinas_Input() X, y = input.read_data(config['patch_size']) tf.reset_default_graph() with tf.Graph().as_default(): # Size of input input_size = len(X) num_batches_per_epoch = int(input_size / config['batch_size']) test_size = len(y) # Create placeholders images_pl, labels_pl = CNNModel_2D.placeholder_inputs( config['patch_size'], input.input_channels) # Build a Graph that computes the logits predictions from the # inference model. logits, keep_prob = CNNModel_2D.inference( images_pl, input.input_channels, config['patch_size'], config['kernel_size'], config['conv1_channels'], config['conv2_channels'], config['fc1_units'], input.num_classes) # Calculate loss. loss = CNNModel_2D.loss(logits, labels_pl) # Build a Graph that trains the model with one batch of examples and # updates the model parameters. # Create a variable to track the global step. global_step = tf.Variable(0, name='global_step', trainable=False) # Define learning rate # Decay once per epoch , using an exponential schedule starting at initial_learning_rate if config['decaying_lr']: learning_rate = tf.train.exponential_decay( config['initial_learning_rate'], # Base learning rate. global_step, # Current index into the dataset. num_batches_per_epoch, # Decay step. 0.96, # Decay rate. staircase=True) else: learning_rate = config['initial_learning_rate'] train_step = CNNModel_2D.training(loss, learning_rate, global_step) # Add the Op to compare the logits to the labels during evaluation. predictions, correct_predictions, accuracy = CNNModel_2D.evaluation( logits, labels_pl) # Add the variable initializer Op. init = tf.global_variables_initializer() # Create a saver for writing training checkpoints. saver = tf.train.Saver() # Create a session for running Ops on the Graph. sess = tf.InteractiveSession() # Run the Op to initialize the variables. sess.run(init) # Create DataBuffer for managing batches of train set data_buffer = DataBuffer.DataBuffer(images=X, labels=y, batch_size=config['batch_size']) # TensorBoard train_writer = tf.summary.FileWriter( log_dir + str(config['id']) + '/train', sess.graph) test_writer = tf.summary.FileWriter(log_dir + str(config['id']) + '/test') with tf.name_scope("accuracy"): acc_var = tf.Variable(0.0) tf.summary.scalar("accuracy", acc_var, collections=['train', 'test']) with tf.name_scope("xent"): xent_var = tf.Variable(0.0) tf.summary.scalar("xent", xent_var, collections=['train', 'test']) merged_summ_training = tf.summary.merge_all('train') merged_summ_test = tf.summary.merge_all('test') # Code for testing the test set in batches (normally too large) test_batch_size = 1000 test_data_buffer = DataBuffer.DataBuffer(images=X, labels=y, batch_size=test_batch_size) test_batch_num = int(math.ceil(len(y) / test_batch_size)) test_eval_freq = 5 def eval_test_set(step, conf_matrix=False): final_test_accuracy, test_loss = 0, 0 y_pred, y_true = [], [] for i in range(test_batch_num): images_batch, labels_batch = test_data_buffer.next_batch( shuffle_data=False) feed_dict_test = { images_pl: images_batch, labels_pl: labels_batch, keep_prob: 1 } batch_loss,batch_correct_predictions,batch_predictions = \ sess.run([loss,tf.reduce_sum(correct_predictions),predictions],feed_dict= feed_dict_test) test_loss += batch_loss final_test_accuracy += batch_correct_predictions final_test_accuracy /= test_size test_loss /= test_batch_num summ_test = sess.run(merged_summ_test, { xent_var: test_loss, acc_var: final_test_accuracy }) test_writer.add_summary(summ_test, step) return final_test_accuracy start_time = time.time() # Start time session['epoch'] = 0 flash(0) for epoch in range(config['max_epochs']): session['epoch'] = epoch print("Session epoch:" + str(session['epoch'])) flash(epoch) for batch_index in range(num_batches_per_epoch + 1): step = tf.train.global_step(sess, global_step) images_batch, labels_batch = data_buffer.next_batch() feed_dict_train_dropout = { images_pl: images_batch, labels_pl: labels_batch, keep_prob: config['train_dropout'] } feed_dict_train_eval = { images_pl: images_batch, labels_pl: labels_batch, keep_prob: 1 } # Evaluate next batch before train train_accuracy = accuracy.eval(feed_dict_train_eval) * 100 if batch_index % 10 == 0: train_loss, train_accuracy = sess.run([loss, accuracy], feed_dict_train_eval) feed_dict_train_eval.update({ xent_var: train_loss, acc_var: train_accuracy }) summ_train = sess.run(merged_summ_training, feed_dict_train_eval) train_writer.add_summary(summ_train, step) #percent_advance = str(batch_index * 100 / num_batches_per_epoch) print( 'Time: ', str( time.strftime( "%Hh%Mm%Ss", time.gmtime((time.time() - start_time))))) print('Epoch %d. Batch index %d, training accuracy %g' % (epoch, batch_index, train_accuracy)) print('---------------\n') # Train model train_step.run(feed_dict_train_dropout) if (epoch % test_eval_freq == 0): test_accuracy = eval_test_set(step) print('---------------') print('Epoch %d. test accuracy %g' % (epoch, test_accuracy * 100)) print('---------------\n') train_writer.close() test_writer.close() save_path = saver.save( sess, log_dir + 'model-' + str(config['id']) + '.ckpt') predicted_image, final_accuracy = Decoder.decode(input, config, save_path) image_path = 'app/static/data/images/outputmap_' + str( config['image_name']) + "_" + str(config['id']) #ground_truth = spectral.imshow(classes = input.target_data,figsize =(9,9)) #predict_image = spectral.imshow(classes = predicted_image.astype(int),figsize =(9,9)) #spectral.save_rgb('gt.png', input.target_data,colors=spectral.spy_colors, format='png') spectral.save_rgb(image_path + ".png", predicted_image, colors=spectral.spy_colors) img = Image.open(image_path + ".png") img = img.resize((700, 700), resample=Image.ANTIALIAS) img.save(image_path + "Big.png") return predicted_image, final_accuracy
print(time.time() - a) y_train, y_test = np.take(y_reduced, train_index, axis=0), np.take(y_reduced, test_index, axis=0) train_positions = np.take(selected_positions, train_index, axis=0) test_positions = np.take(selected_positions, test_index, axis=0) img_train, img_test = input.train_test_images( train_positions, test_positions) save_rgb(fold_dir + "train.png", img_train, format='png') save_rgb(fold_dir + "test.png", img_test, format='png') if rotation_oversampling: X_train, y_train = input.rotation_oversampling( X_train, y_train) print("Size training set", len(X_train)) print("Size test set", len(X_test)) if fold_num == 1: file.write("Size training set: %d\n" % len(X_train)) file.write("Size test set: %d\n" % len(X_test)) file.write("Class distribution:\n") file.write("Train;Test\n") dtrain = Counter(y_train)
def Mlp(self, best_parameters, data, X_train, y_train, X, accuracy): model = MLPClassifier( hidden_layer_sizes=tuple(data[0][best_parameters[0]]), activation='relu', solver='adam', alpha=data[1][best_parameters[1]], batch_size=data[2][best_parameters[2]], learning_rate='constant', learning_rate_init=data[3][best_parameters[3]], power_t=0.5, max_iter=500, shuffle=True, random_state=1, tol=0.0001, verbose=False, warm_start=True, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.18, # 0.33 0.18 beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=data[4][best_parameters[4]], max_fun=15000) model.fit(X_train, y_train) prediction = model.predict(X) if len(prediction.shape) == 2: predicted_gt_1 = np.argmax(prediction, axis=1) predicted_gt_1_list = list(predicted_gt_1) predicted_gt_1_list = [x + 1 for x in predicted_gt_1_list] else: predicted_gt_1_list = prediction for i in self.zero_data: predicted_gt_1_list = np.insert(predicted_gt_1_list, i, 0) # predicted_gt_size = int(math.sqrt(predicted_gt_1_list.shape[0])) self.predicted_gt_1_list = predicted_gt_1_list.reshape( self.image_shape[0], self.image_shape[1]) sp.save_rgb('predicted_gt.jpg', self.predicted_gt_1_list, colors=sp.spy_colors) self.predicted_gt = Image.open('predicted_gt.jpg') self.predicted_gt = self.predicted_gt.resize((250, 250), Image.ANTIALIAS) self.predicted_gt = ImageTk.PhotoImage(self.predicted_gt) self.output_detail_frame = tk.Frame(self.output_frame) self.output_detail_frame.grid(row=0, column=0, sticky='nsew') self.accuracy = tk.Label(self.output_detail_frame, text='Accuracy: ' + str(accuracy)) self.hidden_layer = tk.Label(self.output_detail_frame, text='hidden_layer_sizes: ' + str(data[0][best_parameters[0]])) self.alpha = tk.Label(self.output_detail_frame, text='alpha: ' + str(data[1][best_parameters[1]])) self.degree = tk.Label(self.output_detail_frame, text='batch_size: ' + str(data[2][best_parameters[2]])) self.learning_rate_init = tk.Label(self.output_detail_frame, text='learning_rate_init: ' + str(data[3][best_parameters[3]])) self.n_iter_no_change = tk.Label(self.output_detail_frame, text='n_iter_no_change: ' + str(data[4][best_parameters[4]])) self.accuracy.grid(row=0, column=0, sticky='nsew') self.hidden_layer.grid(row=1, column=0, sticky='nsew') self.alpha.grid(row=2, column=0, sticky='nsew') self.degree.grid(row=3, column=0, sticky='nsew') self.learning_rate_init.grid(row=4, column=0, sticky='nsew') self.n_iter_no_change.grid(row=5, column=0, sticky='nsew') self.output_detail_frame.grid_rowconfigure((0, 1, 2, 3, 4, 5), weight=1) self.output_detail_frame.columnconfigure(0, weight=1)
def Svm(self, best_parameters, data, X_train, y_train, X, accuracy): model = sklearn.svm.SVC( C=data[0][best_parameters[0]], kernel=data[1][best_parameters[1]], degree=data[2][best_parameters[2]], gamma=data[3][best_parameters[3]], coef0=0.0, shrinking=data[4][best_parameters[4]], probability=data[5][best_parameters[5]], tol=0.001, cache_size=200, class_weight=None, verbose=True, max_iter=-1, decision_function_shape=data[6][best_parameters[6]], break_ties=False, random_state=None) model.fit(X_train, y_train) prediction = model.predict(X) predicted_gt_1_list = prediction for i in self.zero_data: predicted_gt_1_list = np.insert(predicted_gt_1_list, i, 0) self.predicted_gt_1_list = predicted_gt_1_list.reshape( self.image_shape[0], self.image_shape[1]) sp.save_rgb('predicted_gt.jpg', self.predicted_gt_1_list, colors=sp.spy_colors) self.predicted_gt = Image.open('predicted_gt.jpg') self.predicted_gt = self.predicted_gt.resize((250, 250), Image.ANTIALIAS) self.predicted_gt = ImageTk.PhotoImage(self.predicted_gt) self.output_detail_frame = tk.Frame(self.output_frame) self.output_detail_frame.grid(row=0, column=0, sticky='nsew') self.accuracy = tk.Label(self.output_detail_frame, text='Accuracy: ' + str(accuracy)) self.C = tk.Label(self.output_detail_frame, text='C: ' + str(data[0][best_parameters[0]])) self.kernel = tk.Label(self.output_detail_frame, text='kernel: ' + str(data[1][best_parameters[1]])) self.degree = tk.Label(self.output_detail_frame, text='degree: ' + str(data[2][best_parameters[2]])) self.gamma = tk.Label(self.output_detail_frame, text='gamma: ' + str(data[3][best_parameters[3]])) self.shrinking = tk.Label(self.output_detail_frame, text='shrinking: ' + str(data[4][best_parameters[4]])) self.probability = tk.Label(self.output_detail_frame, text='probability: ' + str(data[5][best_parameters[5]])) self.decision_function_shape = tk.Label( self.output_detail_frame, text='decision_function_shape: ' + str(data[6][best_parameters[6]])) self.accuracy.grid(row=0, column=0, sticky='nsew') self.C.grid(row=1, column=0, sticky='nsew') self.kernel.grid(row=2, column=0, sticky='nsew') self.degree.grid(row=3, column=0, sticky='nsew') self.gamma.grid(row=4, column=0, sticky='nsew') self.shrinking.grid(row=5, column=0, sticky='nsew') self.probability.grid(row=5, column=0, sticky='nsew') self.decision_function_shape.grid(row=5, column=0, sticky='nsew') self.output_detail_frame.grid_rowconfigure((0, 1, 2, 3, 4, 5, 6, 7), weight=1) self.output_detail_frame.columnconfigure(0, weight=1)
kappa_all[0][num] = kappa KAPPA_RES_SS4.append(kappa) OA_RES_SS4.append(overall_acc_mss) AA_RES_SS4.append(average_acc_mss) print("training finished.") # print('Training Time: ', toc6 - tic6) # print('Test time:', toc7 - tic7) print("# %d Iteration" % (index_iter + 1)) print('each_acc', each_acc_mss) print("oa", overall_acc_mss) print("aa", average_acc_mss) print("kappa", kappa) gt1[test_indices[:-VAL_SIZE]] = pred_test + 1 gt1 = gt1.reshape(349, 1905) save_rgb('houston-DBDA.jpg', gt1, colors=spy_colors) # color = np.array([[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [0.5, 0.5, 1], [0.65, 0.35, 1], [0.75, 0.5, 0.75], [0.75, 1, 0.5], [0.5, 1, 0.65], [0.65, 0.65, 0], [0.75, 1, 0.65], [0, 0, 0.5], [0, 1, 0.75]]) # color = color*255 newcmap = ListedColormap(color) view = pyplot.imshow(gt1.astype(int), cmap=newcmap) bar = pyplot.colorbar() bar.set_ticks(np.linspace(0, 15, 16)) pyplot.show()
def Cnn(self, best_parameters, data, X_train, y_train, X, accuracy): model = Sequential() model.add( Conv1D(filters=data[0][best_parameters[0]], kernel_size=data[4][best_parameters[4]], activation='relu', input_shape=self.input_shape)) model.add( Conv1D(filters=data[0][best_parameters[0]], kernel_size=data[4][best_parameters[4]], activation='relu', input_shape=self.input_shape)) model.add(BatchNormalization()) model.add(MaxPooling1D(pool_size=2)) model.add( Conv1D(filters=data[1][best_parameters[1]], kernel_size=data[5][best_parameters[5]], activation='relu')) model.add( Conv1D(filters=data[1][best_parameters[1]], kernel_size=data[5][best_parameters[5]], activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling1D(pool_size=2)) model.add( Conv1D(filters=data[2][best_parameters[2]], kernel_size=data[5][best_parameters[5]], activation='relu')) model.add( Conv1D(filters=data[2][best_parameters[2]], kernel_size=data[5][best_parameters[5]], activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling1D(pool_size=2)) model.add( Conv1D(filters=data[3][best_parameters[3]], kernel_size=data[6][best_parameters[6]], activation='relu')) model.add( Conv1D(filters=data[3][best_parameters[3]], kernel_size=data[6][best_parameters[6]], activation='relu')) model.add(BatchNormalization()) model.add(MaxPooling1D(pool_size=2)) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(64, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.25)) model.add(Dense(32, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.25)) model.add(Dense(16, activation='relu')) model.add(BatchNormalization()) model.add(Dropout(0.25)) model.add(Dense(self.number_of_classes, activation='softmax')) model.compile(loss=self.loss, optimizer=tensorflow.keras.optimizers.Adadelta(), metrics=self.metrics) model.fit(X_train, np.array(y_train), batch_size=128, epochs=10, verbose=1, validation_data=(self.xx_val, np.array(self.yy_val))) # score = model.evaluate(self.xx_test, self.yy_test, verbose=1)[0] prediction = model.predict(X) if not self.state.one_hot_encoding: self.y_test = [x + 1 for x in self.y_test] self.y_train = [x + 1 for x in self.y_train] if len(prediction.shape) == 2: predicted_gt_1 = np.argmax(prediction, axis=1) predicted_gt_1_list = list(predicted_gt_1) predicted_gt_1_list = [x + 1 for x in predicted_gt_1_list] else: predicted_gt_1_list = prediction for i in self.zero_data: predicted_gt_1_list.insert(i, 0) # predicted_gt_1_list = np.insert(np.array(predicted_gt_1_list), i, 0) # predicted_gt_size = int(math.sqrt(predicted_gt_1_list.shape[0])) self.predicted_gt_1_list = np.array(predicted_gt_1_list).reshape( self.image_shape[0], self.image_shape[1]) sp.save_rgb('predicted_gt.jpg', self.predicted_gt_1_list, colors=sp.spy_colors) self.predicted_gt = Image.open('predicted_gt.jpg') self.predicted_gt = self.predicted_gt.resize((250, 250), Image.ANTIALIAS) self.predicted_gt = ImageTk.PhotoImage(self.predicted_gt) self.output_detail_frame = tk.Frame(self.output_frame) self.output_detail_frame.grid(row=0, column=0, sticky='nsew') self.accuracy = tk.Label(self.output_detail_frame, text='Accuracy: ' + str(accuracy), background='green') self.accuracy_0 = tk.Label(self.output_detail_frame, background='green') self.accuracy.grid(row=0, column=0, sticky='nsew') self.accuracy_0.grid(row=0, column=1, sticky='nsew') for count, i in enumerate(model.layers): name = i.output.name.split('/')[0].split('_') if len(name) > 2: name = name[0] + '_' + name[1] else: name = name[0] self.label1 = tk.Label(self.output_detail_frame, text=str(name)) self.label2 = tk.Label(self.output_detail_frame, text=str(i.output.shape)) self.label1.grid(row=count + 1, column=0, sticky='nsew') self.label2.grid(row=count + 1, column=1, sticky='nsew') self.output_detail_frame.columnconfigure((0, 1), weight=1)
OA_RES_SS4.append(overall_acc_mss) AA_RES_SS4.append(average_acc_mss) print("training finished.") print('Training Time: ', toc6 - tic6) print('Test time:', toc7 - tic7) print("# %d Iteration" % (index_iter + 1)) print('each_acc', each_acc_mss) print("oa", overall_acc_mss) print("aa", average_acc_mss) print("kappa", kappa) gt1[test_indices[:-VAL_SIZE]] = pred_test + 1 gt1 = gt1.reshape(349, 1905) gt_IN1 = gt_IN1.reshape(349, 1905) save_rgb('houston.jpg', gt1, colors=spy_colors) save_rgb('houston-gt.jpg', gt_IN1, colors=spy_colors) # color = np.array( [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [0.5, 0.5, 1], [0.65, 0.35, 1], [0.75, 0.5, 0.75], [0.75, 1, 0.5], [0.5, 1, 0.65], [0.65, 0.65, 0], [0.75, 1, 0.65], [0, 0, 0.5], [0, 1, 0.75]]) # color = color*255 newcmap = ListedColormap(color) view = pyplot.imshow(gt1.astype(int), cmap=newcmap) bar = pyplot.colorbar() bar.set_ticks(np.linspace(0, 15, 16)) pyplot.show()
X, y = loadData() height = y.shape[0] width = y.shape[1] PATCH_SIZE = windowSize numComponents = K X,pca = applyPCA(X, numComponents=numComponents) X = padWithZeros(X, PATCH_SIZE//2) # calculate the predicted image outputs = np.zeros((height,width)) for i in range(height): for j in range(width): target = int(y[i,j]) if target == 0 : continue else : image_patch=Patch(X,i,j) X_test_image = image_patch.reshape(1,image_patch.shape[0],image_patch.shape[1], image_patch.shape[2], 1).astype('float32') prediction = (model.predict(X_test_image)) prediction = np.argmax(prediction, axis=1) outputs[i][j] = prediction+1 ground_truth = spectral.imshow(classes = y,figsize =(7,7)) predict_image = spectral.imshow(classes = outputs.astype(int),figsize =(7,7)) spectral.save_rgb("predictions.jpg", outputs.astype(int), colors=spectral.spy_colors)