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
