def main(): input_lang, output_lang, pairs = prepare_data('ques', 'ans', '../debug.json', reverse=False) encoder = EncoderRNN(input_lang.n_words, hidden_size).to(device) attn_decoder = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1, max_length=1000).to(device) rate = 0.9 pairs_train, pairs_test = pairs[0:int(len(pairs) * rate)], pairs[int(len(pairs) * rate):] encoder.load_state_dict(torch.load('model/encoder-0.model')) encoder.eval() attn_decoder.load_state_dict(torch.load('model/decoder-0.model')) attn_decoder.eval() evaluate_all(encoder, attn_decoder, pairs_test, max_length=1000, input_lang=input_lang, output_lang=output_lang, n=len(pairs_test)) # show_plot(loss_history) print('done test')
def main(): input_lang, output_lang, pairs = prepare_data('ques', 'ans', '../test.json', reverse=False) model = Transformer( src_vocab_size=input_lang.n_words, src_max_len=MAX_LENGTH, tgt_vocab_size=output_lang.n_words, tgt_max_len=MAX_LENGTH, ).to(device) rate = 0.9 pairs_train, pairs_test = pairs[0:int(len(pairs) * rate)], pairs[int(len(pairs) * rate):] model.load_state_dict(torch.load('model/transformer-0.model')) model.eval() evaluate_all(model, pairs_train, max_length=100, input_lang=input_lang, output_lang=output_lang, n=len(pairs_train)) # show_plot(loss_history) print('done test')
def make_data_cqt_spectrogram(): # Note that in audio.py, the spectrogram for CQT uses default parameters. Later we may want to think over this ! # Thus these parameters being passed has no effect. fs = 16000 fft_size = 512 win_size = 512 hop_size = 160 duration = 1 inputType = 'cqt_spec' #1second correspond to (32, 84) spectrogram in current default configurations augment = True data_window = 32 window_shift = 30 # keep 30 frames as shift (making 32 will discard lot of frames) save = True if augment: spectrogramPath = '/homes/bc305/myphd/stage2/deeplearning.experiment1/spectrograms_augmented/1sec_shift/' else: spectrogramPath = '/homes/bc305/myphd/stage2/deeplearning.experiment1/spectrograms/' basePath = '/import/c4dm-datasets/SpeakerRecognitionDatasets/ASVSpoof2017/' outPath = spectrogramPath + inputType + '/' + str(fft_size) + 'FFT/' + str( duration) + 'sec/' # Prepare training data #print('Preparing the training data') #prepare_data(basePath,'train',outPath,inputType,duration,fs,fft_size,win_size,hop_size,data_window,window_shift, # augment,save) # Prepare Validation data #print('Preparing the validation data') #prepare_data(basePath,'dev',outPath,inputType,duration,fs,fft_size,win_size,hop_size,data_window,window_shift, # augment,save) # Prepare test data print('Preparing the test data') prepare_data(basePath, 'test', outPath, inputType, duration, fs, fft_size, win_size, hop_size, data_window, window_shift, augment, save)
def make_data_mag_spectrogram(): fs = 16000 fft_size = 512 #256 # 512 win_size = 512 #256 #512 hop_size = 160 duration = 1 inputType = 'mag_spec' augment = True #True data_window = 100 # for FFT based and for cqt = window_shift = 100 #each frame is 32ms, 10 window shift corresponds to 320ms save = True #minimum_length=1 # in seconds if augment: spectrogramPath = '/homes/bc305/myphd/stage2/deeplearning.experiment1/spectrograms_augmented/1sec_shift/' else: spectrogramPath = '/homes/bc305/myphd/stage2/deeplearning.experiment1/spectrograms/' basePath = '/import/c4dm-datasets/SpeakerRecognitionDatasets/ASVSpoof2017/' outPath = spectrogramPath + inputType + '/' + str(fft_size) + 'FFT/' + str( duration) + 'sec/' # Prepare training data #print('Preparing the training data') #prepare_data(basePath,'train',outPath,inputType,duration,fs,fft_size,win_size,hop_size,data_window,window_shift, # augment,save) # Prepare Validation data #print('Preparing the validation data') #prepare_data(basePath,'dev',outPath,inputType,duration,fs,fft_size,win_size,hop_size,data_window,window_shift, # augment,save) # Prepare test data print('Preparing the test data') prepare_data(basePath, 'test', outPath, inputType, duration, fs, fft_size, win_size, hop_size, data_window, window_shift, augment, save)
def main(argv): config = Config() config.phase = FLAGS.phase config.beam_size = FLAGS.beam_size with tf.Session() as sess: if FLAGS.phase == 'train': # training phase train_data, vocabulary1 = prepare_data(config) model = Model(config, vocabulary1) saver = tf.train.Saver(max_to_keep=1000) sess.run(tf.global_variables_initializer()) if FLAGS.load: model.load(sess, saver, FLAGS.model_file) tf.get_default_graph().finalize() if config.is_sc: config.phase = 'test' eval_data, _ = prepare_data(config) config.phase = 'train' model.train_sc(sess, saver, train_data, vocabulary1, eval_data) else: model.train(sess, saver, train_data, vocabulary1) elif FLAGS.phase == 'eval': # evaluation phase eval_data, vocabulary = prepare_data(config) model = Model(config, vocabulary) saver = tf.train.Saver(max_to_keep=1000) model.load(sess, saver, FLAGS.model_file) tf.get_default_graph().finalize() model.eval(sess, eval_data, vocabulary) else: # testing phase test_data, vocabulary = prepare_data(config) model = Model(config, vocabulary) saver = tf.train.Saver(max_to_keep=1000) model.load(sess, saver, FLAGS.model_file) tf.get_default_graph().finalize() model.eval(sess, test_data, vocabulary)
def main(_): # Retrieve parameters config = get_parameters() #prepare data word_table, data = dataset.prepare_data(config) # Preprocess all images test_data = pre.load_image('data/laska.png', (224, 224)) test_data = np.array([test_data]) # Build model. model = ImageCaptioner(config, word_table) # model.train(train_data) model.test(test_data)
def main(config): # Create save directories utils.create_directories(config) # Prepare and load the data data = dataset.prepare_data(config.dataset_dir, config) # Train the ensemble models # if config.training_type == 'bagging': # ensemble_trainer.bagging_ensemble_training(data, config) # elif config.training_type == 'boosting': # ensemble_trainer.boosted_ensemble_training(data, config) # Evaluate the model test_data = dataset.prepare_test_data(config.test_dataset_dir, config) evaluator.evaluate(data, test_data, config) print(config.model_dir, config.boosting_type, config.voting_type)
def main(): input_lang, output_lang, pairs = prepare_data('ques', 'ans', '../data.json',reverse=False) encoder = Encoder(input_lang.n_words, MAX_LENGTH).to(device) attn_decoder = AttnDecoderRNN(hidden_size, output_lang.n_words, dropout_p=0.1, max_length=MAX_LENGTH).to(device) rate = 0.9 epoch = 10 pairs_train,pairs_test = pairs[0:int(len(pairs)*rate)], pairs[int(len(pairs)*rate):] for i in range(epoch): encoder.train() attn_decoder.train() train(encoder, attn_decoder, len(pairs_train), pairs=pairs_train, input_lang=input_lang,output_lang=output_lang, print_every=10) encoder.eval() attn_decoder.eval() evaluate_all(encoder, attn_decoder, pairs_test, max_length=MAX_LENGTH, input_lang=input_lang, output_lang=output_lang, n=len(pairs_test)) torch.save(encoder.state_dict(), 'model/encoder-' + str(i) + '.model') torch.save(attn_decoder.state_dict(), 'model/decoder-' + str(i) + '.model') #show_plot(loss_history) print('done training')
def main(config): # Create save directories utils.create_directories(config) # Prepare and load the data if 'silences' in config.model_types: data = dataset.prepare_data_new(config.dataset_dir, config) else: data = dataset.prepare_data(config.dataset_dir, config) # print(data) # return # Train the ensemble models if config.training_type == 'bagging': ensemble_trainer.bagging_ensemble_training(data, config) elif config.training_type == 'boosting': ensemble_trainer.boosted_ensemble_training(data, config) # Evaluate the model if 'silences' not in config.model_types: test_data = dataset.prepare_test_data(config.test_dataset_dir, config) evaluator.evaluate(data, test_data, config)
scale_each=True) Imgn = utils.make_grid(imgn_train.data, nrow=8, normalize=True, scale_each=True) Irecon = utils.make_grid(out_train.data, nrow=8, normalize=True, scale_each=True) writer.add_image('clean image', Img, epoch) writer.add_image('noisy image', Imgn, epoch) writer.add_image('reconstructed image', Irecon, epoch) except: print('[{}] Get error when log the images ...'.format(epoch)) # save model if not max(psnr_list) > psnr_val: torch.save(model.state_dict(), os.path.join(opt.outf, 'net_best.pth')) torch.save(model.state_dict(), os.path.join(opt.outf, 'net_final.pth')) if __name__ == "__main__": # print('begin to run ...') if opt.preprocess: prepare_data(data_path='../data', patch_size=40, stride=10, aug_times=1, debug=opt.debug) main()
model_dir = os.path.join('saved_models', model_name) if not os.path.exists(model_dir): os.makedirs(model_dir) torch.save(model.state_dict(), os.path.join(model_dir, 'net_%d.pth' % (epoch))) if __name__ == "__main__": if opt.preprocess: if opt.color == 0: grayscale = True stride = 10 if opt.net_mode == 'F': prepare_data(data_path='training_data', patch_size=50, stride=stride, aug_times=1, grayscale=grayscale) else: prepare_data(data_path='training_data', patch_size=50, stride=stride, aug_times=2, grayscale=grayscale, scales_bool=True) else: stride = 25 grayscale = False prepare_data(data_path='training_data', patch_size=50, stride=stride,
normalize=True, scale_each=True) Imgn = utils.make_grid(imgn_train.data, nrow=8, normalize=True, scale_each=True) Irecon = utils.make_grid(out_train.data, nrow=8, normalize=True, scale_each=True) # writer.add_image('clean image', Img, epoch) # writer.add_image('noisy image', Imgn, epoch) # writer.add_image('reconstructed image', Irecon, epoch) # save model torch.save(model.state_dict(), os.path.join(opt.outf, 'net.pth')) if __name__ == "__main__": if opt.preprocess: if opt.mode == 'S': prepare_data(data_path='../dataset/NWPU', patch_size=40, stride=10, aug_times=1) if opt.mode == 'B': prepare_data(data_path='../dataset/NWPU', patch_size=50, stride=10, aug_times=2) main()
# # validate # psnr_val = 0 # for k in range(len(dataset_val)): # img_val = torch.unsqueeze(dataset_val[k], 0) # noise = torch.FloatTensor(img_val.size()).normal_(mean=0, std=opt.val_noiseL/255.) # imgn_val = img_val + noise # img_val, imgn_val = Variable(img_val.cuda(), volatile=True), Variable(imgn_val.cuda(), volatile=True) # out_val = torch.clamp(imgn_val-model(imgn_val), 0., 1.) # psnr_val += batch_PSNR(out_val, img_val, 1.) # psnr_val /= len(dataset_val) # print("\n[epoch %d] PSNR_val: %.4f" % (epoch+1, psnr_val)) # writer.add_scalar('PSNR on validation data', psnr_val, epoch) # # log the images # out_train = torch.clamp(imgn_train-model(imgn_train), 0., 1.) # Img = utils.make_grid(img_train.data, nrow=8, normalize=True, scale_each=True) # Imgn = utils.make_grid(imgn_train.data, nrow=8, normalize=True, scale_each=True) # Irecon = utils.make_grid(out_train.data, nrow=8, normalize=True, scale_each=True) # writer.add_image('clean image', Img, epoch) # writer.add_image('noisy image', Imgn, epoch) # writer.add_image('reconstructed image', Irecon, epoch) # save model torch.save(model.module.state_dict(), os.path.join(opt.outf, 'netB50color_'+str(epoch)+'.pth')) if __name__ == "__main__": if opt.preprocess: if opt.mode == 'S': prepare_data(data_path='data', patch_size=40, stride=10, aug_times=1) if opt.mode == 'B': prepare_data(data_path='data', patch_size=60, stride=20, aug_times=1) main()
import numpy as np import sys from neural import NeuralNet from dataset import get_all_categories_shuffled, numpy_array_from_file, prepare_data labels_dictionary = {'Circle': 0, 'L': 1, 'RightArrow': 2} labels_map = ['Circle', 'L', 'RightArrow'] #Replace with your root folder that holds the dataset of images all_bytes, all_labels = prepare_data("Datasets/DatasetSample0/Images", labels_dictionary, 56, 56) nn = NeuralNet(56, 56) nn.build_layers() nn.fit_data(training_data=all_bytes, training_labels=all_labels, epochs=10, accuracy=0.999) nn.save_model('easter_egg_ahlabikyafraise_') #nn.load_model('easter_egg_ahlabikyafraise_') image_path = sys.argv[1] test_image = numpy_array_from_file(image_path) test_image = test_image / 255 arg_max, prediction_level = nn.predict_element(test_image) print('arg_max : {} which is {} with prediction : {}'.format( arg_max, labels_map[arg_max], prediction_level))
parser.add_argument("--trainset_dir", type=str, default=None, \ help='path of trainset') parser.add_argument("--valset_dir", type=str, default=None, \ help='path of validation set') args = parser.parse_args() if args.gray: if args.trainset_dir is None: args.trainset_dir = 'data/gray/train' if args.valset_dir is None: args.valset_dir = 'data/gray/Set12' else: if args.trainset_dir is None: args.trainset_dir = 'data/rgb/CImageNet_expl' if args.valset_dir is None: args.valset_dir = 'data/rgb/Kodak24' print("\n### Building databases ###") print("> Parameters:") for p, v in zip(args.__dict__.keys(), args.__dict__.values()): print('\t{}: {}'.format(p, v)) print('\n') prepare_data(args.trainset_dir,\ args.valset_dir,\ args.patch_size,\ args.stride,\ args.max_number_patches,\ aug_times=args.aug_times,\ gray_mode=args.gray)
print("Finished!") if __name__ == '__main__': # Load the data print("Loading the data ...") class_names_list, label_values = helpers.get_label_info( os.path.join(cfg.data_dir, 'class_dict.csv')) class_names_string = "" for class_name in class_names_list: if not class_name == class_names_list[-1]: class_names_string = class_names_string + class_name + ", " else: class_names_string = class_names_string + class_name num_classes = len(label_values) train_input_names, train_output_names, val_input_names, val_output_names, test_input_names, test_output_names = dataset.prepare_data( ) config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) # Compute your softmax cross entropy loss print("Preparing the model ...") net_input = tf.placeholder(tf.float32, shape=[None, None, None, 3]) net_output = tf.placeholder(tf.float32, shape=[None, None, None, num_classes]) network, init_fn = buildNetwork(cfg.model, net_input, num_classes) saver = tf.train.Saver(max_to_keep=cfg.num_keep)
result = torch.clamp(pred_res, 0., 1.) psnr_train = batch_PSNR(result, gt_img, 1.) ave_loss = (ave_loss*i + loss.item()) / (i+1) ave_psnr = (ave_psnr*i + psnr_train) / (i+1) ave_ssim = (ave_ssim*i + 1-loss2.item()*2) / (i+1) time2 = time.time() if i % 100 == 0: print("[epoch %d][%d/%d] time: %.3f t_time: %.3f loss: %.4f PSNR_train: %.4f SSIM_train: %.4f" % (epoch+1, i, len(loader_train), (time2 - time1), (time2 - start_time), ave_loss, ave_psnr, ave_ssim)) if step % 1000 == 0: torch.save(model.state_dict(), os.path.join(model_dir, 'latest_net.pth')) step += 1 print('Time for the epoch is %f' % (time.time() - start_time)) ## the end of each epoch # save model save_name = '%d_net.pth' % (epoch+1) torch.save(model.state_dict(), os.path.join(model_dir, save_name)) if __name__ == "__main__": if opt.preprocess: prepare_data(root=opt.root, data_path='data', patch_size=256, stride=200, aug_times=1) else: main()
outest = torch.clamp(est_model(imgn_val), 0., 1.) out_val_b = torch.clamp( imgn_val - model(imgn_val, outest), 0., 1.) out_val_nb = torch.clamp( imgn_val - model(imgn_val, NM_tensor_val), 0., 1.) psnr_val_nb += batch_PSNR(out_val_nb, img_val, 1.) elif opt.mode == "B": out_val_b = torch.clamp(imgn_val-model(imgn_val), 0., 1.) psnr_val_nb = 0 #crit += evl_criterion(out_val_b, img_val).item() psnr_val_b += batch_PSNR(out_val_b, img_val, 1.) print("\n[val at epoch %d] PSNR_val_b: %.4f, PSNR_val_nb: %.4f" % (epoch+1, psnr_val_b, psnr_val_nb)) writer.add_scalar('PSNR on validation data (blind)', psnr_val_b, epoch*len(loader_train) + i) writer.add_scalar('PSNR on validation data (non_blind)', psnr_val_nb, epoch*len(loader_train) + i) ''' step += 1 ## the end of each epoch # save model if not os.path.exists(opt.outf): os.makedirs(opt.outf) torch.save(model.state_dict(), os.path.join(opt.outf, 'net.pth')) if opt.mode == "MC": torch.save(est_model.state_dict(), os.path.join(opt.outf, 'est_net.pth')) if __name__ == "__main__": if opt.preprocess==1: prepare_data(data_path='data', patch_size=50, stride=10, aug_times=2, color=opt.color) main()
from dataset import prepare_data from params import params from train import train from model import MarketPredictionModel train_dataset, validation_dataset = prepare_data() model = MarketPredictionModel() train(model, (train_dataset, validation_dataset))
errG_D += criterionBCE(output, label) / 4. out_train = modelG(imgn_train) loss = criterionMSE(out_train, noise) + 0.01 * errG_D loss.backward() optimizerG.step() # results modelG.eval() denoise_image = torch.clamp(imgn_train - modelG(imgn_train), 0., 1.) psnr_train = batch_PSNR(denoise_image, img_train, 1.) print( "[epoch %d][%d/%d] Loss_G: %.4f PSNR_train: %.4f" % (epoch + 1, i + 1, len(loader_train), loss.item(), psnr_train)) step += 1 # log the images torch.save({ 'epoch': epoch + 1, 'state_dict': modelG.state_dict() }, 'model/modelG.pth') if __name__ == "__main__": if opt.preprocess: prepare_data(opt.train_root, opt.test_root) main()
ax2 = fig.add_subplot(rows, cols, 2) ax2.imshow(np.transpose(Imgn.cpu(), (1,2,0)), cmap="gray") ax2.set_title('noisy image') ax3 = fig.add_subplot(rows, cols, 4) ax3.imshow(np.transpose(Irecon.cpu(), (1, 2, 0)), cmap="gray") ax3.set_title('denoising image') # plt.savefig('./fig_result/epoch_{:d}.png'.format(epoch + 1)) plt.show() # save model # torch.save(model.state_dict(), os.path.join(opt.outf, 'UsingIQRnNoiseblock_Dualnet_25.pth')) # nl(noise level)25 => 30.6000 nl15 => 32.8000 nl50 => 27.3000 if psnr_val >= 30.6000: torch.save(model.state_dict(), os.path.join(opt.outf, 'FBDNet_' + str(round(psnr_val, 4)) + '.pth')) end_time = datetime.now() print('Training Finished!!') print(end_time) if __name__ == "__main__": if opt.preprocess: # prepare_data에서 data를 patch_size대로 나누어주고 다 준비해서 .h5 파일로 만들어주서 main()의 dataset에 집어넣는다. if opt.mode == 'S': prepare_data(data_path='data', patch_size=opt.patchsize, stride=96, aug_times=1) if opt.mode == 'B': prepare_data(data_path='data', patch_size=50, stride=10, aug_times=2) main()
print("[epoch %d][%d/%d] loss: %.4f PSNR_val: %.4f" % (epoch+1, i+1, len(loader_train), loss.item(), psnr_val)) writer.add_scalar('PSNR on validation data', psnr_val, epoch) # log the images out_train = torch.clamp(model(imgn_train), 0., 1.) Img = utils.make_grid(img_train.data, nrow=8, normalize=True, scale_each=True) Imgn = utils.make_grid(imgn_train.data, nrow=8, normalize=True, scale_each=True) Irecon = utils.make_grid(out_train.data, nrow=8, normalize=True, scale_each=True) writer.add_image('clean image', Img, epoch) writer.add_image('noisy image', Imgn, epoch) writer.add_image('reconstructed image', Irecon, epoch) # save model torch.save(model.state_dict(), os.path.join(opt.outf, 'net_' + str(round(psnr_val, 4)) + '.pth')) ''' if __name__ == "__main__": if opt.preprocess: if opt.mode == 'S': # prepare_data(data_path='data', patch_size=40, stride=10, aug_times=1) prepare_data(data_path='data', patch_size=48, stride=48, aug_times=1) if opt.mode == 'B': prepare_data(data_path='data', patch_size=50, stride=10, aug_times=2) main()
help='batch size for training') parser.add_argument('--embedding_type', type=str, required=True, help='loss function to train with') parser.add_argument('--embedding_save_path', type=str, default=None, help='path to store embeddings') args = parser.parse_args() print(args.data_root, args.preloaded, args.n_epochs) if not args.preloaded: if args.data_root is None: raise Exception('data_root passed is None') song_data = dataset.prepare_data(args.data_root) print('{} songs loaded...'.format(len(song_data))) train_split, val_split = dataset.train_test_split(song_data, split_ratio=0.90) else: song_data = None train_split = val_split = None train_dataset = dataset.MusicDataset(train_split, mode='train', preloaded=args.preloaded == 1) val_dataset = dataset.MusicDataset(val_split, mode='val', preloaded=args.preloaded == 1) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")