def main(args): os.makedirs(os.path.join(args.artifacts_path), exist_ok=True) # Init data train_data, test_data = load_patches(args.patches_dir, args.pixel_neighborhood) train_data.normalize_labels() test_data.normalize_labels() val_data = BalancedSubset(train_data, args.val_set_part) # Callbacks early = EarlyStopping(patience=args.patience) logger = CSVLogger( os.path.join(args.artifacts_path, args.output_file) + ".csv") checkpoint = ModelCheckpoint( os.path.join(args.artifacts_path, args.output_file) + "_model", save_best_only=True) timer = TimeHistory() # Normalize data max_ = train_data.max if train_data.max > val_data.max else val_data.max min_ = train_data.min if train_data.min < val_data.min else val_data.min train_data.normalize_min_max(min_=min_, max_=max_) val_data.normalize_min_max(min_=min_, max_=max_) test_data.normalize_min_max(min_=min_, max_=max_) # Augment data transformation = UpScaleTransform() augmenter = OfflineAugmenter(transformation, sampling_mode="max_twice") augmented_data, augmented_labels = augmenter.augment(train_data, transformations=1) train_data.vstack(augmented_data) train_data.hstack(augmented_labels) if args.pixel_neighborhood == 1: train_data.expand_dims(axis=-1) test_data.expand_dims(axis=-1) val_data.expand_dims(axis=-1) if args.classes_count == 0: args.classes_count = len(np.unique(test_data.get_labels())) # Build model if args.pixel_neighborhood == 1: model = build_1d_model((test_data.shape[1:]), args.kernels, args.kernel_size, args.classes_count) else: settings = build_settings_for_dataset( (args.pixel_neighborhood, args.pixel_neighborhood)) model = build_3d_model(settings, args.classes_count, test_data.shape[-1]) # Train model history = model.fit(x=train_data.get_data(), y=train_data.get_one_hot_labels(args.classes_count), batch_size=args.batch_size, epochs=args.epochs, verbose=args.verbose, callbacks=[early, logger, checkpoint, timer], validation_data=(val_data.get_data(), val_data.get_one_hot_labels( args.classes_count))) # Load best model model = load_model( os.path.join(args.artifacts_path, args.output_file) + "_model") # Calculate test set score test_score = model.evaluate(x=test_data.get_data(), y=test_data.get_one_hot_labels( args.classes_count)) # Calculate accuracy for each class predictions = model.predict(x=test_data.get_data()) predictions = np.argmax(predictions, axis=1) class_accuracy = calculate_class_accuracy(predictions, test_data.get_labels(), args.classes_count) # Collect metrics train_score = max(history.history['acc']) val_score = max(history.history['val_acc']) times = timer.times time = times[-1] avg_epoch_time = np.average(np.array(timer.average)) epochs = len(history.epoch) kappa = cohen_kappa_score(predictions, test_data.get_labels()) # Save metrics metrics_path = os.path.join(args.artifacts_path, "metrics.csv") kappa_path = os.path.join(args.artifacts_path, "kappa.csv") save_to_csv( metrics_path, [train_score, val_score, test_score[1], time, epochs, avg_epoch_time]) class_accuracy_path = os.path.join(args.artifacts_path, "class_accuracy.csv") save_to_csv(class_accuracy_path, class_accuracy) save_to_csv(kappa_path, [kappa]) np.savetxt(os.path.join(args.artifacts_path, args.output_file) + "_times.csv", times, fmt="%1.4f")
def main(args): os.makedirs(os.path.join(args.artifacts_path), exist_ok=True) # Init data test_data = HyperspectralDataset(args.dataset_path, args.gt_path, neighbourhood_size=args.pixel_neighbourhood) test_data.normalize_labels() if args.balanced == 1: train_data = BalancedSubset(test_data, args.train_samples) val_data = BalancedSubset(train_data, args.val_set_part) elif args.balanced == 0: train_data = ImbalancedSubset(test_data, args.train_samples) val_data = ImbalancedSubset(train_data, args.val_set_part) elif args.balanced == 2: # Case for balanced indiana train_data = CustomSizeSubset(test_data, [30, 250, 250, 150, 250, 250, 20, 250, 15, 250, 250, 250, 150, 250, 50, 50]) val_data = BalancedSubset(train_data, args.val_set_part) # Normalize data max_ = train_data.max if train_data.max > val_data.max else val_data.max min_ = train_data.min if train_data.min < val_data.min else val_data.min train_data.normalize_min_max(min_=min_, max_=max_) val_data.normalize_min_max(min_=min_, max_=max_) test_data.normalize_min_max(min_=min_, max_=max_) custom_data_loader = OrderedDataLoader(train_data, args.batch_size) data_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True, drop_last=True) cuda = True if torch.cuda.is_available() else False input_shape = bands_count = train_data.shape[-1] if args.classes_count == 0: args.classes_count = len(np.unique(train_data.get_labels())) classifier_criterion = nn.CrossEntropyLoss() # Initialize generator, discriminator and classifier generator = Generator(input_shape, args.classes_count) discriminator = Discriminator(input_shape) classifier = Classifier(classifier_criterion, input_shape, args.classes_count, use_cuda=cuda, patience=args.classifier_patience) # Optimizers optimizer_G = torch.optim.Adam(generator.parameters(), lr=args.learning_rate, betas=(args.b1, args.b2)) optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=args.learning_rate, betas=(args.b1, args.b2)) optimizer_C = torch.optim.Adam(classifier.parameters(), lr=args.learning_rate, betas=(args.b1, args.b2)) if cuda: generator = generator.cuda() discriminator = discriminator.cuda() classifier = classifier.cuda() classifier_criterion = classifier_criterion.cuda() # Train classifier classifier.train_(data_loader, optimizer_C, args.n_epochs_gan) gan = WGAN(generator, discriminator, classifier, optimizer_G, optimizer_D, use_cuda=cuda, lambda_gp=args.lambda_gp, critic_iters=args.n_critic, patience=args.patience_gan, summary_writer=SummaryWriter(args.artifacts_path), generator_checkout=args.generator_checkout) # Train GAN gan.train(custom_data_loader, args.n_epochs_gan, bands_count, args.batch_size, args.classes_count, os.path.join(args.artifacts_path, args.output_file) + "_generator_model") # Generate samples using trained Generator generator = Generator(input_shape, args.classes_count) generator_path = os.path.join(args.artifacts_path, args.output_file + "_generator_model") generator.load_state_dict(torch.load(generator_path)) if cuda: generator = generator.cuda() train_data.convert_to_numpy() device = 'gpu' if cuda is True else 'cpu' samples_generator = SamplesGenerator(device=device) generated_x, generated_y = samples_generator.generate(train_data, generator) generated_x = np.reshape(generated_x.detach().cpu().numpy(), generated_x.shape + (1, )) train_data.expand_dims(axis=-1) test_data.expand_dims(axis=-1) val_data.expand_dims(axis=-1) train_data.vstack(generated_x) train_data.hstack(generated_y) # Callbacks early = EarlyStopping(patience=args.patience) logger = CSVLogger(os.path.join(args.artifacts_path, args.output_file) + ".csv") checkpoint = ModelCheckpoint(os.path.join(args.artifacts_path, args.output_file) + "_model", save_best_only=True) timer = TimeHistory() # Build model model = build_1d_model((test_data.shape[1:]), args.kernels, args.kernel_size, args.classes_count) # Train model history = model.fit(x=train_data.get_data(), y=train_data.get_one_hot_labels(args.classes_count), batch_size=args.batch_size, epochs=args.epochs, verbose=args.verbose, callbacks=[early, logger, checkpoint, timer], validation_data=(val_data.get_data(), val_data.get_one_hot_labels(args.classes_count))) # Load best model model = load_model(os.path.join(args.artifacts_path, args.output_file) + "_model") # Calculate test set score test_score = model.evaluate(x=test_data.get_data(), y=test_data.get_one_hot_labels( args.classes_count)) # Calculate accuracy for each class predictions = model.predict(x=test_data.get_data()) predictions = np.argmax(predictions, axis=1) class_accuracy = calculate_class_accuracy(predictions, test_data.get_labels(), args.classes_count) # Collect metrics train_score = max(history.history['acc']) val_score = max(history.history['val_acc']) times = timer.times time = times[-1] avg_epoch_time = np.average(np.array(timer.average)) epochs = len(history.epoch) # Save metrics metrics_path = os.path.join(args.artifacts_path, "metrics.csv") save_to_csv(metrics_path, [train_score, val_score, test_score[1], time, epochs, avg_epoch_time]) class_accuracy_path = os.path.join(args.artifacts_path, "class_accuracy.csv") save_to_csv(class_accuracy_path, class_accuracy) np.savetxt(os.path.join(args.artifacts_path, args.output_file) + "_times.csv", times, fmt="%1.4f")
def main(args): os.makedirs(os.path.join(args.artifacts_path), exist_ok=True) # Init data test_data = HyperspectralDataset(args.dataset_path, args.gt_path, neighborhood_size=args.pixel_neighborhood) test_data.normalize_labels() if args.pixel_neighborhood == 1: test_data.expand_dims(axis=-1) if args.balanced: train_data = BalancedSubset(test_data, args.train_samples) val_data = BalancedSubset(train_data, args.val_set_part) elif args.balanced == 0: train_data = ImbalancedSubset(test_data, args.train_samples) val_data = ImbalancedSubset(train_data, args.val_set_part) elif args.balanced == 2: # Case for balanced indiana train_data = CustomSizeSubset(test_data, [ 30, 250, 250, 150, 250, 250, 20, 250, 15, 250, 250, 250, 150, 250, 50, 50 ]) val_data = BalancedSubset(train_data, args.val_set_part) # Callbacks early = EarlyStopping(patience=args.patience) logger = CSVLogger( os.path.join(args.artifacts_path, args.output_file) + ".csv") checkpoint = ModelCheckpoint( os.path.join(args.artifacts_path, args.output_file) + "_model", save_best_only=True) timer = TimeHistory() # Normalize data max_ = train_data.max if train_data.max > val_data.max else val_data.max min_ = train_data.min if train_data.min < val_data.min else val_data.min train_data.normalize_min_max(min_=min_, max_=max_) val_data.normalize_min_max(min_=min_, max_=max_) test_data.normalize_min_max(min_=min_, max_=max_) if args.pixel_neighbourhood == 1: test_data.expand_dims(axis=-1) train_data.expand_dims(axis=-1) val_data.expand_dims(axis=-1) if args.classes_count == 0: args.classes_count = len(np.unique(test_data.get_labels())) # Build model if args.pixel_neighborhood == 1: model = build_1d_model((test_data.shape[1:]), args.kernels, args.kernel_size, args.classes_count) else: settings = build_settings_for_dataset( (args.pixel_neighborhood, args.pixel_neighborhood)) model = build_3d_model(settings, args.classes_count, test_data.shape[-1]) # Train model history = model.fit(x=train_data.get_data(), y=train_data.get_one_hot_labels(args.classes_count), batch_size=args.batch_size, epochs=args.epochs, verbose=args.verbose, callbacks=[early, logger, checkpoint, timer], validation_data=(val_data.get_data(), val_data.get_one_hot_labels( args.classes_count))) # Load best model model = load_model( os.path.join(args.artifacts_path, args.output_file) + "_model") # Remove last dimension train_data.data = train_data.get_data()[:, :, 0] test_data.data = test_data.get_data()[:, :, 0] from time import time transformation = OnlineLightenTransform(scaling=[0.05, 0.1]) start_online = time() transformation.fit(train_data.get_data()) augmenter = OnlineAugmenter() test_score, class_accuracy = augmenter.evaluate(model, test_data, transformation) online_time = time() - start_online # Collect metrics train_score = max(history.history['acc']) val_score = max(history.history['val_acc']) times = timer.times time_ = times[-1] avg_epoch_time = np.average(np.array(timer.average)) epochs = len(history.epoch) # Save metrics metrics_path = os.path.join(args.artifacts_path, "metrics.csv") time_path = os.path.join(args.artifacts_path, "inference_time.csv") save_to_csv( metrics_path, [train_score, val_score, test_score, time_, epochs, avg_epoch_time]) class_accuracy_path = os.path.join(args.artifacts_path, "class_accuracy.csv") save_to_csv(class_accuracy_path, class_accuracy) save_to_csv(time_path, [online_time]) np.savetxt(os.path.join(args.artifacts_path, args.output_file) + "_times.csv", times, fmt="%1.4f")
def main(args): os.makedirs(os.path.join(args.artifacts_path), exist_ok=True) # Init data test_data = HyperspectralDataset(args.dataset_path, args.gt_path, neighbourhood_size=args.pixel_neighbourhood) mapper = BandMapper() test_data.data = mapper.map(test_data.get_data(), args.bands) test_data.normalize_labels() if args.balanced == 1: train_data = BalancedSubset(test_data, args.train_samples) val_data = BalancedSubset(train_data, args.val_set_part) elif args.balanced == 0: train_data = ImbalancedSubset(test_data, args.train_samples) val_data = ImbalancedSubset(train_data, args.val_set_part) elif args.balanced == 2: # Case for balanced indiana train_data = CustomSizeSubset(test_data, [30, 250, 250, 150, 250, 250, 20, 250, 15, 250, 250, 250, 150, 250, 50, 50]) val_data = BalancedSubset(train_data, args.val_set_part) # Callbacks early = EarlyStopping(patience=args.patience) logger = CSVLogger(os.path.join(args.artifacts_path, args.output_file) + ".csv") checkpoint = ModelCheckpoint(os.path.join(args.artifacts_path, args.output_file) + "_model", save_best_only=True) timer = TimeHistory() # Normalize data max_ = train_data.max if train_data.max > val_data.max else val_data.max min_ = train_data.min if train_data.min < val_data.min else val_data.min train_data.normalize_min_max(min_=min_, max_=max_) val_data.normalize_min_max(min_=min_, max_=max_) test_data.normalize_min_max(min_=min_, max_=max_) if args.pixel_neighbourhood == 1: test_data.expand_dims(axis=-1) train_data.expand_dims(axis=-1) val_data.expand_dims(axis=-1) if args.classes_count == 0: args.classes_count = len(np.unique(test_data.get_labels())) # Load model model = load_model(os.path.join(args.models_dir, args.output_file + "_model")) model.pop() model.pop() model.pop() first = Dense(units=20, activation='relu')(model.output) second = Dense(units=20, activation='relu')(first) new_layer = Dense(units=args.classes_count, activation='softmax')(second) model = Model(inputs=model.input, outputs=new_layer) # for layer in model.layers[0:7]: # layer.trainable = False if args.blocks >= 1: model.layers[1].trainable = False if args.blocks >= 2: model.layers[3].trainable = False if args.blocks >= 3: model.layers[5].trainable = False optimizer = Adam(lr=0.0001) model.compile(optimizer=optimizer, metrics=['accuracy'], loss='categorical_crossentropy') print(model.summary()) history = model.fit(x=train_data.get_data(), y=train_data.get_one_hot_labels(args.classes_count), batch_size=args.batch_size, epochs=args.epochs, verbose=args.verbose, callbacks=[early, logger, checkpoint, timer], validation_data=(val_data.get_data(), val_data.get_one_hot_labels(args.classes_count))) # Load best model model = load_model(os.path.join(args.artifacts_path, args.output_file + "_model")) # Calculate test set score test_score = model.evaluate(x=test_data.get_data(), y=test_data.get_one_hot_labels(args.classes_count)) # Calculate accuracy for each class predictions = model.predict(x=test_data.get_data()) predictions = np.argmax(predictions, axis=1) class_accuracy = calculate_class_accuracy(predictions, test_data.get_labels(), args.classes_count) # Collect metrics train_score = max(history.history['acc']) val_score = max(history.history['val_acc']) times = timer.times time = times[-1] avg_epoch_time = np.average(np.array(timer.average)) epochs = len(history.epoch) # Save metrics metrics_path = os.path.join(args.artifacts_path, "metrics.csv") save_to_csv(metrics_path, [train_score, val_score, test_score[1], time, epochs, avg_epoch_time]) class_accuracy_path = os.path.join(args.artifacts_path, "class_accuracy.csv") save_to_csv(class_accuracy_path, class_accuracy) np.savetxt(os.path.join(args.artifacts_path, args.output_file) + "_times.csv", times, fmt="%1.4f")