def generate_prob(epoch=-1): xlnet_config = XLNetConfig.from_json_file(config.xlnet_config_root) model = XlnetCloze(xlnet_config) test_dataloader = getdataLoader(mode="test") load_model(epoch, model) model.to(config.device) model.eval() all_results = {} if config.n_gpu > 1: model = nn.DataParallel(model) for batch in tqdm(test_dataloader): input_ids, attention_mask, position, option_ids, tags = batch input_ids, attention_mask, position, option_ids, tags = to_device( input_ids, attention_mask, position, option_ids, tags ) with torch.no_grad(): batch_logits = model.forward(input_ids, attention_mask, position, option_ids, tags) for i, tag in enumerate(tags): logits = batch_logits[i].detach().cpu().numpy() prob = F.softmax(t.Tensor(logits)) all_results["#idiom%06d#" % tag] = prob with open(config.prob_file, "w") as f: for each in all_results: f.write(each) for i in range(10): f.write(',' + str(all_results[each][i].item())) f.write("\n") with open(config.raw_result_file, "w") as f: for each in all_results: f.write(each) f.write("," + str(all_results[each].max(dim=0)[1].item())) f.write("\n") print("generate test result finished")
class MyModel(models.Model): vectorizer1 = load_model('part1_vect.pk') model1 = load_model('part1_model.pk') part1_model = make_pipeline(vectorizer1, model1) vectorizer2 = load_model('part2_vect.pk') model2 = load_model('part2_model.pk') part2_model = make_pipeline(vectorizer2, model2)
def save_plot(data_dir, model_file, output_file): # frame_interval_sec = frame_dirs = get_frame_pair_list(data_dir) images1_ph = tf.placeholder(tf.float32, [2] + movie.IMAGE_SHAPE) images2_ph = tf.placeholder(tf.float32, [2] + movie.IMAGE_SHAPE) net_op = movie.build_net(images1_ph, images2_ph, is_training=False) correct_prediction = tf.equal(tf.argmax(net_op, 1), tf.constant([1, 0], dtype=tf.int64)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) sess = tf.get_default_session() saver = tf.train.Saver(var_list=tf.get_collection(slim.variables.VARIABLES_TO_RESTORE)) sess.run(tf.initialize_all_variables()) tf.train.start_queue_runners() train.load_model(saver, sess, model_file) f = open(output_file, 'w') for i, dirs in enumerate(frame_dirs): my_print('\r%i/%i' % (i, len(frame_dirs))) image1, image2 = read_image_pair(dirs) image1 = image1.reshape([1] + list(image1.shape)) image2 = image2.reshape([1] + list(image2.shape)) im12 = np.concatenate((image1, image2)) im21 = np.concatenate((image2, image1)) feed = {images1_ph: im12, images2_ph: im21} result = sess.run(accuracy, feed) f.write(str(i) + ' ' + str(result) + '\n') my_print('\r\n') f.close()
def main(): opt = Opt() parser = argparse.ArgumentParser() parser.add_argument('envname', type=str) parser.add_argument('--render', action='store_true') parser.add_argument("--max_timesteps", type=int) parser.add_argument('--num_rollouts', type=int, default=10, help='Number of agent roll outs') args = parser.parse_args() print('loading and building agent policy') env = opt.env if opt.seed: env.seed(opt.seed) torch.manual_seed(opt.seed) model = Agent(env.observation_space.shape[0], env.action_space.shape[0]).double() load_model(opt, model, "./models/") print('loaded and built') env = gym.make(args.envname) max_steps = args.max_timesteps or env.spec.timestep_limit returns = [] observations = [] actions = [] for i in range(args.num_rollouts): print('iter', i) obs = env.reset() done = False totalr = 0. steps = 0 while not done: obs = Variable(torch.from_numpy(obs)) action = model.forward(obs[None, :]) observations.append(obs) actions.append(action) obs, r, done, _ = env.step(action.detach().numpy()) totalr += r steps += 1 if args.render: env.render() if steps % 100 == 0: print("%i/%i" % (steps, max_steps)) if steps >= max_steps: break returns.append(totalr) print('returns', returns) print('mean return', np.mean(returns)) print('std of return', np.std(returns))
def main(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--input', dest='input', help='Training data file, e.g. data/1_train.txt') parser.add_argument('-r', '--oround', dest='oround', default=20, help='Number of output rounds, e.g. 20 [default=20]') parser.add_argument('-m', '--model', dest='model', nargs='+', help='Model python library, e.g. modelxxx, should located in \'rgmodels\'') parser.add_argument('-val', '--val', dest='val_split', type=int, default=15, help='Split input data to train, val.') parser.add_argument('-o', '--ofile', dest='ofile', help='Output data file, e.g. result/1_modelxxx.txt') parser.add_argument('-gt', '--gt', dest='groundtruth', help='Groundtruth, use to test the model if provided') args = parser.parse_args() assert args.input is not None assert args.model is not None in_data = io.read_database(args.input) in_data = numpy.array(in_data) assert args.groundtruth is not None gt_data = io.read_database(args.groundtruth) train_data, val_data = in_data[:, 0:args.val_split], in_data[:, args.val_split:] nr_rows = len(train_data) nr_cols = len(in_data[0]) nr_train_cols = len(train_data[0]) nr_val_cols = len(val_data[0]) nr_types = numpy.array(train_data).max()+1 all_outs = list() for current_model in args.model: current_outs = list() for _ in range(10): out_data = numpy.zeros((nr_rows, nr_val_cols), dtype=numpy.int32) model = load_model(current_model)() model.train(train_data, nr_rows, nr_train_cols, nr_types) model.predict(out_data, nr_rows, nr_val_cols, nr_types, val_data) current_outs.append(out_data) all_outs.append(current_outs) final_map = ensemble(all_outs, gt=val_data) # print(final_map) all_outs = list() for current_model in args.model: out_data = numpy.zeros((nr_rows, args.oround), dtype=numpy.int32) model = load_model(current_model)() model.train(in_data, nr_rows, nr_cols, nr_types) model.predict(out_data, nr_rows, args.oround, nr_types, gt_data) all_outs.append(out_data) final = ensemble(all_outs, final_map=final_map) # final = cheat_ensemble(all_outs, gt_data) score, count = evaluate(final, gt_data) print("model={} score={}/{}".format(args.model, score, count))
def main(): parser = argparse.ArgumentParser() parser.add_argument('-i', '--input', dest='input', help='Training data file, e.g. data/1_train.txt') parser.add_argument('-r', '--oround', dest='oround', default=20, help='Number of output rounds, e.g. 20 [default=20]') parser.add_argument('-m', '--model', dest='model', nargs='+', help='Model python library, e.g. modelxxx, should located in \'rgmodels\'') parser.add_argument('-o', '--ofile', dest='ofile', help='Output data file, e.g. result/1_modelxxx.txt') parser.add_argument('-gt', '--gt', dest='groundtruth', help='Groundtruth, use to test the model if provided') args = parser.parse_args() assert args.input is not None assert args.model is not None assert args.groundtruth is not None in_data = io.read_database(args.input) in_data = numpy.array(in_data) gt_data = io.read_database(args.groundtruth) gt_data = numpy.array(gt_data) all_data = numpy.concatenate([in_data, gt_data], axis=1) nr_rows = len(all_data) nr_types = numpy.array(all_data).max()+1 final_data = numpy.zeros_like(gt_data) for i in range(30, 50): for j1 in range(all_data.shape[0]): best_score, best_model = -1, None for current_model in args.model: sum_score = 0 for _ in range(1): train_data = all_data[:, 0:25] val_data = all_data[:, 25:i] out_data = numpy.zeros_like(val_data) model = load_model(current_model)() model.train(train_data, nr_rows, train_data.shape[1], nr_types) model.predict(out_data, nr_rows, val_data.shape[1], nr_types, val_data) for j2 in range(val_data.shape[1]): sum_score += 1 if val_data[j1, j2] == out_data[j1, j2] else 0 if sum_score > best_score: best_score = sum_score best_model = current_model current_final_out = numpy.zeros_like(all_data[:, i:i+1]) print(i, j1, best_model) model = load_model(best_model)() model.train(all_data[:, 0:i], nr_rows, i, nr_types) model.predict(current_final_out, nr_rows, 1, nr_types, all_data[:, i:i+1]) final_data[j1, i-30] = current_final_out[j1, 0] score, count = evaluate(final_data, gt_data) print("model={} score={}/{}".format(args.model, score, count))
def mel_spectrogram_and_waveform_generation(checkpoint_path, waveglow_checkpoint, text, hparams): # #### Load model from checkpoint model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = model.eval() # #### Prepare text input #text = "amor é fogo que arde sem se ver." sequence = np.array(text_to_sequence(text, ['basic_cleaners']))[None, :] sequence = torch.autograd.Variable( torch.from_numpy(sequence)).cuda().long() # #### Decode text input mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence) waveglow = torch.load(waveglow_checkpoint)['model'] waveglow.cuda() with torch.no_grad(): waveform = waveglow.infer(mel_outputs_postnet, sigma=0.666) return waveform
def setup(): global model, waveglow, denoiser, hparams hparams = create_hparams() hparams.sampling_rate = 22050 checkpoint_path = downloads.download_from_gdrive( gdrive_fileid='1c5ZTuT7J08wLUoVZ2KkUs_VdZuJ86ZqA', output_path='tacotron2/tacotron2_statedict.pt') model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = model.cuda().eval().half() waveglow_path = downloads.download_from_gdrive( gdrive_fileid='1rpK8CzAAirq9sWZhe9nlfvxMF1dRgFbF', output_path='tacotron2/waveglow_256channels_universal_v5.pt') with submodules.localimport('submodules/tacotron2/waveglow') as _importer: waveglow_ = torch.load(waveglow_path) waveglow = waveglow_['model'] waveglow.cuda().eval().half() for k in waveglow.convinv: k.float() denoiser = Denoiser(waveglow)
def generate(model_path, model_name, generate_path, generate_name, start_piece=None, sr=16000, duration=10): if os.path.exists(generate_path) is False: os.makedirs(generate_path) with open('./params/wavenet_params.json', 'r') as f: params = json.load(f) f.close() net = wavenet(**params) net = load_model(net, model_path, model_name) if start_piece is None: start_piece = torch.zeros(1, 256, net.receptive_field) start_piece[:, 128, :] = 1.0 start_piece = Variable(start_piece) note_num = duration * sr note = start_piece state_queue = None generated_piece = [] for i in range(note_num): note, state_queue = predict_next(net, note, state_queue) note = note[0] generated_piece.append(note) temp = torch.zeros(1, net.quantization_channels, 1) temp[:, note, :] = 1.0 note = Variable(temp) print(generated_piece) generated_piece = torch.LongTensor(generated_piece) generated_piece = mu_law_decode(generated_piece, net.quantization_channels) generated_piece = generated_piece.numpy() wav_name = generate_path + generate_name librosa.output.write_wav(wav_name, generated_piece, sr=sr)
def load_model(self): ####TODO#### 1.학습된 모델 불러오기 # 학습된 tacotron 모델 주소를 load하고 # 모델에 hparam과 statedict를 load한다 checkpoint_path = "/home/ubuntu/test/TTS/checkpoint_28000" self.model = train.load_model(self.hparams) self.model.load_state_dict( torch.load(checkpoint_path, map_location=torch.device("cpu"))['state_dict']) # pass ####TODO#### # _ = self.model.cpu().eval().half() _ = self.model.cpu().eval() #waveglow model load # waveglow_path = "/home/multicam/checkpoints/waveglow.pt" waveglow_path = "/home/ubuntu/test/TTS/waveglow.pt" self.waveglow = torch.load(waveglow_path, map_location=torch.device("cpu"))['model'] self.waveglow.cpu().eval() #self.waveglow.cpu().eval().half() for k in self.waveglow.convinv: k.float() self.denoiser = Denoiser(self.waveglow)
def mel_spectrogram_and_waveform_generation(checkpoint_path, text, hparams): # Griffin Lim iterations n_iter = 60 # #### Load model from checkpoint model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = model.eval() # #### Prepare text input #text = "amor é fogo que arde sem se ver." sequence = np.array(text_to_sequence(text, ['basic_cleaners']))[None, :] sequence = torch.autograd.Variable( torch.from_numpy(sequence)).cuda().long() # #### Decode text input mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence) taco_stft = TacotronSTFT(hparams.filter_length, hparams.hop_length, hparams.win_length, sampling_rate=hparams.sampling_rate) mel_decompress = taco_stft.spectral_de_normalize(mel_outputs_postnet) mel_decompress = mel_decompress.transpose(1, 2).data.cpu() spec_from_mel_scaling = 1000 spec_from_mel = torch.mm(mel_decompress[0], taco_stft.mel_basis) spec_from_mel = spec_from_mel.transpose(0, 1).unsqueeze(0) spec_from_mel = spec_from_mel * spec_from_mel_scaling waveform = griffin_lim(torch.autograd.Variable(spec_from_mel[:, :, :-1]), taco_stft.stft_fn, n_iter) return waveform
def classify(ques_text): ''' uses a pre trained model to predict the class (code) of the ques text rtype: a reverse sorted dict with class probability and the question code for the given ques text ''' if not ques_text: return {} classifier = load_model() if not classifier: return {} cl_codes = classifier.classes_ cl_probs = classifier.predict_proba([ques_text]) # the classifier returns unpredictable string # which needs to be cleaned before converting # into list cl_probs = str(cl_probs).replace('[', '').replace(']', '').replace(' ', ' ').split(' ') result = list(zip(cl_codes, cl_probs)) logfile.info("classify() : ques_text = " + str(ques_text) + " Class probability matrix = " + str(result)) return result
def main(): """ Creates a temporary file for the given input which is used to create a dataset, that is then evaluated on the given model. The generated summary is printed to standard out. """ args, unknown_args = prepare_arg_parser().parse_known_args() model_file = args.model_file with suppress_stdout_stderr(): model, _optimizer, vocab, _stats, cfg = train.load_model( model_file, unknown_args ) _, filename = tempfile.mkstemp() try: with open(filename, "a") as f: input_ = sys.stdin.read() article = preprocess.parse(input_) print(f"{article}\tSUMMARY_STUB", file=f) with suppress_stdout_stderr(): dataset = Dataset(filename, vocab, cfg) batch = next(dataset.generator(1, cfg.pointer)) # don't enforce any min lengths (useful for short cmdline summaries") setattr(cfg, "min_summary_length", 1) bs = BeamSearch(model, cfg=cfg) summary = evaluate.batch_to_text(bs, batch)[0] print(f"SUMMARY:\n{summary}") finally: os.remove(filename)
def main(): """Run evaluation on given test_file and print ROUGE scores to console""" args, unknown_args = prepare_arg_parser().parse_known_args() model_file = args.model_file test_file = args.test_file model, _optimizer, vocab, stats, cfg = train.load_model( model_file, unknown_args) model.eval() dataset = Dataset(test_file, vocab, cfg, evaluation=True) print("Evaluating with %s on %d pairs:" % (DEVICE.type.upper(), len(dataset))) with tqdm(total=min(len(dataset), cfg.limit), ncols=0, desc="Evaluating") as pbar: hypothesis, references = generate_summaries(model, dataset, cfg, pbar=pbar) scores = Rouge(use_python=args.use_python).get_scores( hypothesis, references) log_dict = make_log_dict(model_file, test_file, scores, stats, cfg, hypothesis, args.use_python) log_results(log_dict) if args.save: destination = Path(model_file).with_suffix(".json") save_summaries(destination, hypothesis, references, log_dict=log_dict) print_scores(scores)
def synth1(models, text, out): hparams = create_hparams() checkpoint_path = models + '/checkpoint_800' model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = model.eval() waveglow_path = models + '/waveglow' waveglow = torch.load(waveglow_path)['model'] waveglow.cuda() for m in waveglow.modules(): if 'Conv' in str(type(m)): setattr(m, 'padding_mode', 'zeros') sequence = np.array(text_to_sequence(text, ['basic_cleaners']))[None, :] sequence = torch.autograd.Variable( torch.from_numpy(sequence)).cuda().long() mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence) with torch.no_grad(): audio = 32768.0 * waveglow.infer(mel_outputs_postnet, sigma=0.666)[0] audio = audio.cpu().numpy() audio = audio.astype('int16') write(out, 22050, audio)
def run(sigma, sentence_path, taco_cp_path, wg_cp_path, cleaner='english_cleaners', output_dir='', is_fp16=True): hparams = create_hparams() hparams.sampling_rate = 22050 # set 80 if u use korean_cleaners. set 149 if u use english_cleaners hparams.n_symbols = 80 if cleaner == 'korean_cleaners' else 148 hparams.text_cleaners = [cleaner] f = open(sentence_path, 'r') sentences = [x.strip() for x in f.readlines()] f.close() model = load_model(hparams) model.load_state_dict(torch.load(taco_cp_path)['state_dict']) _ = model.cuda().eval() waveglow = torch.load(wg_cp_path)['model'] waveglow = waveglow.remove_weightnorm(waveglow) waveglow.cuda().eval() if is_fp16: model.half() waveglow.half() for k in waveglow.convinv: k.float() mel_outputs = generate_mels(model, sentences, cleaner, output_dir) mels_to_wavs_WG(waveglow, mel_outputs, sigma, is_fp16, hparams, output_dir)
def main(): """Argument parser for making G2P predictions""" parser = argparse.ArgumentParser() parser.add_argument('pron_path', default='./data/prondict_ice.txt', nargs='?') parser.add_argument( 'words', default=['adolfsdóttir', 'skynsemi', 'uppvaxtarskilyrði'], nargs='?') parser.add_argument('exp_name', default='g2p_ice', nargs='?') parser.add_argument('emb_dim', default=500, nargs='?') parser.add_argument('hidden_dim', default=500, nargs='?') parser.add_argument('cuda', default=True, nargs='?') parser.add_argument('seed', default=1337, nargs='?') parser.add_argument('result_dir', default='./results', nargs='?') parser.add_argument('data_splits', default=(0.9, 0.05, 0.05), nargs='?') args = parser.parse_args() exp_dir = os.path.join(args.result_dir, args.exp_name) ckp_path = os.path.join(exp_dir, 'mdl.ckpt') full_ds, _ = load_data(args.pron_path, args.data_splits, **vars(args)) model = load_model(full_ds.num_graphemes, full_ds.num_phonemes, ckp_path, **vars(args)) for word in args.words: print(word) predict(model, word, full_ds)
def generate_mels(hparams, checkpoint_path, sentences, speaker_id, trans_con, logvar, cleaner, removing_silence_mel_padding, adding_silence_mel_padding, is_GL, output_dir=""): model = load_model(hparams) try: model = model.module except: pass model.load_state_dict({ k.replace('module.', ''): v for k, v in torch.load(checkpoint_path)['state_dict'].items() }) _ = model.eval() speaker_name = hparams.speaker_list[speaker_id] audio_path = os.path.join("./wavfile", speaker_name, speaker_name + "_t01_s03.wav") refence_mel, ref_length = get_mel(hparams, audio_path) output_mels = [] for i, s in enumerate(sentences): sequence = np.array(text_to_sequence(s, cleaner))[None, :] sequence = torch.autograd.Variable( torch.from_numpy(sequence)).cuda().long() stime = time.time() if trans_con == 0: ref = False elif trans_con == 1: ref = True _, mel_outputs_postnet, _, alignments = model.inference( sequence, refence_mel, ref_length, condition_on_ref=ref, logvar=logvar) mel = mel_outputs_postnet.data.cpu().numpy( )[0][:, :-removing_silence_mel_padding] mel = np.append( mel, np.ones((80, adding_silence_mel_padding), dtype=np.float32) * -4.0, axis=1) if (is_GL): plot_data((mel, alignments.data.cpu().numpy()[0].T), i, output_dir) inf_time = time.time() - stime print("{}th sentence, Infenrece time: {:.2f}s, len_mel: {}".format( i, inf_time, mel_outputs_postnet.size(2))) output_mels.append(mel) return output_mels
def load_checkpoint(checkpoint_path='model_checkpoint.pth'): checkpoint = torch.load(checkpoint_path) structure = checkpoint['structure'] hidden_layer1 = checkpoint['hidden_layer1'] model, _, _ = load_model(structure, 0.5, hidden_layer1) model.class_to_idx = checkpoint['class_to_idx'] model.load_state_dict(checkpoint['state_dict']) return model
def generate(model_path,model_name,generate_path,generate_name,start_piece=None,sr = 1600,duration=1): if os.path.exists(generate_path) is False: os.makedirs(generate_path) with open('./params/model_params_text.json') as f : model_params = json.load(f) f.close() net = wavenet_autoencoder(**model_params) net = load_model(net,model_path,model_name) cuda_available = torch.cuda.is_available() if cuda_available is True: net = net.cuda() # print(net.receptive_field) if start_piece is None: data= open('../np_text1.pkl','rb') data = pickle.load(data) data = np.array(data) data = data[0] data = torch.from_numpy(data) data = data[-net.receptive_field-512:] start_piece = torch.zeros(100,net.receptive_field+512) start_piece[data.numpy(),np.arange(net.receptive_field+512)] = 1 # start_piece = torch.from_numpy(start_piece) start_piece = start_piece.view(1,100,net.receptive_field+512) start_piece = Variable(start_piece) del data # start_piece = torch.zeros(1, 256, net.receptive_field+512) # start_piece[:, 128, :] = 1.0 # start_piece = Variable(start_piece) if cuda_available is True: start_piece = start_piece.cuda() note_num = duration * sr note = start_piece state_queue = None generated_piece = [] input_wav = start_piece char2id, id2char, vocab_size,chars = create_dictionary() for i in range(note_num): print(i) predict_note = predict_next(net, input_wav) generated_piece.append(predict_note) temp = torch.zeros(net.quantization_channel,1) temp[predict_note] =1 temp = temp.view(1,net.quantization_channel,1) # temp = torch.zeros(1, net.quantization_channel, 1) # temp[:, predict_note, :] = 1.0 note = Variable(temp) note = note.cuda() # # print(note.size()) # # print(input_wav.size()) input_wav = torch.cat((input_wav[:,-net.receptive_field-510:],note), 2) print(generated_piece) generated_piece = torch.LongTensor(generated_piece) generated_piece = [id2char[i] for i in generated_piece ] generated_piece = ''.join(generated_piece) output = open(generate_path+'generated_piece2.txt','w') # pickle.dump(generated_piece,output) output.write(str(generated_piece)) output.close()
def predict(config, img_data): # write tmp img img_path = "" features = get_features(img_path) model = load_model(config) label = model.predict(features) return label
def predict_from_dir(args): images = os.listdir(args.dir) if len(images) == 0: print('Cannot find any images in ' + args.dir) return print('%d images to classify found' % len(images)) use_cuda = torch.cuda.is_available() and args.gpu.lower() == 'true' device = torch.device("cuda" if use_cuda else "cpu") print("Using GPU" if use_cuda else "Using CPU") # loading labels labels = ImageDataset.load_labels(args.data_root) if labels is None: print("Failed to load labels. Data root is " + args.data_root) return num_classes = len(labels) print("Number of recognized classes = %d" % num_classes) # loading model print("loading model...") model, model_name = load_model(args.model, device, num_classes, inference=True) target_size = (224, 224) # loading snapshot snapshot_file = os.path.join("snapshots", model_name, "snapshot_%d.pt" % args.snapshot) if not os.path.exists(snapshot_file): print("Snapshot file does not exists: " + snapshot_file) return model.load_state_dict(torch.load(snapshot_file, 'cpu')) for image_name in images: img = cv2.imread(os.path.join(args.dir, image_name)) if img is None: print('Failed to load ' + image_name) continue img = cv2.resize(img, target_size, interpolation=cv2.INTER_AREA) # getting required number of frames for prediction images_to_predict = [img] probs = predict_with_tta(args.tta, images_to_predict, model, target_size) sorted_indexes = np.argsort(probs) for t in range(5): label_index = sorted_indexes[-t - 1] label_prob = probs[label_index] label_name = labels[label_index] s = "%s: %1.2f%% %s" % (image_name, label_prob * 100.0, label_name) print(s)
def prepare_graph(build_net_m, save_dir): images1_ph, images2_ph, labels_ph = train.create_input_placeholders([None, None, 3]) net_op = build_net_m(images1_ph, images2_ph, is_training=False) init = tf.initialize_all_variables() # sess = tf.Session(config=tf.ConfigProto(log_device_placement=False)) sess = tf.get_default_session() saver = tf.train.Saver(var_list=tf.get_collection(slim.variables.VARIABLES_TO_RESTORE)) sess.run(init) train.load_model(saver, sess, save_dir) def maximize_output(layer_name, channel, octave_n=3, octave_scale=1.4, iter_n=20, step=1.0, seed=None): t_obj = tf.get_default_graph().get_tensor_by_name(layer_name + ':0')[:, :, :, channel] t_score = tf.reduce_mean(t_obj) t_grad = tf.gradients(t_score, [images1_ph, images2_ph]) if seed is not None: np.random.seed(seed) img1 = np.random.uniform(64, 192, size=(1, TILE_SIZE, TILE_SIZE, 3)) img2 = img1.copy() for octave in range(octave_n): my_print("%s %i %i" % (layer_name, channel, octave)) if octave > 0: hw = np.float32(img1.shape[1:3]) * octave_scale img1 = resize(img1, np.int32(hw)) img2 = resize(img2, np.int32(hw)) for i in range(iter_n): g1, g2 = calc_grad_tiled(img1, img2, t_grad, images1_ph, images2_ph) div = np.concatenate((g1, g2)).std() + 1e-8 g1 /= div g2 /= div img1 += g1 * step img2 += g2 * step my_print(' .') my_print('\n') # showarray(visstd(np.concatenate((img1, img2), 2))) my_print('\r') return float_to_uint(visstd(np.concatenate((img1[0], img2[0]), 1))) return maximize_output
def generate_from_file(tacotron2_path, waveglow_path, text_file, output_directory): # Make synthesis paths if not os.path.exists(output_directory): os.makedirs(output_directory) print("Creating directory " + output_directory + "...") hparams = create_hparams() hparams.sampling_rate = 22050 print("Loading models...") model = load_model(hparams) model.load_state_dict(torch.load(tacotron2_path)['state_dict']) _ = model.cuda().eval().half() waveglow = torch.load(waveglow_path)['model'] waveglow.cuda().eval().half() for k in waveglow.convinv: k.float() denoiser = Denoiser(waveglow) genlist = [] with open(text_file) as file: for line in file: genlist.append(line.strip()) for entry in genlist: wav_name = "_".join(entry.split(" ")[:4]).lower() + ".wav" epi = epitran.Epitran('eng-Latn', ligatures = True) if hparams.preprocessing == "ipa": entry = ipa.convert(english_cleaners(entry)) foreign_words = re.findall(r"[^ ]{0,}\*", entry) for word in foreign_words: entry = entry.replace(word, epi.transliterate(word[0:len(word)-1])) if hparams.preprocessing == "arpabet": entry = make_arpabet(entry) # Text sequencer if hparams.preprocessing is not None: sequence = np.array(text_to_sequence(entry, None))[None, :] else: sequence = np.array(text_to_sequence(entry, ['english_cleaners']))[None, :] sequence = torch.autograd.Variable( torch.from_numpy(sequence)).cuda().long() # Synthesis mel_outputs, mel_outputs_postnet, _, alignments = model.inference(sequence) with torch.no_grad(): audio = waveglow.infer(mel_outputs_postnet, sigma=0.666) audio_denoised = denoiser(audio, strength=0.01)[:, 0] # Save audio print ("Saving " + wav_name) write(os.path.join(output_directory, wav_name), hparams.sampling_rate, audio_denoised[0].data.cpu().numpy())
def get_Tacotron2(hparams): checkpoint_path = "checkout" checkpoint_path = os.path.join(checkpoint_path, "tacotron2_statedict.pt") print("load tacotron2 model !!") model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = model.cuda().eval() return model
def load_checkpoint(filepath): checkpoint = torch.load(filepath) arch = checkpoint['arch'] num_labels = len(checkpoint['class_to_idx']) hidden_units = checkpoint['hidden_units'] model = load_model(arch=arch, num_labels=num_labels, hidden_units=hidden_units) model.load_state_dict(checkpoint['state_dict']) return model, checkpoint['class_to_idx']
def classify_sample(sample) -> bool: """ classifies one sample """ is_sample_valid = validate_sample(sample) if is_sample_valid is False: raise Exception("Invalid sample") model = load_model() is_model_valid, _ = validate_model(model) if is_model_valid is False: raise Exception("Invalid model") predicted_class = int(model.predict(sample)[0]) return predicted_class
def predict(image, checkpoint, topk=5, labels='', gpu=True): ''' Predict the class (or classes) of an image using a trained deep learning model. ''' # Use command line values when specified if args.image: image = args.image if args.checkpoint: checkpoint = args.checkpoint if args.topk: topk = args.topk if args.labels: labels = args.labels if args.gpu: gpu = args.gpu # Loading the checkpoint checkpoint_dict = torch.load(checkpoint) arch = checkpoint_dict['arch'] output_size = len(checkpoint_dict['class_to_idx']) hidden_units = checkpoint_dict['hidden_units'] model = load_model(arch, output_size, hidden_units) model.load_state_dict(checkpoint_dict['state_dict']) model.class_to_idx = checkpoint_dict['class_to_idx'] if gpu: model.to('cuda') model.eval() image = Image.open(image_path) image_array = process_image(image) image_tensor = torch.from_numpy(image_array) inputs = image_tensor.type(torch.cuda.FloatTensor) inputs = inputs.unsqueeze(0) # Forward Pass on Model output = model.forward(inputs) ps = torch.exp(output).data.topk(topk) ps_top_five = ps[0].cpu() classes = ps[1].cpu() class_to_idx_i = {model.class_to_idx[i]: i for i in model.class_to_idx} classes_m = [class_to_idx_i[label] for label in classes.numpy()[0]] return ps_top_five.numpy()[0], classes_m
def restore_tacotron(self): checkpoint_path = self.taco_path self.model = load_model(self.hparams) try: self.model = self.model.module except: pass self.model.load_state_dict({ k.replace('module.', ''): v for k, v in torch.load(checkpoint_path)['state_dict'].items() }) _ = self.model.eval()
def predict(build_net_m, image1_raw, save_dir, iter_n=20, step=1, seed=None, image2_raw=None): img1 = np.expand_dims(image1_raw, 0) image1 = tf.placeholder(dtype=tf.float32, shape=[None, None, None, 3], name='image1') image2 = tf.placeholder(dtype=tf.float32, shape=[None, None, None, 3], name='image2') net_op = build_net_m(image1, image2) # predict_layer = 'conv6/Conv/BiasAdd' # t_obj0 = tf.get_default_graph().get_tensor_by_name(predict_layer + ':0')[:, :, :, 0] # t_obj1 = tf.get_default_graph().get_tensor_by_name(predict_layer + ':0')[:, :, :, 1] # t_score = tf.reduce_mean(t_obj1) - tf.reduce_mean(t_obj0)# - slim.losses.l2_loss(image1 - image2, 5e-2) t_score = net_op[0, 1] # - net_op[0, 0] t_grad = tf.gradients(t_score, image2)[0] init = tf.initialize_all_variables() sess = tf.get_default_session() saver = tf.train.Saver() sess.run(init) train.load_model(saver, sess, save_dir) if seed is not None: np.random.seed(seed) img2 = np.expand_dims(image2_raw, 0) for i in range(iter_n): pred, g, ts = sess.run([net_op, t_grad, t_score], {image1: img1, image2: img2}) my_print('iter ' + str(i) + '\n') my_print('std ' + str(g.std()) + '\n') my_print('score ' + str(ts) + '\n') my_print('pred ' + str(pred) + '\n') my_print('\n') g /= g.std() + 1e-20 img2 += g * step my_print('\n') return np.concatenate([(img1[0]), (img2[0])], 1), img1[0] - img2[0]
def generate(model_path, model_name, generate_path, generate_name, start_piece=None, sr=16000, duration=10): if os.path.exists(generate_path) is False: os.makedirs(generate_path) with open('./params/model_params.json') as f: model_params = json.load(f) f.close() net = wavenet_autoencoder(**model_params) net = load_model(net, model_path, model_name) cuda_available = torch.cuda.is_available() if cuda_available is True: net = net.cuda() # print(net.receptive_field) if start_piece is None: start_piece = torch.zeros(1, 256, net.receptive_field + 512) start_piece[:, 128, :] = 1.0 start_piece = Variable(start_piece) if cuda_available is True: start_piece = start_piece.cuda() note_num = duration * sr note = start_piece state_queue = None generated_piece = [] input_wav = start_piece for i in range(note_num): print(i) predict_note = predict_next(net, input_wav) generated_piece.append(note) temp = torch.zeros(net.quantization_channel, 1) temp[predict_note] = 1 temp = temp.view(1, net.quantization_channel, 1) # temp = torch.zeros(1, net.quantization_channel, 1) # temp[:, predict_note, :] = 1.0 note = Variable(temp) note = note.cuda() # print(note.size()) # print(input_wav.size()) input_wav = torch.cat( (input_wav[:, -net.receptive_field - 511:], note), 2) print(generated_piece) generated_piece = torch.LongTensor(generated_piece) generated_piece = mu_law_decode(generated_piece, net.quantization_channel) generated_piece = generated_piece.numpy() wav_name = generate_path + generate_name librosa.output.write_wav(wav_name, generated_piece, sr=sr)
def main(): """ Creates the GUI and runs the pipeline. """ gui = Gui(key_handler=key_handler) gui.state["model"] = load_model() widget_camera = Widget("Camera", do_camera, show_window=True, show_controls=False) gui.widgets.append(widget_camera) widget_greyscale = Widget("Greyscale", do_greyscale, show_window=False, show_controls=False) gui.widgets.append(widget_greyscale) # widget_denoising = Widget("Denoising", do_denoising) # widget_denoising.params.append(Param(P_DENOISE_KERNEL, 1, 20, 1)) # gui.widgets.append(widget_denoising) widget_threshold = Widget("Threshold", do_threshold, show_controls=False) widget_threshold.params.append(Param(P_THRESHOLD_BLOCK_SIZE, 0, 50, 5)) widget_threshold.params.append(Param(P_THRESHOLD_MAX_VAL, 0, 255, 160)) widget_threshold.params.append(Param(P_THRESHOLD_CONSTANT, -20, 20, 0)) gui.widgets.append(widget_threshold) widget_blur = Widget("Blur", do_blur, show_controls=False) widget_blur.params.append(Param(P_BLUR_KERNEL, 0, 20, 2)) gui.widgets.append(widget_blur) widget_edges_canny = Widget("Canny Edge Detection", do_edges_canny, display_function=do_display_edges, show_controls=False) widget_edges_canny.params.append(Param(P_CANNY_THRESHOLD_1, 1, 600, 110)) widget_edges_canny.params.append(Param(P_CANNY_THRESHOLD_2, 1, 600, 320)) gui.widgets.append(widget_edges_canny) # widget_edges_hough = Widget("Hough Line Detection", do_edges_hough, show_image=False) # widget_edges_hough.params.append(Param(P_HOUGH_RHO, 1, 10, 1)) # widget_edges_hough.params.append(Param(P_HOUGH_THRESHOLD, 1, 500, 100)) # widget_edges_hough.params.append( # Param(P_HOUGH_MIN_LINE_LENGTH, 1, 300, 10)) # widget_edges_hough.params.append(Param(P_HOUGH_MAX_LINE_GAP, 1, 300, 10)) # gui.widgets.append(widget_edges_hough) widget_annotate = Widget("Annotated Camera Frame", do_annotation) gui.widgets.append(widget_annotate) gui.show()
def load_models(hparams, checkpoint_path, waveglow_path): print("load models...") model = load_model(hparams) model.load_state_dict(torch.load(checkpoint_path)['state_dict']) model.cuda().eval() waveglow = torch.load(waveglow_path)['model'] waveglow.cuda().eval() for k in waveglow.convinv: k.float() print("loaded!") return model, waveglow
def __init__(self): hparams = create_hparams() hparams.sampling_rate = 22050 checkpoint_path = constants.TACOTRON_PT self.model = load_model(hparams) self.model.load_state_dict(torch.load(checkpoint_path)['state_dict']) _ = self.model.cuda().eval().half() waveglow_path = constants.WAVEGLOW_PT self.waveglow = torch.load(waveglow_path)['model'] self.waveglow.cuda().eval().half() for k in self.waveglow.convinv: k.float() self.denoiser = Denoiser(self.waveglow)
def predict(args): makedirs("ans") with open("conf/fea.yaml") as fin: cfg = yaml.load(fin)[args.p] begin, end = map(int, cfg["test"].split("-")) with TimeLog("load data"): data = read_data(cfg["data"], begin, end) if not args.m: args.m = args.p model = load_model("model/" + args.m) #, model_file="e3.hdf5") pred = model.predict(data.fea, batch_size=1024, verbose=1) gen_ans(pred, data, "ans/" + args.m) K.clear_session()
def run_gan(get_data_m, get_generator, get_discriminator, batch_size, image_size, iter_n=1000000, init_rate=0.0001, logs_dir='logs_tmp/', save_dir='save_tmp/', need_load=False): """ build_net_m: (t_images1, t_images2, is_trainable) -> t_logits get_data_m: () -> (images1, images2) """ create_dir(logs_dir) create_dir(save_dir) save_file_path = os.path.join(save_dir, 'model.ckpt') images1 = tf.placeholder(tf.float32, [batch_size] + image_size, name='images1') # todo: Change to variable shapes images2 = tf.placeholder(tf.float32, [batch_size] + image_size, name='images2') # Build nets G = get_generator(images1) D_true = get_discriminator(images1, images2) # Checks true image pairs D_false = get_discriminator(images2, images1, reuse=True) # Checks false image pairs D_gen = get_discriminator(images1, G, reuse=True) # Checks generated image pairs d_vars = [] g_vars = [] for var in tf.trainable_variables(): name = var.op.name if name.startswith('discriminator/'): d_vars.append(var) if name.startswith('generator/'): g_vars.append(var) # C = build_net_m(images1, G, is_training=False) # Trained classifier dt_sum = tf.histogram_summary("dt", D_true) df_sum = tf.histogram_summary("df", D_false) dg_sum = tf.histogram_summary("dg", D_gen) g_sum = tf.image_summary("g", G) g_sum_2 = tf.image_summary("left_g", tf.concat(2, [images1, G])) # Build losses dt_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(D_true, tf.ones_like(D_true))) df_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(D_false, tf.zeros_like(D_false))) dg_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(D_gen, tf.zeros_like(D_gen))) g_loss_discr = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(D_gen, tf.ones_like(D_gen))) # g_loss_net = train.build_loss(C, tf.constant(1, dtype=tf.int64, shape=[BATCH_SIZE])) * 50.0 g_loss_reg = tf.div(slim.losses.l1_loss(G - images1, weight=2e-6, scope='l1_loss'), batch_size) g_loss_l2im2 = tf.div(slim.losses.l2_loss(G - images2, weight=2e-6, scope='l2im2_loss'), batch_size) dt_loss_sum = tf.scalar_summary("dt_loss", dt_loss) df_loss_sum = tf.scalar_summary("df_loss", df_loss) dg_loss_sum = tf.scalar_summary("dg_loss", dg_loss) g_loss_discr_sum = tf.scalar_summary("g_loss_discr", g_loss_discr) # g_loss_net_sum = tf.scalar_summary("g_loss_net", g_loss_net) g_loss_reg_sum = tf.scalar_summary("g_loss_reg", g_loss_reg) g_loss_l2im2_sum = tf.scalar_summary("g_loss_l2im2", g_loss_l2im2) # d_loss = dt_loss * 3.0 + df_loss * 3.0 + dg_loss * 2.0 d_loss = dt_loss + dg_loss # g_loss = g_loss_discr + g_loss_reg + g_loss_l2im2 # g_loss = g_loss_discr + g_loss_l2im2 # g_loss = g_loss_reg g_loss = g_loss_l2im2 d_loss_sum = tf.scalar_summary("d_loss", d_loss) g_loss_sum = tf.scalar_summary("g_loss", g_loss) # Build optimizers g_opt = tf.train.AdamOptimizer(init_rate, name='train_G') g_grads = g_opt.compute_gradients(g_loss, var_list=g_vars) d_opt = tf.train.AdamOptimizer(init_rate, name='train_D') d_grads = d_opt.compute_gradients(d_loss, var_list=d_vars) d_apply_grad = d_opt.apply_gradients(d_grads) g_apply_grad = g_opt.apply_gradients(g_grads) for var in tf.trainable_variables(): tf.histogram_summary(var.op.name, var) for grad, var in d_grads: if grad is not None: tf.histogram_summary(var.op.name + '/gradients', grad) for grad, var in g_grads: if grad is not None: tf.histogram_summary(var.op.name + '/gradients', grad) step = slim.variables.variable('step_ref', shape=[], initializer=tf.constant_initializer(0), dtype=tf.int64, trainable=False) step = tf.assign(step, tf.add(step, 1), name='global_step') merged_summaries = tf.merge_all_summaries() sess = tf.get_default_session() # old_variables = [] # for var in tf.get_collection(slim.variables.VARIABLES_TO_RESTORE): # if (var.op.name.startswith('discriminator') or # var.op.name.startswith('generator') or # var.op.name == 'step_ref'): # pass # else: # old_variables.append(var) saver = tf.train.Saver(tf.get_collection(slim.variables.VARIABLES_TO_RESTORE)) # tmp_saver = tf.train.Saver(g_vars) # old_saver = tf.train.Saver(old_variables) writer = tf.train.SummaryWriter(logs_dir, sess.graph, flush_secs=30) sess.run(tf.initialize_all_variables()) tf.train.start_queue_runners() if need_load: train.load_model(saver, sess, save_file_path) else: pass # train.load_model(old_saver, sess, 'save_kingstreet/model.ckpt') # todo: remove kingstreet my_print("Starting...\n") for i in range(0, iter_n): im1, im2 = get_data_m() feed = { images1: im1, images2: im2 } st = step.eval() g_loss_val = 0.0 for j in range(2): _, g_loss_val = sess.run([g_apply_grad, g_loss], feed) if g_loss_val < 5 and False: d_apply_grad.run(feed) if st % 10 == 0: summary_str = merged_summaries.eval(feed) my_print('Current step: %i\n' % st) writer.add_summary(summary_str, st) if st % 100 == 0: train.save_model(saver, sess, save_file_path)
#--use a benchmark instead of a classifier--# benchmark_preds = train.cross_validate_using_benchmark('3.5', dfTrn, dfTrn[0].merge(dfTrn[1],how='inner',on='business_id').as_matrix(),dfTrn[0].ix[:,['rev_stars']].as_matrix(),folds=3,SEED=42,test_size=.15) benchmark_preds = train.cross_validate_using_benchmark('global_mean', dfTrn, dfTrn[0].merge(dfTrn[1],how='inner',on='business_id').as_matrix(),dfTrn[0].ix[:,['rev_stars']].as_matrix(),folds=3,SEED=42,test_size=.15) benchmark_preds = train.cross_validate_using_benchmark('business_mean', dfTrn, dfTrn[0].merge(dfTrn[1],how='inner',on='business_id').as_matrix(),dfTrn[0].ix[:,['rev_stars']].as_matrix(),folds=3,SEED=42,test_size=.15) benchmark_preds = train.cross_validate_using_benchmark('usr_mean', dfTrn, dfTrn[0].merge(dfTrn[2],how='inner',on='user_id').as_matrix(),dfTrn[0].merge(dfTrn[2],how='inner',on='user_id').ix[:,['rev_stars']].as_matrix(),folds=3,SEED=22,test_size=.15) #--predict using a benchmark--# train.save_predictions_benchmark(dfTest_Benchmark_BusMean,'bus_mean',submission_no) train.save_predictions_benchmark(dfTest_Benchmark_UsrMean,'usr_mean',submission_no) train.save_predictions_benchmark(dfTest_Benchmark_BusUsrMean,'bus_usr_mean',submission_no) #--Save model to joblib file--# train.save_model(clf,clf_name) #--Save a dataframe to CSV--# filename = 'Data/'+datetime.now().strftime("%d-%m-%y_%H%M")+'--FinalDataset--OldUserTest'+'.csv' #del dfTest_Master['business_id'];del dfTest_Master['user_id']; #dfTest_Master.ix[:,['RecommendationId','calc_user_avg_stars','calc_user_rev_count']].to_csv(filename, index=False) dfTest_Old[2].to_csv(filename, index=False) #--Save predictions to CSV--# filename = 'Data/'+datetime.now().strftime("%d-%m-%y_%H%M")+'--Pred_ChkBus&Open_LinReg'+'.csv' dfTest_Master['predictions_LinReg'] = [x[0] for x in dfTest_Master.predictions_LinReg] dfTest_Master.ix[:,['RecommendationId','predictions_LinReg']].to_csv(filename, index=False) #--Load model from joblib file--# clf = train.load_model('Models/07-07-13_1247--SGD_001_1000.joblib.pk1') if __name__ == '__main__': main()
def predict(image, checkpoint, topk=5, labels='', gpu=False): ''' Predict the class (or classes) of an image using a trained deep learning model. ''' # Use command line values when specified if args.image: image = args.image if args.checkpoint: checkpoint = args.checkpoint if args.topk: topk = args.topk if args.labels: labels = args.labels if args.gpu: gpu = args.gpu # Load the checkpoint checkpoint_dict = torch.load(checkpoint) arch = checkpoint_dict['arch'] num_labels = len(checkpoint_dict['class_to_idx']) hidden_units = checkpoint_dict['hidden_units'] model = load_model(arch=arch, num_labels=num_labels, hidden_units=hidden_units) # Use gpu if selected and available if gpu and torch.cuda.is_available(): model.cuda() was_training = model.training model.eval() img_loader = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor()]) pil_image = Image.open(image) pil_image = img_loader(pil_image).float() image = np.array(pil_image) mean = np.array([0.485, 0.456, 0.406]) std = np.array([0.229, 0.224, 0.225]) image = (np.transpose(image, (1, 2, 0)) - mean)/std image = np.transpose(image, (2, 0, 1)) image = Variable(torch.FloatTensor(image), requires_grad=True) image = image.unsqueeze(0) # this is for VGG if gpu and torch.cuda.is_available(): image = image.cuda() result = model(image).topk(topk) if gpu and torch.cuda.is_available(): # Added softmax here as per described here: # https://github.com/pytorch/vision/issues/432#issuecomment-368330817 probs = torch.nn.functional.softmax(result[0].data, dim=1).cpu().numpy()[0] classes = result[1].data.cpu().numpy()[0] else: probs = torch.nn.functional.softmax(result[0].data, dim=1).numpy()[0] classes = result[1].data.numpy()[0] if labels: with open(labels, 'r') as f: cat_to_name = json.load(f) labels = list(cat_to_name.values()) classes = [labels[x] for x in classes] model.train(mode=was_training) # Print only when invoked by command line if args.image: print('Predictions and probabilities:', list(zip(classes, probs))) return probs, classes