def test_load_data(self): # Test loading of cityscapes dataset, no resize data = data_loader.load_data(self.cityscapes_path, 'cityscapes', resize=False) sample_img, sample_label = data[0] self.assertIsInstance(data, datasets.Cityscapes) self.assertEqual(sample_img.size(), torch.Size([3, 1024, 2048])) self.assertEqual(sample_label.size(), torch.Size([1024, 2048])) # Test loading of cityscapes dataset, resizing data to 256x256 data = data_loader.load_data(self.cityscapes_path, 'cityscapes', resize=True) sample_img, sample_label = data[0] self.assertIsInstance(data, datasets.Cityscapes) self.assertEqual(sample_img.size(), torch.Size([3, 256, 256])) self.assertEqual(sample_label.size(), torch.Size([256, 256])) # Test loading of tinyimagenet dataset, no resize data = data_loader.load_data(self.imagenet_path, 'imagenet', resize=False) sample_img, sample_label = data[0] self.assertIsInstance(data, datasets.ImageFolder) self.assertEqual(sample_img.size(), torch.Size([3, 64, 64])) self.assertIsInstance(sample_label, int) # Test loading of tinyimagenet dataset, resizing data to 256x256 data = data_loader.load_data(self.imagenet_path, 'imagenet', resize=True) sample_img, sample_label = data[0] self.assertIsInstance(data, datasets.ImageFolder) self.assertEqual(sample_img.size(), torch.Size([3, 256, 256])) self.assertIsInstance(sample_label, int)
def main(): data_loader, class_to_idx, dataset_sizes = load_data( data_folder=args.input_data, batch_size=1, train_flag=False, kwargs={'num_workers': 0}) # models for fuzzing: alexnet, vgg19, mobilenet_v2, vgg16 model_1, model_2, model_3 = load_model() # neuron coverage coverage_table_init = CoverageTable.CoverageTableInit() model_layer_dict_1, model_1_layer_names, \ model_layer_dict_2, model_2_layer_names, \ model_layer_dict_3, model_3_layer_names = \ coverage_table_init.init_deepxplore_coverage_tables(model_1, model_2, model_3) # params of Fuzzer data = [data_loader, class_to_idx] models = [model_1, model_2, model_3] model_layer_dicts = [ model_layer_dict_1, model_layer_dict_2, model_layer_dict_3 ] model_layer_names = [ model_1_layer_names, model_2_layer_names, model_3_layer_names ] fuzzer = Fuzzer.Fuzzer(data, args, models, model_layer_dicts, model_layer_names, DEVICE) fuzzer.loop()
def test_vocabulary_processor(): from tensorflow.contrib import learn import sys sys.path.append("..") from utils.data_loader import load_data, batch_iter processor = learn.preprocessing.VocabularyProcessor.restore( "../temp/vocab") processor.max_document_length = 100 data, label = load_data("test") test_data = [] for d, l in zip(data, label): # for each task in data d = list(processor.transform(d)) # generator -> list d = np.array(d) l = np.array(l) print(np.shape(d)) print(np.shape(l)) test_data.append(d) td = np.array(test_data[2]) print(np.shape(td)) for task, batch in batch_iter(test_data, label, 7, 3, False): x, y = zip(*batch) print(task) break
def main(): # ハイパーパラメータ epoch = 5 lr = 0.001 batch_size = 128 # GPU or CPUの自動判別 device = 'cuda' if torch.cuda.is_available() else 'cpu' # データセットの保存先 root_name = './data' # datasetの呼び出し train_loader, test_loader, classes = load_data(root_name, batch_size) # network呼び出し model = Net().to(device) # modelの動作クラス ope = ModelOperation(model, device) # 学習 ope.train_model(train_loader, epoch, lr) # modelのsave model_path = 'model.pth' torch.save(model.state_dict(), model_path) # 評価 ope.test_model(test_loader)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--rootpath', type=str, default='/mnt/KRED_publish/data/', help='root path of data') ##turning paras parser.add_argument('--learning_rate', action='store_true', default=0.0001, help='learning rate') parser.add_argument('--epoch', action='store_true', default=100, help='epoch num') parser.add_argument('--batch_size', action='store_true', default=16, help='batch size') parser.add_argument('--l2_regular', action='store_true', default=0.00001, help='l2 regular') ##task specific parameter parser.add_argument('--training_type', action='store_true', default="single_task", help='single_task training or multi-task training') parser.add_argument('--task', action='store_true', default="user2item", help='task types: user2item, item2item, vert_classify, pop_predict, local_news') parser.add_argument('--news_entity_num', action='store_true', default=20, help='fix a news entity num to news_entity_num') parser.add_argument('--entity_neighbor_num', action='store_true', default=20, help='nerighbor num for a entity') parser.add_argument('--user_his_num', action='store_true', default=20, help='user history num') parser.add_argument('--negative_num', action='store_true', default=6, help='1 postive and negative_num-1 negative in training set') parser.add_argument('--smooth_lamda', action='store_true', default=10, help='smooth_lamda in softmax in loss function') parser.add_argument('--embedding_dim', action='store_true', default=90, help='embedding dim for enity_embedding dv uv') parser.add_argument('--layer_dim', action='store_true', default=128, help='layer dim') parser.add_argument('--logdir', action='store_true', default="EXP_num", help='the dir for save predict results') args = parser.parse_args() data = load_data(args) train_test(args, data)
def model_test(): print() print('############ offline testing ############') print() model = torch.load(args.target_model) model = model.eval() data_loaders, class_to_idx, dataset_sizes = load_data(args.test_data, args.batch_size, train_flag=False, kwargs=kwargs) print('number of the adversarial samples: {}'.format(dataset_sizes)) correct = 0 total = 0 with torch.no_grad(): for (images, labels) in data_loaders: images, labels = images.to(DEVICE), labels.to(DEVICE) outputs = model(images) _, predicted = torch.max(outputs, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the target model on the test images: %d %%' % (100 * correct / total))
def load_and_stack_data(load_file_names=None): with open(load_file_names) as f: file_name_list = f.readlines() file_name_list = [x.strip() for x in file_name_list] states_list = [] deltas_list = [] actions_list = [] weights_list = [] for file_name in file_name_list: file_dir = os.path.join(os.getcwd(), "testing_pipeline", file_name) states, deltas, actions, weights = load_data(file_dir) states_list.append(states) deltas_list.append(deltas) actions_list.append(actions) weights_list.append(weights) states_full = np.concatenate(states_list) deltas_full = np.concatenate(deltas_list) actions_full = np.concatenate(actions_list) weights_full = np.concatenate(weights_list) weights_full = np.expand_dims(weights_full, axis=-1) return states_full, deltas_full, actions_full, weights_full
def get_avg_activated_channels(self, layers, data_path, data_type, sample_size=100): ''' Computes the average number number of channels activated in each layer by inputs from the specified dataset. ''' layer_activations = [] for layer in layers: activations = LayerActivations(layer) layer_activations.append(activations) dataset = load_data(data_path, data_type) sampler = torch.utils.data.SubsetRandomSampler(np.arange(sample_size)) dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, sampler=sampler) avg_activated_channels = np.zeros(len(layers)) for x, _ in dataloader: _ = self.model(x) channels_activations = [ l.activations[0].detach().numpy() for l in layer_activations ] avg_activated_channels += [ len(np.unique(np.nonzero(c)[0])) for c in channels_activations ] avg_activated_channels = avg_activated_channels / sample_size return avg_activated_channels
def main(train_df_path, test_df_path, embedings_file, model_name, stamp): experiment_path = './experiments/%s' % stamp x_train, targets_train, x_test, train_submission, submission, embedings = load_data(train_df_path, test_df_path, embedings_file) (kfold_data, X_test) = prepare_data_cv(x_train, targets_train, x_test) train_probas = np.zeros(shape=(x_train.shape[0], 6)) test_probas = np.zeros(shape=(x_test.shape[0], 6)) models_roc = [] models_train_roc = [] for idx, data in enumerate(tqdm(kfold_data)): X_train, y_train, X_valid, y_valid, val_indices = data model = get_model(model_name, embedding_matrix=embedings, dropout_dense=0.4, weight_decay=1e-4) callbacks = get_model_callbacks(save_dir=os.path.join(experiment_path, 'fold_%02d' % idx)) model.fit(X_train, y_train, batch_size=BATCH_SIZE, epochs=EPOCHES, validation_data=(X_valid, y_valid), shuffle=True, callbacks=callbacks, verbose=1) model.load_weights(filepath=os.path.join(experiment_path, ('fold_%02d/model/model_weights.hdf5' % idx))) proba = model.predict(X_train, batch_size=BATCH_SIZE * 2) proba_val = model.predict(X_valid, batch_size=BATCH_SIZE * 2) proba_test = model.predict(x_test, batch_size=BATCH_SIZE * 2) models_roc.append(roc_auc_score(y_valid, proba_val)) models_train_roc.append(roc_auc_score(y_train, proba)) train_probas[val_indices] += proba_val test_probas += proba_test / 5. print('Train ROC AUC:\nMean: %f\nStd: %f\nMin: %f\nMax: %f\n\n' % (np.mean(models_train_roc), np.std(models_train_roc), np.min(models_train_roc), np.max(models_train_roc))) print('Val ROC AUC:\nMean: %f\nStd: %f\nMin: %f\nMax: %f\n\n' % (np.mean(models_roc), np.std(models_roc), np.min(models_roc), np.max(models_roc))) for i, cls_name in enumerate(CLASS_NAMES): train_submission[cls_name] = train_probas[:, i] train_submission.to_csv('./csv/train_%s.csv' % stamp, index=False) for i, cls_name in enumerate(CLASS_NAMES): submission[cls_name] = test_probas[:, i] submission.to_csv('./csv/submission_%s.csv' % stamp, index=False)
def __init__(self, sequence_length): # load data first self.processor = learn.preprocessing.VocabularyProcessor.restore( "../temp/vocab") self.processor.max_document_length = sequence_length raw_data, raw_label = load_data("train") self.train_data = [] self.train_label = [] for rd, rl in zip(raw_data, raw_label): # for each task in data tmp_data = [] tmp_label = [] rd = list(self.processor.transform(rd)) # generator -> list for tmp_x, tmp_y in zip(rd, rl): tmp_x = tmp_x.tolist() if np.sum(tmp_x) != 0: tmp_data.append(tmp_x) tmp_label.append(tmp_y) self.train_data.append(tmp_data) self.train_label.append(tmp_label) del raw_data, raw_label print("load training data complete!") self.test_data = [] self.test_label = [] raw_data, raw_label = load_data("test") for rd, rl in zip(raw_data, raw_label): tmp_data = [] tmp_label = [] rd = list(self.processor.transform(rd)) for tmp_x, tmp_y in zip(rd, rl): tmp_x = tmp_x.tolist() if np.sum(tmp_x) != 0: tmp_data.append(tmp_x) tmp_label.append(tmp_label) self.test_data.append(tmp_data) self.test_label.append(tmp_label) del raw_data, raw_label print("load test data complete!") self.embedding_matrix = self._embedding_matrix_initializer( ) if os.path.exists("../data/glove.6B/glove.6B.{}d.txt".format( params["global"]["embedding_size"])) else None print("read from embedding_matrix complete!")
def load_data(src, tar, root_dir): '''Train data and test data initialization''' folder_src = os.path.join(root_dir, src) folder_tar = os.path.join(root_dir, tar) source_loader = data_loader.load_data(folder_src, CFG['batch_size'], True, CFG['kwargs']) target_train_loader = data_loader.load_data(folder_tar, CFG['batch_size'], True, CFG['kwargs']) target_test_loader = data_loader.load_data(folder_tar, CFG['batch_size'], False, CFG['kwargs']) print( 'source len: {0}, target train len: {1}, target test len: {2}'.format( len(source_loader.dataset), len(target_train_loader.dataset), len(target_test_loader.dataset))) return source_loader, target_train_loader, target_test_loader
def main(): device = 'cuda' if torch.cuda.is_available() else 'cpu' root_name = './data' _, test_loader, _ = load_data(root_name, 128) # 読み込み model_path = 'model.pth' model = Net().to(device) model.load_state_dict(torch.load(model_path, map_location=device)) print(model) # 評価 ope = ModelOperation(model, device) ope.test_model(test_loader)
def __init__(self, sequence_length): # load data first self.processor = learn.preprocessing.VocabularyProcessor.restore( "../temp/vocab") self.processor.max_document_length = sequence_length raw_data, raw_label = load_data("test") self.train_data = [] self.train_label = [] for rd, rl in zip(raw_data, raw_label): # for each task in data tmp_data = [] tmp_label = [] rd = list(self.processor.transform(rd)) # generator -> list for tmp_x, tmp_y in zip(rd, rl): tmp_x = tmp_x.tolist() if np.sum(tmp_x) != 0: tmp_data.append(tmp_x) tmp_label.append(tmp_y) self.train_data.append(tmp_data) self.train_label.append(tmp_label) del raw_data, raw_label print("load training data complete!")
def main(): args = get_cli_arguments() if (args.checkpoint is not None) and (not os.path.exists(args.checkpoint)): sys.exit('Specified checkpoint cannot be found') if args.mode == 'train': if args.dataset != 'cityscapes': sys.exit("Model can only be trained on cityscapes dataset") dataset = load_data(args.path, args.dataset, resize=~args.no_resize) if args.subset: sampler = torch.utils.data.SubsetRandomSampler(np.arange(50)) dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, sampler=sampler) else: dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, shuffle=True) model = UNet(num_classes=len(datasets.Cityscapes.classes), pretrained=args.pretrained) if not args.pretrained: set_parameter_required_grad(model, True) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate) if (args.savedir is not None) and (not os.path.exists(args.savedir)): os.makedirs(args.savedir) train(model, dataloader, criterion, optimizer, num_epochs=args.epochs, checkpoint_path=args.checkpoint, save_path=args.savedir) return if args.mode == 'test': dataset = load_data(args.path, args.dataset, resize=~args.no_resize, split='val') if args.subset: sampler = torch.utils.data.SubsetRandomSampler(np.arange(50)) dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, sampler=sampler) else: dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, shuffle=True) model = UNet(num_classes=len(datasets.Cityscapes.classes), pretrained=args.pretrained) validate(model, dataloader, args.checkpoint) if args.mode == 'activations': if args.model is None: sys.exit("Must specify model to use with --model argument") dataset = load_data(args.path, args.dataset, resize=~args.no_resize) if args.subset: sampler = torch.utils.data.SubsetRandomSampler(np.arange(50)) dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, sampler=sampler) else: dataloader = torch.utils.data.DataLoader( dataset, batch_size=args.batch_size, shuffle=True) if args.model == 'unet': model = UNet(num_classes=len(datasets.Cityscapes.classes)) if args.checkpoint: checkpoint = torch.load( args.checkpoint, map_location=lambda storage, loc: storage) model.load_state_dict(checkpoint['model_state_dict']) else: print( "NOTE: Getting activations for untrained network. Specified a pretrained model with the " "--checkpoint argument.") elif args.model == 'vggmod': model = VGGmod() else: model = UNet(num_classes=len(datasets.Cityscapes.classes)) if args.checkpoint: checkpoint = torch.load(args.checkpoint) model.load_state_dict(checkpoint['model_state_dict']) set_parameter_required_grad(model, True) retrieve_activations(model, dataloader, args.dataset) model = VGGmod() set_parameter_required_grad(model, True) retrieve_activations(model, dataloader, args.dataset) if args.mode == 'view_activations': file_1 = os.path.join(args.path, 'VGGmod_activations') file_2 = os.path.join(args.path, 'UNet_activations_matched') if not os.path.exists(file_1) or not os.path.exists(file_2): exit( "Could not load activations from " + args.path + ". If you have not generated activations for both UNet " "and VGG11, run instead with the \"--mode activations\" parameter." ) activs1, activs2 = load_activations(file_1, file_2) visualize_batch(activs1, activs2, batch_num=args.batch_num, start_layer=args.start_layer, stop_layer=args.stop_layer) if args.mode == 'compare_activations': file_1 = os.path.join(args.path, 'VGGmod_activations') file_2 = os.path.join(args.path, 'UNet_activations') match_channels(file_1, file_2, args.type) if args.mode == 'view_max_activating': channel_vis_driver(args.model, args.checkpoint, args.path, args.dataset, args.conv_layer, args.channels, args.img_size, args.upscale_steps, args.upscale_factor, args.learning_rate, args.opt_steps, args.grid, args.path, args.verbose)
args = arg_parser.parse_args() logs = logger.Logger(args) if args.GPU_to_use is not None: logs.write_to_log_file("Using GPU #" + str(args.GPU_to_use)) ( train_loader, valid_loader, test_loader, loc_max, loc_min, vel_max, vel_min, ) = data_loader.load_data(args) rel_rec, rel_send = utils.create_rel_rec_send(args, args.num_atoms) encoder, decoder, optimizer, scheduler, edge_probs = model_loader.load_model( args, loc_max, loc_min, vel_max, vel_min) logs.write_to_log_file(encoder) logs.write_to_log_file(decoder) if args.prior != 1: assert 0 <= args.prior <= 1, "args.prior not in the right range" prior = np.array([args.prior] + [(1 - args.prior) / (args.edge_types - 1) for _ in range(args.edge_types - 1)]) logs.write_to_log_file("Using prior")
' Source Port', ' Destination Port', ' Flow Duration', 'Total Length of Fwd Packets', ' Total Length of Bwd Packets', 'Bwd Packet Length Max', ' Bwd Packet Length Min', 'Flow Bytes/s', ' Flow IAT Mean', ' Flow IAT Std', ' Flow IAT Max', ' Flow IAT Min', 'Fwd IAT Total', ' Fwd IAT Mean', ' Fwd IAT Std', ' Fwd IAT Min', 'Bwd IAT Total', ' Bwd IAT Mean', ' Bwd IAT Std', ' Bwd IAT Min', 'Fwd PSH Flags', ' Bwd PSH Flags', ' Fwd URG Flags', ' Fwd Header Length', ' Bwd Packets/s', ' Packet Length Mean', ' ACK Flag Count', ' Down/Up Ratio', ' Avg Fwd Segment Size', ' Fwd Header Length.1', 'Fwd Avg Bytes/Bulk', ' Fwd Avg Packets/Bulk', ' Bwd Avg Bytes/Bulk', 'Bwd Avg Bulk Rate', 'Subflow Fwd Packets', ' Subflow Fwd Bytes', 'Init_Win_bytes_forward', ' act_data_pkt_fwd', ' Active Std', ' Active Min', ' Idle Max' ] # X, Y = load_data(input_file, features_selected, output_file) # output_file = '../original_data_no_sample/Wednesday-workingHours.pcap_ISCX_feature_selected.csv' # X, Y= load_data_from_files(output_file, sample_ratio=0.05, preprocess=True) # print('X.shape:', X.shape, ' Y.shape:', np.asarray(Y).shape) print('X[0]:', X[0]) X = normalize_data(X, axis=0, low=-1, high=1, eps=1e-5) print('Normalized X[0]:', X[0]) print('X.shape:', X.shape, ' Y.shape:', np.asarray(Y).shape) print('label:', Counter(Y)) show_flg = True save_flg = True in_size = 41 h_size = 64 out_size = 1 dtype = torch.float
model_ft.fc = nn.Linear(num_ftrs, num_classes) input_size = 299 else: print("Invalid model name, exiting...") exit() return model_ft, input_size if __name__ == '__main__': # Initialize the target model for this run model, input_size = initialize_model(args.model_name, args.num_classes, feature_extract=True, use_pretrained=True) model.to(DEVICE) # Print the model we just instantiated print(model) data_loaders, dataset_sizes = load_data(input_size) print(dataset_sizes) model, model_saved_path = model_training(model, data_loaders, dataset_sizes) print('Finished Training') # test offline model_test(model_saved_path, data_loaders)
def main(arg): directory = Path('./saved_predictions/') directory.mkdir(exist_ok=True) directory = Path('./saved_models/') directory.mkdir(exist_ok=True) directory = Path('./training_checkpoints/') directory.mkdir(exist_ok=True) input_yx_size = tuple(args.input_yx_size) batch_size = args.batch_size epochs = args.epochs learning_rate = args.learning_rate num_test_samples = args.num_test_samples save_weights = args.save_weights every = args.every num_samples = args.num_samples save_train_prediction = args.save_train_prediction save_test_prediction = args.save_test_prediction verbose = args.verbose validation_ratio = args.validation_ratio y_axis_len, x_axis_len = input_yx_size decay = args.decay decay = args.decay load_weights = args.load_weights y_axis_len, x_axis_len = input_yx_size num_points = y_axis_len * x_axis_len is_flat_channel_in = args.is_flat_channel_in input_points = Input(shape=(num_points, 4)) x = input_points x = Convolution1D(64, 1, activation='relu', input_shape=(num_points, 4))(x) x = BatchNormalization()(x) x = Convolution1D(128, 1, activation='relu')(x) x = BatchNormalization()(x) x = Convolution1D(512, 1, activation='relu')(x) x = BatchNormalization()(x) x = MaxPooling1D(pool_size=num_points)(x) x = Dense(512, activation='relu')(x) x = BatchNormalization()(x) x = Dense(256, activation='relu')(x) x = BatchNormalization()(x) x = Dense(16, weights=[ np.zeros([256, 16]), np.array([1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1]).astype(np.float32) ])(x) input_T = Reshape((4, 4))(x) # forward net g = Lambda(mat_mul, arguments={'B': input_T})(input_points) g = Convolution1D(64, 1, input_shape=(num_points, 3), activation='relu')(g) g = BatchNormalization()(g) g = Convolution1D(64, 1, input_shape=(num_points, 3), activation='relu')(g) g = BatchNormalization()(g) # feature transformation net f = Convolution1D(64, 1, activation='relu')(g) f = BatchNormalization()(f) f = Convolution1D(128, 1, activation='relu')(f) f = BatchNormalization()(f) f = Convolution1D(128, 1, activation='relu')(f) f = BatchNormalization()(f) f = MaxPooling1D(pool_size=num_points)(f) f = Dense(512, activation='relu')(f) f = BatchNormalization()(f) f = Dense(256, activation='relu')(f) f = BatchNormalization()(f) f = Dense(64 * 64, weights=[ np.zeros([256, 64 * 64]), np.eye(64).flatten().astype(np.float32) ])(f) feature_T = Reshape((64, 64))(f) # forward net g = Lambda(mat_mul, arguments={'B': feature_T})(g) seg_part1 = g g = Convolution1D(64, 1, activation='relu')(g) g = BatchNormalization()(g) g = Convolution1D(32, 1, activation='relu')(g) g = BatchNormalization()(g) g = Convolution1D(32, 1, activation='relu')(g) g = BatchNormalization()(g) # global_feature global_feature = MaxPooling1D(pool_size=num_points)(g) global_feature = Lambda(exp_dim, arguments={'num_points': num_points})(global_feature) # point_net_seg c = concatenate([seg_part1, global_feature]) """ c = Convolution1D(512, 1, activation='relu')(c) c = BatchNormalization()(c) c = Convolution1D(256, 1, activation='relu')(c) c = BatchNormalization()(c) c = Convolution1D(128, 1, activation='relu')(c) c = BatchNormalization()(c) c = Convolution1D(128, 1, activation='relu')(c) c = BatchNormalization()(c) """ c = Convolution1D(256, 1, activation='relu')(c) c = BatchNormalization()(c) c = Convolution1D(128, 4, activation='relu', strides=4)(c) c = BatchNormalization()(c) c = Convolution1D(128, 4, activation='relu', strides=4)(c) c = BatchNormalization()(c) c = Convolution1D(128, 4, activation='relu', strides=4)(c) c = BatchNormalization()(c) c = Convolution1D(64, 4, activation='relu', strides=4)(c) c = BatchNormalization()(c) c = Convolution1D(64, 4, activation='relu', strides=4)(c) c = BatchNormalization()(c) c = Convolution1D(32, 1, activation='relu')(c) c = BatchNormalization()(c) """ c = Convolution1D(128, 4, activation='relu',strides=4)(c) c = Convolution1D(64, 4, activation='relu',strides=4)(c) c = Convolution1D(32, 4, activation='relu',strides=4)(c) c = Convolution1D(16, 1, activation='relu')(c) c = Convolution1D(1, 1, activation='relu')(c) """ #c = tf.keras.backend.squeeze(c,3); c = CuDNNLSTM(64, return_sequences=False)(c) #c =CuDNNLSTM(784, return_sequences=False)) #c =CuDNNLSTM(256, return_sequences=False)) #c = Reshape([16,16,1])(c) c = Reshape([8, 8, 1])(c) c = Conv2DTranspose(8, (3, 3), padding="same", activation="relu", strides=(2, 2))(c) c = Conv2DTranspose(8, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(16, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(64, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(64, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) #c =Dropout(0.4)) c = Conv2DTranspose(128, (3, 3), padding="same", activation="relu", strides=(2, 2))(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(128, (3, 3), padding="valid", activation="relu")(c) #c =Dropout(0.4)) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(128, (3, 3), padding="same", activation="relu", strides=(2, 2))(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(128, (3, 3), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) #c =Dropout(0.4)) #c =tf.keras.layers.BatchNormalization()) c = Conv2DTranspose(64, (3, 3), padding="same", strides=(4, 2))(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 3), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 3), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) #c =Dropout(0.4)) c = Conv2DTranspose(32, (3, 3), padding="same", activation="relu", strides=(1, 1))(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 1), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(32, (3, 1), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(16, (1, 1), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(8, (1, 1), padding="valid", activation="relu")(c) c = tf.keras.layers.BatchNormalization()(c) c = Conv2DTranspose(1, (1, 1), padding="valid")(c) """ c =Conv2DTranspose(4, (1,1),padding="same",activation="relu")) c =Conv2DTranspose(2, (1,1),padding="same",activation="relu")) #c =Dropout(0.4)) c =Conv2DTranspose(1, (1,1),padding="same")) """ prediction = tf.keras.layers.Reshape([512, 256])(c) """ c1 ,c2 = tf.split(c,[256,256],axis=1,name="split") complexNum = tf.dtypes.complex( c1, c2, name=None ) complexNum =tf.signal.ifft2d( complexNum, name="IFFT" ) real = tf.math.real(complexNum) imag = tf.math.imag(complexNum) con = concatenate([real,imag]) prediction =tf.keras.layers.Reshape([ 512, 256])(con) """ # define model model = Model(inputs=input_points, outputs=prediction) opt = tf.keras.optimizers.Adam(lr=learning_rate, decay=decay) loss = tf.keras.losses.MeanSquaredError() mertric = ['mse'] if args.loss is "MAE": loss = tf.keras.losses.MeanAbsoluteError() mertric = ['mae'] model.compile( loss=loss, optimizer=opt, metrics=mertric, ) model.summary() if load_weights: model.load_weights('./training_checkpoints/cp-best_loss.ckpt') #edit data_loader.py if you want to play with data input_ks, ground_truth = load_data(num_samples, is_flat_channel_in=is_flat_channel_in) input_ks = input_ks / np.max(input_ks) checkpoint_path = "./training_checkpoints/cp-{epoch:04d}.ckpt" checkpoint_dir = os.path.dirname(checkpoint_path) # Create checkpoint callback #do you want to save the model's wieghts? if so set this varaible to true cp_callback = [] NAME = "NUFFT_NET" tensorboard = TensorBoard(log_dir="logs/{}".format(NAME)) cp_callback.append(tensorboard) if save_weights: cp_callback.append( tf.keras.callbacks.ModelCheckpoint(checkpoint_dir, save_weights_only=True, verbose=verbose, period=every)) if args.is_train: model.fit(input_ks, ground_truth, batch_size=batch_size, epochs=epochs, validation_split=validation_ratio, callbacks=cp_callback) if args.name_model is not "": model.save('./saved_mdoels/' + args.name_model) dict_name = './saved_predictions/' #return to image size x_axis_len = int(x_axis_len / 4) np.random.seed(int(time())) if save_train_prediction <= num_samples: rand_ix = np.random.randint(0, num_samples - 1, save_train_prediction) #kspace = np.zeros((save_train_prediction, #y_axis_len,input_ks[rand_ix].shape[1])) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/inputs.npy", input_ks[rand_ix]) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_train_prediction) for i in range(save_train_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'prediction%d.npy' % (i + 1), output) input_ks, ground_truth = load_data( num_test_samples, 'test', is_flat_channel_in=is_flat_channel_in) input_ks = input_ks / np.max(input_ks) if args.is_eval: model.evaluate(input_ks, ground_truth, batch_size, verbose, callbacks=cp_callback) if save_test_prediction <= num_test_samples: rand_ix = np.random.randint(0, num_test_samples - 1, save_test_prediction) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/test_inputs.npy", input_ks[rand_ix]) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_test_prediction) for i in range(save_test_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'test_prediction%d.npy' % (i + 1), output)
action='store_true', default=500, help='batch size') parser.add_argument('--l2_regular', action='store_true', default=0.00001, help='l2 regular') parser.add_argument('--news_entity_num', action='store_true', default=20, help='fix a news entity num to news_entity_num') parser.add_argument('--negative_num', action='store_true', default=6, help='negative sampling number') parser.add_argument('--embedding_dim', action='store_true', default=90, help='embedding dim for enity_embedding dv uv') parser.add_argument('--layer_dim', action='store_true', default=128, help='layer dim') args = parser.parse_args() data = load_data(args) train_test(args, data)
def main_advertorch(): data_loaders, class_to_idx, dataset_sizes = load_data(args.input_data, args.batch_size, train_flag=False, kwargs=kwargs) print('length of dataset: {}'.format(dataset_sizes)) if args.model_type == 0: # transfer learning based model from TransferNet import Transfer_Net model_target = Transfer_Net(num_class=10, base_net=args.base_net) model_target.load_state_dict(torch.load(args.input_model)) model_target.to(DEVICE) model_target = model_target.predict elif args.model_type == 1: # normal DNN model_target = torch.load(args.target_model) model_target.to(DEVICE) model_target = model_target.eval() # SinglePixelAttack adversary = attacks.DDNL2Attack( model_target, nb_iter=100, gamma=0.05, init_norm=1.0, quantize=True, levels=256, clip_min=0.0, clip_max=1.0, targeted=False, loss_fn=nn.CrossEntropyLoss(reduction="sum")) # adversary = attacks.LinfPGDAttack(model_target, loss_fn=nn.CrossEntropyLoss(reduction="sum"), # eps=0.05, nb_iter=40, eps_iter=0.01, rand_init=True, clip_min=0.0, clip_max=1.0, targeted=False) running_corrects_adv_untargeted = 0 if os.path.isdir(args.output_path): shutil.rmtree(args.output_path) for batch_idx, (inputs, labels) in enumerate(data_loaders): cln_data, true_label = inputs.to(DEVICE), labels.to(DEVICE) print() print('clean data shape: {}, true label: {}'.format( cln_data.shape, true_label)) adv_untargeted = adversary.perturb(cln_data, true_label) # predict adversarial samples outputs = model_target(adv_untargeted.to(DEVICE)) _, predicted = torch.max(outputs, 1) running_corrects_adv_untargeted += torch.sum( predicted == true_label.data) print('untargeted perturb predict label: ', predicted) # save adversarial images to local for idx, adver_seed in enumerate(adv_untargeted): for key, value in class_to_idx.items(): if true_label[idx].item() == value: adver_seed_dir = os.path.join(args.output_path, key) if not os.path.isdir(adver_seed_dir): os.makedirs(adver_seed_dir) adver_seed_path = os.path.join( adver_seed_dir, str(batch_idx) + '_' + str(idx) + '.jpg') torchvision.utils.save_image(adver_seed, adver_seed_path, normalize=True, scale_each=True) print('running_corrects_adver_untargeted: {}'.format( running_corrects_adv_untargeted))
def create_data(folder_path, file_name, label_val, **kwargs): # data = load_data(path.join(getcwd(), 'Data'), 'temp_causal')[0] data = load_data(folder_path, file_name)[0] labels = create_labels(len(data), label_val) return data, labels
enc_output, enc_hidden = self.encoder(tokenized_result['input'], enc_hidden) dec_hidden = enc_hidden result = [] for i in range(len(tokenized_result['input'])): cur_enc_output = enc_output[i: i + 1] cur_dec_hidden = dec_hidden[i: i + 1] int_ext = tokenized_result['input_extended'][i: i + 1] oov_len = tokenized_result['oov_len'][i: i + 1] oov_list =tokenized_result['oov_list'][i] cur_result = self.beam_predict_single_item(cur_enc_output, cur_dec_hidden, beam_size, alpha, return_best, int_ext, oov_list, oov_len) result.append(cur_result) return result if __name__ == '__main__': embedding_matrix, word_index_dict = load_embedding_matrix() train_x, train_y, test_x = load_data() x = train_x[:600] y = train_y[:600] model = AttentionModel(embedding_matrix=embedding_matrix, word_index_dict=word_index_dict) model.fit(x, y) model.beam_predict(test_x[:2], beam_size=3) model.beam_predict(test_x[:2], beam_size=5) model.beam_predict(test_x[:2], beam_size=5, return_best=False) model.beam_predict(test_x[:2], beam_size=5, alpha=0.5, return_best=False)
def main(_): FLAGS = tf.app.flags.FLAGS # ========================================= parameter part begins ========================================== # Dx = FLAGS.Dx # --------------------- SSM flags --------------------- # # should q use true_X to sample? (useful for debugging) q_uses_true_X = FLAGS.q_uses_true_X # whether use input in q and f use_input = FLAGS.use_input # --------------------- printing and data saving params --------------------- # print_freq = FLAGS.print_freq if FLAGS.use_input: FLAGS.use_residual = False if FLAGS.use_2_q: FLAGS.q_uses_true_X = q_uses_true_X = False if FLAGS.flow_transition: FLAGS.use_input = use_input = False if FLAGS.TFS: FLAGS.use_input = use_input = False tf.set_random_seed(FLAGS.seed) np.random.seed(FLAGS.seed) # ============================================= dataset part ============================================= # # generate data from simulation if FLAGS.generateTrainingData: model = "fhn" hidden_train, hidden_test, obs_train, obs_test, input_train, input_test = \ generate_dataset(FLAGS.n_train, FLAGS.n_test, FLAGS.time, model=model, Dy=FLAGS.Dy, lb=-2.5, ub=2.5) # load data from file else: hidden_train, hidden_test, obs_train, obs_test, input_train, input_test = \ load_data(FLAGS.datadir + FLAGS.datadict, Dx, FLAGS.Di, FLAGS.isPython2, use_input, q_uses_true_X) FLAGS.n_train, FLAGS.n_test, FLAGS.time = obs_train.shape[ 0], obs_test.shape[0], obs_test.shape[1] # clip saving_num to avoid it > n_train or n_test FLAGS.MSE_steps = min(FLAGS.MSE_steps, FLAGS.time - 1) FLAGS.saving_num = saving_num = min(FLAGS.saving_num, FLAGS.n_train, FLAGS.n_test) print("finished preparing dataset") # ============================================== model part ============================================== # SSM_model = SSM(FLAGS) # SMC class to calculate loss SMC_train = SMC(SSM_model, FLAGS, name="log_ZSMC_train") # =========================================== data saving part =========================================== # # create dir to save results Experiment_params = { "np": FLAGS.n_particles, "t": FLAGS.time, "bs": FLAGS.batch_size, "lr": FLAGS.lr, "epoch": FLAGS.epoch, "seed": FLAGS.seed, "rslt_dir_name": FLAGS.rslt_dir_name } RLT_DIR = create_RLT_DIR(Experiment_params) save_experiment_param(RLT_DIR, FLAGS) print("RLT_DIR:", RLT_DIR) # ============================================= training part ============================================ # mytrainer = trainer(SSM_model, SMC_train, FLAGS) mytrainer.init_data_saving(RLT_DIR) history, log = mytrainer.train(obs_train, obs_test, hidden_train, hidden_test, input_train, input_test, print_freq) # ======================================== final data saving part ======================================== # with open(RLT_DIR + "history.json", "w") as f: json.dump(history, f, indent=4, cls=NumpyEncoder) Xs, y_hat = log["Xs"], log["y_hat"] Xs_val = mytrainer.evaluate(Xs, mytrainer.saving_feed_dict) y_hat_val = mytrainer.evaluate(y_hat, mytrainer.saving_feed_dict) print("finish evaluating training results") plot_training_data(RLT_DIR, hidden_train, obs_train, saving_num=saving_num) plot_y_hat(RLT_DIR, y_hat_val, obs_test, saving_num=saving_num) if Dx == 2: plot_fhn_results(RLT_DIR, Xs_val) if Dx == 3: plot_lorenz_results(RLT_DIR, Xs_val) testing_data_dict = { "hidden_test": hidden_test[0:saving_num], "obs_test": obs_test[0:saving_num] } learned_model_dict = {"Xs_val": Xs_val, "y_hat_val": y_hat_val} data_dict = { "testing_data_dict": testing_data_dict, "learned_model_dict": learned_model_dict } with open(RLT_DIR + "data.p", "wb") as f: pickle.dump(data_dict, f) plot_MSEs(RLT_DIR, history["MSE_trains"], history["MSE_tests"], print_freq) plot_R_square(RLT_DIR, history["R_square_trains"], history["R_square_tests"], print_freq) plot_log_ZSMC(RLT_DIR, history["log_ZSMC_trains"], history["log_ZSMC_tests"], print_freq)
sentence_vecs.append(np.subtract(vec, sub)) return sentence_vecs def generate_sentence_vectors(self, text): """ :param text: Input text :return: A list of sentences in this text and sentence vectors of these sentences """ sentence_list = self.split_into_sentences(text) sentences = [] trans_sentences = [] for sentence in sentence_list: trans_sentence = process_sentence(sentence) trans_sentence = trans_sentence.replace('<start>', '').replace('<end>', '').strip() if trans_sentence is not None and len(trans_sentence) > 0: sentences.append(sentence) trans_sentences.append(trans_sentence) return sentences, self.sentences_to_vecs(trans_sentences) if __name__ == '__main__': train_X, train_Y, test_X = load_data(transform_data=False) sent_emd_generator = SentEmbGenerator() sentences, sent_vecs = sent_emd_generator.generate_sentence_vectors( train_X[0]) print(sent_vecs)
def main(args): directory = Path('./saved_predictions/') directory.mkdir(exist_ok=True) directory = Path('./saved_models/') directory.mkdir(exist_ok=True) directory = Path('./training_checkpoints/') directory.mkdir(exist_ok=True) conv_layers = args.conv_layers lstm_layers = args.lstm_layers input_yx_size = tuple(args.input_yx_size) flatten = args.is_flatten_gt is_flat_channel_in = args.is_flat_channel_in #dense layers dense_layers = args.dense_layers #transpose convultional layers of the Decoder trans_conv_layers = args.trans_conv_layers padding = {} for ix in args.padding: padding[ix] = True #sizes of the kernels kernel_sizes = {} if len(args.kernel_sizes_decoder) % 3 != 0: sys.exit("Error input kernel size of decoder, the \ input shoud be of this form: #index of layer #kernel width #kernel height" ) for ix in range(0, len(args.kernel_sizes_decoder), 3): i = args.kernel_sizes_decoder[ix] kernel_sizes[i] = (args.kernel_sizes_decoder[ix + 1], args.kernel_sizes_decoder[ix + 2]) #sizes of conv strides strides_decoder = {} if len(args.strides_decoder) % 3 != 0: sys.exit("Error input stride size of conv Layers, the \ input shoud be of this form: #index of layer #stride width #stride height" ) for ix in range(0, len(args.strides_decoder), 3): i = args.strides_decoder[ix] strides_decoder[i] = (args.strides_decoder[ix + 1], args.strides_decoder[ix + 2]) #Upsampling window size upsampling_layers = {} if len(args.upsampling_layers) % 3 != 0: sys.exit("Error input window size of upsmapling Layers, the \ input shoud be of this form: #index of layer #kernel width #kernel height" ) for ix in range(0, len(args.upsampling_layers), 3): i = args.upsampling_layers[ix] upsampling_layers[i] = (args.upsampling_layers[ix + 1], args.upsampling_layers[ix + 2]) #Encoder Architecture #sizes of the kernels kernel_sizes_encoder = {} if len(args.kernel_sizes_encoder) % 3 != 0: sys.exit("Error input kernel size of encoder, the \ input shoud be of this form: #index of layer #kernel width #kernel height" ) for ix in range(0, len(args.kernel_sizes_encoder), 3): i = args.kernel_sizes_encoder[ix] kernel_sizes_encoder[i] = (args.kernel_sizes_encoder[ix + 1], args.kernel_sizes_encoder[ix + 2]) #sizes of conv strides strides_encoder = {} if len(args.strides_encoder) % 3 != 0: sys.exit("Error input stride size of conv Layers, the \ input shoud be of this form: #index of layer #stride width #stride height" ) for ix in range(0, len(args.strides_encoder), 3): i = args.strides_encoder[ix] strides_encoder[i] = (args.strides_encoder[ix + 1], args.strides_encoder[ix + 2]) #sizes of pooling windows pooling_layers = {} if len(args.pooling_layers) % 3 != 0: sys.exit("Error input window size of pooling layers, the \ input shoud be of this form: #index of layer #window width #window height" ) for ix in range(0, len(args.pooling_layers), 3): i = args.pooling_layers[ix] pooling_layers[i] = (args.pooling_layers[ix + 1], args.pooling_layers[ix + 2]) #tuple for batch normalization, if the first tuple is_batchnorm = (args.is_batchnorm_dense, args.is_batchnorm_conv) dropout = args.dropout reg = args.reg flatten = args.is_flatten_gt #optimization settings is_CuDNNLSTM = args.is_CuDNNLSTM batch_size = args.batch_size epochs = args.epochs learning_rate = args.learning_rate num_test_samples = args.num_test_samples save_weights = args.save_weights load_weights = args.load_weights num_samples = args.num_samples save_train_prediction = args.save_train_prediction save_test_prediction = args.save_test_prediction verbose = args.verbose validation_ratio = args.validation_ratio decay = args.decay #initialize Encoder's arch """ input_shape, conv_intermediate_dims,strides ={}, kernel_sizes={},pooling_layers={}, is_batchnorm = False,dropout = 0.0,reg=0.0 """ encoderArch = [ input_yx_size, conv_layers, strides_encoder, kernel_sizes_encoder, pooling_layers, is_batchnorm[1], dropout, reg ] #initialize Decoder's arch """ dense_intermediate_dims,conv_intermediate_dims,input_shape,strides= {},kernel_sizes={},upsampling_layers ={}, is_flatten = False, is_batchnorm = (False,False),dropout = 0.0,reg=0.0 """ decoderArch = [ dense_layers, trans_conv_layers, lstm_layers[len(lstm_layers) - 1], strides_decoder, kernel_sizes, upsampling_layers, padding, flatten, is_batchnorm, dropout, reg ] #declare and initialize the network model = create_nufft_nn(encoderArch, lstm_layers, decoderArch, input_yx_size, is_CuDNNLSTM) opt = tf.keras.optimizers.Adam(lr=learning_rate, decay=decay) loss = tf.keras.losses.MeanSquaredError() mertric = ['mse'] if args.loss is "MAE": loss = tf.keras.losses.MeanAbsoluteError() mertric = ['mae'] model.compile( loss=loss, optimizer=opt, metrics=mertric, ) y_axis_len, x_axis_len = input_yx_size input_shape = (None, y_axis_len, x_axis_len) model.build(input_shape=input_shape) model.summary() if load_weights: model.load_weights('./training_checkpoints/cp-best_loss.ckpt') #edit data_loader.py if you want to play with data input_ks, ground_truth = load_data(num_samples, is_flatten=flatten, is_flat_channel_in=is_flat_channel_in) input_ks_max = np.max(input_ks) input_ks = input_ks / input_ks_max checkpoint_path = "training_checkpoints/cp-best_loss.ckpt" cp_callback = [] NAME = "NUFFT_NET" tensorboard = TensorBoard(log_dir="logs/{}".format(NAME)) cp_callback.append(tensorboard) if save_weights: cp_callback.append( tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_best_only=True, save_weights_only=True, verbose=verbose)) if args.is_train: model.fit(input_ks, ground_truth, batch_size=batch_size, epochs=epochs, validation_split=validation_ratio, callbacks=cp_callback) if args.name_model != "": print("Saving The Model.. ") model.save('./saved_models/' + args.name_model) dict_name = './saved_predictions/' #return to image size x_axis_len = int(x_axis_len / 4) np.random.seed(int(time())) if save_train_prediction <= num_samples: rand_ix = np.random.randint(0, num_samples - 1, save_train_prediction) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/inputs.npy", input_ks[rand_ix] * input_ks_max) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_train_prediction) for i in range(save_train_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] if flatten: output_gt = np.reshape(output_gt, (y_axis_len * 2, x_axis_len)) output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'prediction%d.npy' % (i + 1), output) input_ks, ground_truth = load_data( num_test_samples, 'test', is_flatten=flatten, is_flat_channel_in=is_flat_channel_in) input_ks_max = np.max(input_ks) input_ks = input_ks / input_ks_max if args.is_eval: model.evaluate(input_ks, ground_truth, batch_size, verbose, callbacks=cp_callback) if save_test_prediction <= num_test_samples: rand_ix = np.random.randint(0, num_test_samples - 1, save_test_prediction) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/test_inputs.npy", input_ks[rand_ix] * input_ks_max) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_test_prediction) for i in range(save_test_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] if flatten: output_gt = np.reshape(output_gt, (y_axis_len * 2, x_axis_len)) output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'test_prediction%d.npy' % (i + 1), output)
def main(args): directory = Path('./saved_predictions/') directory.mkdir(exist_ok=True) directory = Path('./saved_models/') directory.mkdir(exist_ok=True) directory = Path('./training_checkpoints/') directory.mkdir(exist_ok=True) #passed arguments input_yx_size = tuple(args.input_yx_size) batch_size = args.batch_size epochs = args.epochs learning_rate = args.learning_rate num_test_samples = args.num_test_samples save_weights = args.save_weights load_weights = args.load_weights every = args.every num_samples = args.num_samples save_train_prediction = args.save_train_prediction save_test_prediction = args.save_test_prediction verbose = args.verbose validation_ratio = args.validation_ratio y_axis_len, x_axis_len = input_yx_size val = input("Enter number of samples to load to GPUs: ") gpu_load = int(val) strategy = tf.distribute.MirroredStrategy() BATCH_SIZE_PER_REPLICA = batch_size BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync with strategy.scope(): model = models.Sequential() model.add( Bidirectional(CuDNNLSTM(256, return_sequences=True), input_shape=input_yx_size)) model.add( CuDNNLSTM(256, return_sequences=True, input_shape=input_yx_size)) model.add(tf.keras.layers.Reshape([256, 256, 1])) model.add( Conv2DTranspose(64, (3, 3), padding="same", activation="relu", strides=(2, 1))) model.add( Conv2DTranspose(64, (3, 3), padding="same", activation="relu", strides=(1, 1))) model.add( Conv2DTranspose(256, (1, 1), activation="relu", strides=(1, 1))) model.add( Conv2DTranspose(256, (1, 1), activation="relu", strides=(1, 1))) model.add( Conv2DTranspose(64, (1, 1), activation="relu", strides=(1, 1))) model.add( Conv2DTranspose(32, (1, 1), activation="relu", strides=(1, 1))) model.add(Conv2DTranspose(1, (1, 1), strides=(1, 1))) model.add(tf.keras.layers.Reshape([512, 256])) opt = tf.keras.optimizers.Adam(lr=learning_rate, decay=1e-6) loss = tf.keras.losses.MeanSquaredError() mertric = ['mse'] if args.loss is "MAE": loss = tf.keras.losses.MeanAbsoluteError() mertric = ['mae'] model.compile( loss=loss, optimizer=opt, metrics=mertric, ) model.summary() if load_weights: model.load_weights('./training_checkpoints/cp-best_loss.ckpt') #edit data_loader.py if you want to play with data input_ks, ground_truth = load_data(num_samples) input_ks = input_ks / np.max(input_ks) checkpoint_path = "training_checkpoints/cp-best_loss.ckpt" cp_callback = [] NAME = "NUFFT_NET" tensorboard = TensorBoard(log_dir="logs/{}".format(NAME)) cp_callback.append(tensorboard) if save_weights: cp_callback.append( tf.keras.callbacks.ModelCheckpoint(checkpoint_path, save_best_only=True, save_weights_only=True, verbose=verbose)) epochs_losses = [] if args.is_train: for e in range(epochs): losses = [] for bth, i in enumerate(range(0, num_samples, gpu_load)): #loss_batch = model.train_on_batch(input_ks[i:i+gpu_load],ground_truth[i:i+gpu_load]) #losses.append(loss_batch) model.fit(input_ks[i:i + gpu_load], ground_truth[i:i + gpu_load], BATCH_SIZE, verbose=verbose, callbacks=cp_callback) #print("the %d'th batch in %d'th epoch and is loss: %f"%(bth,e,loss_batch)) #if i%every is 0: #model.save_weights("./training_checkpoints/cp-{}.ckpt".format(e)) #avg_loss = sum(losses) / len(losses) #epochs_losses.append(avg_loss) #print("End of %d th Epoch and AVG loss is %f"%(e,avg_loss)) print("End of Epoch {}".format(e)) if args.name_model is not "": model.save('./saved_models/' + args.name_model) #____________________saving predicitons dict_name = './saved_predictions/' #return to image size x_axis_len = int(x_axis_len / 4) np.random.seed(int(time())) if save_train_prediction <= num_samples: rand_ix = np.random.randint(0, num_samples - 1, save_train_prediction) #kspace = np.zeros((save_train_prediction, #y_axis_len,input_ks[rand_ix].shape[1])) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/inputs.npy", input_ks[rand_ix]) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_train_prediction) for i in range(save_train_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'prediction%d.npy' % (i + 1), output) input_ks, ground_truth = load_data( num_test_samples, 'test', is_flatten=flatten, is_flat_channel_in=is_flat_channel_in) input_ks = input_ks / np.max(input_ks) if args.is_eval: model.evaluate(input_ks, ground_truth, batch_size, verbose, callbacks=cp_callback) if save_test_prediction <= num_test_samples: rand_ix = np.random.randint(0, num_test_samples - 1, save_test_prediction) #kspace = np.zeros((save_test_prediction, #y_axis_len,input_ks[rand_ix].shape[1])) kspace = input_ks[rand_ix] if args.save_input: np.save("./saved_predictions/test_inputs.npy", input_ks[rand_ix]) ground_truth = ground_truth[rand_ix] preds = model.predict(kspace, batch_size=save_test_prediction) for i in range(save_test_prediction): output = np.reshape(preds[i], (y_axis_len * 2, x_axis_len)) output = output * 255 output[np.newaxis, ...] output_gt = ground_truth[i] output_gt[np.newaxis, ...] output = np.concatenate([output, output_gt], axis=0) np.save(dict_name + 'test_prediction%d.npy' % (i + 1), output)
def train_scratch(model_name): optimizer = getattr(keras.optimizers, opt.train.optimizer)() criterion = keras.losses.CategoricalCrossentropy() metric = keras.metrics.CategoricalAccuracy() # val_metric = keras.metrics.CategoricalAccuracy() lr_scheduler = keras.callbacks.ReduceLROnPlateau( monitor=opt.train.monitor, factor=opt.train.lr_factor, patience=opt.train.lr_patience, min_lr=opt.train.lr_min_lr, verbose=1) checkpoint = keras.callbacks.ModelCheckpoint( filepath='results/models/best_model.h5', save_best_only=False, monitor='val_loss', verbose=1) tensorboard = keras.callbacks.TensorBoard( log_dir='results/tensorboard_logs', update_freq='epoch') csv_logger = keras.callbacks.CSVLogger('results/logs/training.log') early_stop = keras.callbacks.EarlyStopping( monitor=opt.train.monitor, min_delta=opt.train.stop_min_delta, patience=opt.train.stop_patience, verbose=1, restore_best_weights=True) #callbacks = [lr_scheduler, tensorboard, csv_logger, early_stop] callbacks = [lr_scheduler, early_stop] for dataset_name in opt.dataset.test_dataset_names: # get data logger.info('============loading data============') train_data, test_data, input_shape, num_classes = load_data( opt, dataset_name) #lb = LabelBinarizer() #y_train_onehot = lb.fit_transform(y_train) logger.info(('===========Done===============')) if model_name != opt.model.name: opt.model.name = model_name # get model model = None if opt.model.name == 'TSCNet': model = TSCNet(num_classes, opt.model.num_layers) elif opt.model.name == 'ResNet': x, y = build_resnet(input_shape, 64, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == 'FCN': x, y = build_fcn(input_shape, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == 'ResNet10': x, y = build_resnet10(input_shape, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == 'ResNet18': x, y = build_resnet18(input_shape, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == 'ResNet34': x, y = build_resnet34(input_shape, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == 'ResNet50': x, y = build_resnet50(input_shape, num_classes) model = keras.models.Model(inputs=x, outputs=y) elif opt.model.name == "FCNLSTM": x, y = build_fcnlstm(input_shape, num_classes, num_cells=8) model = keras.models.Model(inputs=x, outputs=y) # summary model print('model builed!') if model: model.summary() solver = Solver(opt, model, dataset_name, num_classes) solver.fit(train_data=train_data, test_data=test_data, optimizer=optimizer, criterion=criterion, callbacks=callbacks, metric=metric) solver.evaluate(test_data)
def link(model_name, dev_pred_mentions, test_pred_mentions, predict_log, batch_size=32, n_epoch=50, learning_rate=0.001, optimizer_type='adam', embed_type=None, embed_trainable=True, use_relative_pos=False, n_neg=1, omit_one_cand=True, callbacks_to_add=None, swa_type=None, predict_on_final_test=True, **kwargs): config = ModelConfig() config.model_name = model_name config.batch_size = batch_size config.n_epoch = n_epoch config.learning_rate = learning_rate config.optimizer = get_optimizer(optimizer_type, learning_rate) config.embed_type = embed_type if embed_type: config.embeddings = np.load( format_filename(PROCESSED_DATA_DIR, EMBEDDING_MATRIX_TEMPLATE, type=embed_type)) config.embed_trainable = embed_trainable else: config.embeddings = None config.embed_trainable = True config.callbacks_to_add = callbacks_to_add or [ 'modelcheckpoint', 'earlystopping' ] config.vocab = pickle_load( format_filename(PROCESSED_DATA_DIR, VOCABULARY_TEMPLATE, level='char')) config.vocab_size = len(config.vocab) + 2 config.mention_to_entity = pickle_load( format_filename(PROCESSED_DATA_DIR, MENTION_TO_ENTITY_FILENAME)) config.entity_desc = pickle_load( format_filename(PROCESSED_DATA_DIR, ENTITY_DESC_FILENAME)) config.exp_name = '{}_{}_{}_{}_{}_{}'.format( model_name, embed_type if embed_type else 'random', 'tune' if embed_trainable else 'fix', batch_size, optimizer_type, learning_rate) config.use_relative_pos = use_relative_pos if config.use_relative_pos: config.exp_name += '_rel' config.n_neg = n_neg if config.n_neg > 1: config.exp_name += '_neg_{}'.format(config.n_neg) config.omit_one_cand = omit_one_cand if not config.omit_one_cand: config.exp_name += '_not_omit' if kwargs: config.exp_name += '_' + '_'.join( [str(k) + '_' + str(v) for k, v in kwargs.items()]) callback_str = '_' + '_'.join(config.callbacks_to_add) callback_str = callback_str.replace('_modelcheckpoint', '').replace('_earlystopping', '') config.exp_name += callback_str # logger to log output of training process predict_log.update({ 'el_exp_name': config.exp_name, 'el_batch_size': batch_size, 'el_optimizer': optimizer_type, 'el_epoch': n_epoch, 'el_learning_rate': learning_rate, 'el_other_params': kwargs }) print('Logging Info - Experiment: %s' % config.exp_name) model = LinkModel(config, **kwargs) model_save_path = os.path.join(config.checkpoint_dir, '{}.hdf5'.format(config.exp_name)) if not os.path.exists(model_save_path): raise FileNotFoundError( 'Recognition model not exist: {}'.format(model_save_path)) if swa_type is None: model.load_best_model() elif 'swa' in callbacks_to_add: model.load_swa_model(swa_type) predict_log['er_exp_name'] += '_{}'.format(swa_type) dev_data_type = 'dev' dev_data = load_data(dev_data_type) dev_text_data, dev_gold_mention_entities = [], [] for data in dev_data: dev_text_data.append(data['text']) dev_gold_mention_entities.append(data['mention_data']) if predict_on_final_test: test_data_type = 'test_final' else: test_data_type = 'test' test_data = load_data(test_data_type) test_text_data = [data['text'] for data in test_data] if dev_pred_mentions is not None: print( 'Logging Info - Evaluate over valid data based on predicted mention:' ) r, p, f1 = model.evaluate(dev_text_data, dev_pred_mentions, dev_gold_mention_entities) dev_performance = 'dev_performance' if swa_type is None else '%s_dev_performance' % swa_type predict_log[dev_performance] = (r, p, f1) print('Logging Info - Generate submission for test data:') test_pred_mention_entities = model.predict(test_text_data, test_pred_mentions) test_submit_file = predict_log[ 'er_exp_name'] + '_' + config.exp_name + '_%s%ssubmit.json' % ( swa_type + '_' if swa_type else '', 'final_' if predict_on_final_test else '') submit_result(test_submit_file, test_data, test_pred_mention_entities) predict_log['timestamp'] = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()) write_log(format_filename(LOG_DIR, PERFORMANCE_LOG, model_type='2step'), log=predict_log, mode='a') return predict_log
def __init__(self, dataset): train_path = config.dataset_path + dataset + "/train_data_50000.json" dev_path = config.dataset_path + dataset + "/dev_data_5000.json" test_path = config.dataset_path + dataset + "/dev_data_5000.json" rel_dict_path = config.dataset_path + dataset + "/rel2id.json" # data process self.train_data, self.dev_data, self.test_data, self.id2rel, self.rel2id, self.num_rels = load_data( train_path, dev_path, test_path, rel_dict_path)
def main_foolbox(): data_loaders, dataset_sizes, class_to_idx = load_data(args.test_data, args.batch_size, train_flag=False, kwargs=kwargs) print('length of dataset: {}'.format(dataset_sizes)) if args.model_type == 0: # transfer learning based model from TransferNet import Transfer_Net model_target = Transfer_Net(num_class=10, base_net=args.base_net) model_target.load_state_dict(torch.load(args.input_model)) model_target.to(DEVICE) model_target = model_target.predict elif args.model_type == 1: # normal DNN model_target = torch.load(args.target_model) model_target.to(DEVICE) model_target = model_target.eval() fmodel = fb.PyTorchModel(model_target, bounds=(0, 1)) epsilons = [ 0.0, 0.0005, 0.001, 0.0015, 0.002, 0.003, 0.005, 0.01, 0.02, 0.03, 0.1, 0.3, 0.5, 1.0 ] attacks = [ fb.attacks.L2RepeatedAdditiveGaussianNoiseAttack(), # fb.attacks.LinfDeepFoolAttack(steps=50, candidates=10, overshoot=0.02, loss='logits'), ] attack = attacks[0] running_corrects_adv_untargeted = 0 if os.path.isdir(args.output_path): shutil.rmtree(args.output_path) for batch_idx, (inputs, labels) in enumerate(data_loaders): cln_data, true_label = inputs.to(DEVICE), labels.to(DEVICE) print() print('clean data shape: {}, true label: {}'.format( cln_data.shape, true_label)) print() advs, _, success = attack(fmodel, cln_data, true_label, epsilons=epsilons) adv_images = advs[4].clone().detach().requires_grad_(True) # predict adversarial samples outputs = model_target(adv_images.to(DEVICE)) _, predicted = torch.max(outputs, 1) running_corrects_adv_untargeted += torch.sum( predicted == true_label.data) print('perturbed data predict label: ', predicted) # save adversarial images to local for idx, adver_seed in enumerate(adv_images): for key, value in class_to_idx.items(): if true_label[idx].item() == value: adver_seed_dir = os.path.join(args.output_path, key) if not os.path.isdir(adver_seed_dir): os.makedirs(adver_seed_dir) adver_seed_path = os.path.join( adver_seed_dir, str(batch_idx) + '_' + str(idx) + '.jpg') torchvision.utils.save_image(adver_seed, adver_seed_path, normalize=True, scale_each=True) print('running_corrects_adver: {}'.format(running_corrects_adv_untargeted))