def test():
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(HParams())
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
print(bcolors.HEADER + '\nPost-training static quantization' +
bcolors.ENDC)
num_calibration_batches = 10
model.qconfig = torch.quantization.default_qconfig
print(model.qconfig)
torch.quantization.prepare(model, inplace=True)
# Calibrate first
print('Post Training Quantization Prepare: Inserting Observers')
# Calibrate with the training set
print('Calibrate with the training set')
evaluate(model, neval_batches=num_calibration_batches)
print('Post Training Quantization: Calibration done')
# Convert to quantized model
torch.quantization.convert(model, inplace=True)
print('Post Training Quantization: Convert done')
print("Size of model after quantization")
print_size_of_model(model)
def load_glow_tts(config_path, checkpoint_path):
with open(config_path, "r") as f:
data = f.read()
config = json.loads(data)
hparams = HParams(**config)
model = FlowGenerator(len(glow_tts_symbols),
out_channels=hparams.data.n_mel_channels,
**hparams.model).to("cpu")
load_checkpoint(checkpoint_path, model)
model.decoder.store_inverse(
) # do not calcuate jacobians for fast decoding
_ = model.eval()
return model
def main():
print('initializing preprocessing..')
hparams = HParams()
parser = argparse.ArgumentParser()
parser.add_argument('--base_dir', default='')
parser.add_argument(
'--hparams',
default='',
help=
'Hyperparameter overrides as a comma-separated list of name=value pairs'
)
parser.add_argument('--dataset', default='TIMIT')
parser.add_argument('--output', default='testing_TIMIT-noisy')
parser.add_argument('--n_jobs', type=int, default=cpu_count())
args = parser.parse_args()
run_preprocess(args, hparams)
def __init__(self, nbatch=128, nsteps=64):
global hps
hps = HParams(
load_path='model_params/params.jl',
nhidden=4096,
nembd=64,
nsteps=nsteps,
nbatch=nbatch,
nstates=2,
nvocab=256,
out_wn=False,
rnn_wn=True,
rnn_type='mlstm',
embd_wn=True,
)
global params
params = [np.load('model/%d.npy' % i) for i in range(15)]
params[2] = np.concatenate(params[2:6], axis=1)
params[3:6] = []
X = tf.placeholder(tf.int32, [None, hps.nsteps])
M = tf.placeholder(tf.float32, [None, hps.nsteps, 1])
S = tf.placeholder(tf.float32, [hps.nstates, None, hps.nhidden])
cells, states, logits = model(X, S, M, reuse=False)
#gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.5)
#sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
sess = tf.Session()
tf.global_variables_initializer().run(session=sess)
def seq_rep(xmb, mmb, smb):
return sess.run(states, {X: xmb, M: mmb, S: smb})
def seq_cells(xmb, mmb, smb):
return sess.run(cells, {X: xmb, M: mmb, S: smb})
def transform(xs):
tstart = time.time()
xs = [preprocess(x) for x in xs]
lens = np.asarray([len(x) for x in xs])
sorted_idxs = np.argsort(lens)
unsort_idxs = np.argsort(sorted_idxs)
sorted_xs = [xs[i] for i in sorted_idxs]
maxlen = np.max(lens)
offset = 0
n = len(xs)
smb = np.zeros((2, n, hps.nhidden), dtype=np.float32)
for step in range(0, ceil_round_step(maxlen, nsteps), nsteps):
start = step
end = step + nsteps
xsubseq = [x[start:end] for x in sorted_xs]
ndone = sum([x == b'' for x in xsubseq])
offset += ndone
xsubseq = xsubseq[ndone:]
sorted_xs = sorted_xs[ndone:]
nsubseq = len(xsubseq)
xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps)
for batch in range(0, nsubseq, nbatch):
start = batch
end = batch + nbatch
batch_smb = seq_rep(xmb[start:end], mmb[start:end],
smb[:, offset + start:offset + end, :])
smb[:, offset + start:offset + end, :] = batch_smb
features = smb[0, unsort_idxs, :]
#print('%0.3f seconds to transform %d examples' %
# (time.time() - tstart, n))
return features
def cell_transform(xs, indexes=None):
Fs = []
xs = [preprocess(x) for x in xs]
for xmb in tqdm(iter_data(xs, size=hps.nbatch),
ncols=80,
leave=False,
total=len(xs) // hps.nbatch):
smb = np.zeros((2, hps.nbatch, hps.nhidden))
n = len(xmb)
xmb, mmb = batch_pad(xmb, hps.nbatch, hps.nsteps)
smb = sess.run(cells, {X: xmb, S: smb, M: mmb})
smb = smb[:, :n, :]
if indexes is not None:
smb = smb[:, :, indexes]
Fs.append(smb)
Fs = np.concatenate(Fs, axis=1).transpose(1, 0, 2)
return Fs
self.transform = transform
self.cell_transform = cell_transform
def __init__(self, nbatch=128, nsteps=64):
global hps
hps = HParams(
load_path='model_params/params.jl',
nhidden=4096,
nembd=64,
nsteps=nsteps,
nbatch=nbatch,
nstates=2,
nvocab=256,
out_wn=False,
rnn_wn=True,
rnn_type='mlstm',
embd_wn=True,
)
global params
params = [np.load('model/%d.npy'%i) for i in range(15)]
params[2] = np.concatenate(params[2:6], axis=1)
params[3:6] = []
X = tf.placeholder(tf.int32, [None, hps.nsteps])
M = tf.placeholder(tf.float32, [None, hps.nsteps, 1])
S = tf.placeholder(tf.float32, [hps.nstates, None, hps.nhidden])
cells, states, logits = model(X, S, M, reuse=False)
sess = tf.Session()
tf.global_variables_initializer().run(session=sess)
def seq_rep(xmb, mmb, smb):
return sess.run(states, {X: xmb, M: mmb, S: smb})
def seq_cells(xmb, mmb, smb):
return sess.run(cells, {X: xmb, M: mmb, S: smb})
def transform(xs):
tstart = time.time()
xs = [preprocess(x) for x in xs]
lens = np.asarray([len(x) for x in xs])
sorted_idxs = np.argsort(lens)
unsort_idxs = np.argsort(sorted_idxs)
sorted_xs = [xs[i] for i in sorted_idxs]
maxlen = np.max(lens)
offset = 0
n = len(xs)
smb = np.zeros((2, n, hps.nhidden), dtype=np.float32)
for step in range(0, ceil_round_step(maxlen, nsteps), nsteps):
start = step
end = step+nsteps
xsubseq = [x[start:end] for x in sorted_xs]
ndone = sum([x == b'' for x in xsubseq])
offset += ndone
xsubseq = xsubseq[ndone:]
sorted_xs = sorted_xs[ndone:]
nsubseq = len(xsubseq)
xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps)
for batch in range(0, nsubseq, nbatch):
start = batch
end = batch+nbatch
batch_smb = seq_rep(
xmb[start:end], mmb[start:end],
smb[:, offset+start:offset+end, :])
smb[:, offset+start:offset+end, :] = batch_smb
features = smb[0, unsort_idxs, :]
print('%0.3f seconds to transform %d examples' %
(time.time() - tstart, n))
return features
def cell_transform(xs, indexes=None):
Fs = []
xs = [preprocess(x) for x in xs]
for xmb in tqdm(
iter_data(xs, size=hps.nbatch), ncols=80, leave=False,
total=len(xs)//hps.nbatch):
smb = np.zeros((2, hps.nbatch, hps.nhidden))
n = len(xmb)
xmb, mmb = batch_pad(xmb, hps.nbatch, hps.nsteps)
smb = sess.run(cells, {X: xmb, S: smb, M: mmb})
smb = smb[:, :n, :]
if indexes is not None:
smb = smb[:, :, indexes]
Fs.append(smb)
Fs = np.concatenate(Fs, axis=1).transpose(1, 0, 2)
return Fs
def generate_sequence(x_start, override={}, sampling = 0, len_add = '.'):
len_start = len(x_start)
x = bytearray(preprocess(x_start))
string_terminate = isinstance(len_add, str)
len_end = (-1 if string_terminate else (len_start + len_add))
ndone = 0
last_chr = chr(x[-1])
smb = np.zeros((2, 1, hps.nhidden))
while True if string_terminate else ndone <= len_end:
xsubseq = x[ndone:ndone+nsteps]
ndone += len(xsubseq)
xmb, mmb = batch_pad([xsubseq], 1, nsteps)
#Override salient neurons
for neuron, value in override.items():
smb[:, :, neuron] = value
if ndone <= len_start:
#Prime hidden state with full steps
smb = sess.run(states, {X: xmb, S: smb, M: mmb})
else:
#Incrementally add characters
outs, smb = sess.run([logits, states], {X: xmb, S: smb, M: mmb})
out = outs[-1]
#Do uniform weighted sampling always or only after ' '
if (sampling == 1 and last_chr == ' ') or sampling == 2:
squashed = np.exp(out) / np.sum(np.exp(out), axis=0)
last_chr = chr(np.random.choice(len(squashed), p=squashed))
else:
last_chr = chr(np.argmax(out))
x.append(ord(last_chr))
if string_terminate and (last_chr in len_add):
len_add = len_add.replace(last_chr, "", 1)
if len(len_add) == 0:
break
return(x.decode())
self.transform = transform
self.cell_transform = cell_transform
self.generate_sequence = generate_sequence
with torch.no_grad():
bias_audio = waveglow.infer(mel_input, sigma=0.0).float()
bias_spec, _ = self.stft.transform(bias_audio)
self.register_buffer('bias_spec', bias_spec[:, :, 0][:, :, None])
def forward(self, audio, strength=0.1):
audio_spec, audio_angles = self.stft.transform(audio.cuda().float())
audio_spec_denoised = audio_spec - self.bias_spec * strength
audio_spec_denoised = torch.clamp(audio_spec_denoised, 0.0)
audio_denoised = self.stft.inverse(audio_spec_denoised, audio_angles)
return audio_denoised
if __name__ == '__main__':
config = HParams()
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(config)
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
waveglow_path = 'waveglow_256channels.pt'
waveglow = torch.load(waveglow_path)['model']
waveglow.cuda().eval().half()
for k in waveglow.convinv:
k.float()
denoiser = Denoiser(waveglow)
text = "相对论直接和间接的催生了量子力学的诞生 也为研究微观世界的高速运动确立了全新的数学模型"
import time
import numpy as np
import torch
from tqdm import tqdm
import config
from models.models import Tacotron2
from utils import text_to_sequence, HParams
if __name__ == '__main__':
checkpoint = 'tacotron2-cn.pt'
print('loading model: {}...'.format(checkpoint))
model = Tacotron2(HParams())
model.load_state_dict(torch.load(checkpoint))
model = model.to('cpu')
model.eval()
filename = config.validation_files
with open(filename, 'r') as file:
lines = file.readlines()
num_samples = len(lines)
print('num_samples: ' + str(num_samples))
elapsed = 0
# Batches
for line in tqdm(lines):
tokens = line.strip().split('|')
text = tokens[1]
sequence = np.array(text_to_sequence(text))[None, :]
def __init__(self, nbatch=128, nsteps=64):
global hps
hps = HParams(
load_path='model_params/params.jl',
nhidden=4096,
nembd=64,
nsteps=nsteps,
nbatch=nbatch,
nstates=2,
nvocab=256,
out_wn=False,
rnn_wn=True,
rnn_type='mlstm',
embd_wn=True,
)
global params
params = [np.load('model/%d.npy' % i) for i in range(15)]
params[2] = np.concatenate(params[2:6], axis=1)
params[3:6] = []
#print("n steps is", hps.nsteps);
X = tf.placeholder(tf.int32, [None, hps.nsteps])
M = tf.placeholder(tf.float32, [None, hps.nsteps, 1])
S = tf.placeholder(tf.float32, [hps.nstates, None, hps.nhidden])
cells, states, logits = model(X, S, M, reuse=False)
sess = tf.Session()
tf.global_variables_initializer().run(session=sess)
def seq_rep(xmb, mmb, smb):
return sess.run(states, {X: xmb, M: mmb, S: smb})
def seq_cells(xmb, mmb, smb):
return sess.run(cells, {X: xmb, M: mmb, S: smb})
def transform(xs, track_indices=[]):
tstart = time.time()
xs = [preprocess(x) for x in xs]
lens = np.asarray([len(x) for x in xs])
#print lens
sorted_idxs = np.argsort(lens)
unsort_idxs = np.argsort(sorted_idxs)
sorted_xs = [xs[i] for i in sorted_idxs]
maxlen = np.max(lens)
offset = 0
n = len(xs)
smb = np.zeros((2, n, hps.nhidden), dtype=np.float32)
track_indices_values = [[] for i in range(len(track_indices))]
rounded_steps = ceil_round_step(maxlen, nsteps)
#print "rounded_steps", rounded_steps
#print "maxlen", maxlen
for step in range(0, rounded_steps, nsteps):
start = step
end = step + nsteps
#print "start is", start, "and end is", end
xsubseq = [x[start:end] for x in sorted_xs]
ndone = sum([x == b'' for x in xsubseq])
offset += ndone
xsubseq = xsubseq[ndone:]
sorted_xs = sorted_xs[ndone:]
nsubseq = len(xsubseq)
#print "nsubseq is", nsubseq
xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps, 'post')
#print "xmb is", xmb
#print "iterating through each batch for step", step
for batch in range(0, nsubseq, nbatch):
start = batch
end = batch + nbatch
#print "scanning from", start, "to", end
#print "xmb - ", xmb[start:end], xmb.shape
batch_smb = seq_rep(xmb[start:end], mmb[start:end],
smb[:, offset + start:offset + end, :])
#print "batch_smb", batch_smb, batch_smb.shape, batch_smb[0][0][2388], batch_smb[1][0][2388]
#smb[:, offset+start:offset+end, :] = batch_smb
batch_cells = seq_cells(
xmb[start:end], mmb[start:end],
smb[:, offset + start:offset + end, :])
smb[:, offset + start:offset + end, :] = batch_smb
#print "batch_cells len", len(batch_cells)
#print batch_cells[len(batch_cells)-1][0][2388]
#print batch_smb[0][0][2388]
#smb[0, offset+start:offset+end, :] = batch_cells[nsteps-1]
if len(track_indices):
#print "tracking sentiment..", batch_smb.shape, batch_cells.shape
for i, index in enumerate(track_indices):
#print "sentiment neuron values -- ", batch_cells[:,0,index]
track_indices_values[i].append(batch_cells[:, 0,
index])
#print "rounded_steps after", rounded_steps
#print "maxlen after", maxlen
if rounded_steps < maxlen:
start = rounded_steps
end = maxlen
#print "start is", start, "and end is", end
xsubseq = [x[start:end] for x in sorted_xs]
ndone = sum([x == b'' for x in xsubseq])
offset += ndone
xsubseq = xsubseq[ndone:]
sorted_xs = sorted_xs[ndone:]
nsubseq = len(xsubseq)
#print "xsubseq is", xsubseq
xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps, 'post')
#xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps)
#print "xmb is", xmb
#print "mmb is", mmb
#print "n subseq is", nsubseq
#print "nbatch is", nbatch
#print "iterating through each batch for step", step
for batch in range(0, nsubseq, nbatch):
start = batch
end = batch + nbatch
#print "scanning from", start, "to", end
batch_smb = seq_rep(xmb[start:end], mmb[start:end],
smb[:, offset + start:offset + end, :])
#print "batch_smb", batch_smb, batch_smb.shape, batch_smb[0][0][2388], batch_smb[1][0][2388]
#print "offset", offset, start, end
#smb[:, offset+start:offset+end, :] = batch_smb
batch_cells = seq_cells(
xmb[start:end], mmb[start:end],
smb[:, offset + start:offset + end, :])
smb[:, offset + start:offset + end, :] = batch_smb
#print "batch_cells", batch_cells.shape
#smb[0, offset+start:offset+end, :] = batch_cells[maxlen-rounded_steps-1]
#print "smb----", smb
if len(track_indices):
#print "tracking sentiment..", batch_smb.shape, batch_cells.shape
for i, index in enumerate(track_indices):
#print "sentiment neuron values -- ", batch_cells[:,0,index]
track_indices_values[i].append(batch_cells[:, 0,
index])
#print "done with batch iteration"
#print "unsort_idxs", unsort_idxs
#print smb.shape
features = smb[0, unsort_idxs, :]
print('%0.3f seconds to transform %d examples' %
(time.time() - tstart, n))
return features, track_indices_values
def cell_transform(xs, indexes=None):
Fs = []
xs = [preprocess(x) for x in xs]
for xmb in tqdm(iter_data(xs, size=hps.nbatch),
ncols=80,
leave=False,
total=len(xs) // hps.nbatch):
smb = np.zeros((2, hps.nbatch, hps.nhidden))
n = len(xmb)
xmb, mmb = batch_pad(xmb, hps.nbatch, hps.nsteps)
smb = sess.run(cells, {X: xmb, S: smb, M: mmb})
smb = smb[:, :n, :]
if indexes is not None:
smb = smb[:, :, indexes]
Fs.append(smb)
Fs = np.concatenate(Fs, axis=1).transpose(1, 0, 2)
return Fs
self.transform = transform
self.cell_transform = cell_transform
def generate_sequence(x_start, override={}, sampling=0, len_add='.'):
"""Continue a given sequence.
Args:
x_start (string): The string to be continued.
override (dict): Values of the hidden state to override
with keys of the dictionary as index.
sampling (int): 0 greedy argmax, 2 weighted random from probabilty
distribution, 1 weighted but only once after each word.
len_add (int, string, None):
If int, the number of characters to be added.
If string, returns after each contained character was seen once.
Returns:
The completed string including transformation and paddings from preprocessing.
"""
len_start = len(x_start)
x_preprocessed = preprocess(x_start)
x = bytearray(x_preprocessed)
string_terminate = isinstance(len_add, str)
len_end = (-1 if string_terminate else (len_start + len_add))
ndone = 0
last_chr = chr(x[-1])
smb = np.zeros((2, 1, hps.nhidden))
while True if string_terminate else ndone <= len_end:
xsubseq = x[ndone:ndone + nsteps]
ndone += len(xsubseq)
xmb, mmb = batch_pad([xsubseq], 1, nsteps)
#Override salient neurons
for neuron, value in override.items():
smb[:, :, neuron] = value
if ndone <= len_start:
#Prime hidden state with full steps
smb = sess.run(states, {X: xmb, S: smb, M: mmb})
else:
#Incrementally add characters
outs, smb = sess.run([logits, states], {
X: xmb,
S: smb,
M: mmb
})
out = outs[-1]
#Do uniform weighted sampling always or only after ' '
if (sampling == 1 and last_chr == ' ') or sampling == 2:
squashed = np.exp(out) / np.sum(np.exp(out), axis=0)
last_chr = chr(
np.random.choice(len(squashed), p=squashed))
else:
last_chr = chr(np.argmax(out))
x.append(ord(last_chr))
if string_terminate and (last_chr in len_add):
len_add = len_add.replace(last_chr, "", 1)
if len(len_add) == 0:
break
return (x.decode())
self.transform = transform
self.cell_transform = cell_transform
self.generate_sequence = generate_sequence
def main():
DEVICE = torch.device('cuda')
CPU = torch.device('cpu')
input_path = './testing_TIMIT_noisy/train.txt'
print('input_path: {}'.format(input_path))
path_checkpoint = "./checkpoint/STAM_weights_4_1.0.pth" # 断点路径
print('loading checkpoint: {}'.format(path_checkpoint))
with open(input_path, encoding='utf-8') as f:
metadata = [line.strip().split('|') for line in f]
noises = ['airport', 'babble', 'car', 'exhibition', 'restaurant', 'street', 'subway', 'train']
snrs = ['SNR(-5)_', 'SNR(00)_', 'SNR(05)_', 'SNR(10)_']
# snrs = ['SNR(-10)_', 'SNR(-15)_']
# snrs = ['SNR(-20)_', 'SNR(-25)_']
aucs = []
features = []
F1 = []
DCF = []
ACC = []
PRECISION = []
for snr in snrs:
for noise in noises:
features.append(snr + noise)
gc.collect()
torch.cuda.empty_cache()
hparams = HParams()
model = VAD(hparams).to(DEVICE)
checkpoint = torch.load(path_checkpoint)
model.load_state_dict(checkpoint['model'])
with torch.no_grad():
model.eval()
TN = 0
TP = 0
FP = 0
FN = 0
for feature in tqdm(features):
labels = []
vads = []
count = 0
test_meta = [meta for meta in metadata if feature in meta[0]]
test_dataset = SpeechDataset(input_path, test_meta, hparams)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, num_workers=4, pin_memory=True)
for train_data, train_label in test_loader:
count += 1
train_data = train_data[0]
train_label = train_label[0]
train_data = torch.as_tensor(train_data, dtype=torch.float32).to(DEVICE)
label = train_label[:, int(np.floor(int(2 * (hparams.w - 1) / hparams.u + 3) / 2))]
midnet_output, postnet_output, alpha = model(train_data)
_, vad = bdnn_prediction(F.sigmoid(postnet_output).cpu().detach().numpy(), w=hparams.w, u=hparams.u)
vads = np.concatenate((vads, vad[:, 0]), axis=None)
labels = np.concatenate((labels, label), axis=None)
fpr, tpr, _ = metrics.roc_curve(labels, vads, pos_label=1)
auc = metrics.auc(fpr, tpr)
aucs.append(auc)
A = confusion_matrix(np.int8(labels), np.int8(vads.round()))
TN += A[0][0]
FN += A[1][0]
FP += A[0][1]
TP += A[1][1]
f1 = 2 * A[1][1] / (2 * A[1][1] + A[0][1] + A[1][0])
dcf = (0.75 * A[1][0] + 0.25 * A[0][1]) / sum(sum(A))
acc = (A[0][0] + A[1][1]) / sum(sum(A))
precision = A[1][1] / (A[1][1] + A[0][1])
ACC.append(acc)
PRECISION.append(precision)
F1.append(f1)
DCF.append(dcf)
print('[{}]: AUC: {:.2f}, F1-score: {:.2f}, DCF: {:.2f}, acc: {:.2f}, precision: {:.2f}'.format(
feature, auc * 100, f1 * 100, dcf * 100, acc * 100, precision * 100))
gc.collect()
torch.cuda.empty_cache()
for i in range(len(features)):
print('[{}]: AUC: {:.2f}, F1-score: {:.2f}, DCF: {:.2f}, acc: {:.2f}, precision: {:.2f}'.format(
features[i], aucs[i]*100, F1[i]*100, DCF[i]*100, ACC[i]*100, PRECISION[i]*100))
print('Global AUC: {:.2f}, F1-score: {:.2f}, DCF: {:.2f}, acc: {:.2f}, precision: {:.2f}'.format(
np.mean(aucs)*100, (2*TP / (2*TP+FN+FP))*100, ((0.75*FN+0.25*FP) / (TN+TP+FN+FP))*100,
(TP+TN)/(TN+TP+FN+FP)*100, TP/(TP+FP)*100))
import torch
import torch.nn as nn
import torch.nn.functional as F
from utils import HParams
hparamas = HParams()
class spec_conv(nn.Module):
def __init__(self, hparamas=None):
super(spec_conv, self).__init__()
self.layers = hparamas.layers # 4
self.filter_width = hparamas.filter_width
self.conv_channels = hparamas.conv_channels
self.conv_layers1 = nn.ModuleList()
self.conv_layers2 = nn.ModuleList()
self.batch_norm = nn.ModuleList()
self.sigmoid = nn.Sigmoid()
self.max_pool2d = nn.ModuleList()
for layer in range(self.layers):
if layer == 0:
self.conv_layers1.append(
nn.Conv2d(in_channels=1,
out_channels=self.conv_channels * (2**layer),
kernel_size=self.filter_width,
padding=(1, 1)))
self.conv_layers2.append(
nn.Conv2d(in_channels=1,
out_channels=self.conv_channels * (2**layer),
kernel_size=self.filter_width,
padding=(1, 1)))
def __init__(self, nbatch=128, nsteps=64):
global hps
hps = HParams(
load_path=project_path + 'model_params/params.jl',
nhidden=4096,
nembd=64,
nsteps=nsteps,
nbatch=nbatch,
nstates=2,
nvocab=256,
out_wn=False,
rnn_wn=True,
rnn_type='mlstm',
embd_wn=True,
)
global params
params = [
np.load(project_path + 'model/%d.npy' % i) for i in range(15)
]
params[2] = np.concatenate(params[2:6], axis=1)
params[3:6] = []
X = tf.placeholder(tf.int32, [None, hps.nsteps])
M = tf.placeholder(tf.float32, [None, hps.nsteps, 1])
S = tf.placeholder(tf.float32, [hps.nstates, None, hps.nhidden])
cells, states, logits = model(X, S, M, reuse=False)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
tf.global_variables_initializer().run(session=sess)
def seq_rep(xmb, mmb, smb):
return sess.run(states, {X: xmb, M: mmb, S: smb})
def transform(xs):
# tstart = time.time()
xs = [preprocess(x) for x in xs]
lens = np.asarray([len(x) for x in xs])
sorted_idxs = np.argsort(lens)
unsort_idxs = np.argsort(sorted_idxs)
sorted_xs = [xs[i] for i in sorted_idxs]
maxlen = 260 # np.max(lens)
offset = 0
n = len(xs)
smb = np.zeros((2, n, hps.nhidden), dtype=np.float32)
for step in range(0, ceil_round_step(maxlen, nsteps), nsteps):
sent_step_start = step
sent_step_end = step + nsteps
xsubseq = [x[sent_step_start:sent_step_end] for x in sorted_xs]
ndone = sum([x == b'' for x in xsubseq])
offset += ndone
xsubseq = xsubseq[ndone:]
sorted_xs = sorted_xs[ndone:]
nsubseq = len(xsubseq)
xmb, mmb = batch_pad(xsubseq, nsubseq, nsteps)
# for i in range(0, nsubseq):
# smb[:, offset+i:offset+i+1, :] = seq_rep(
# xmb[i:i+1], mmb[i:i+1],
# smb[:, offset+i:offset+i+1, :])
for batch in range(0, nsubseq, nbatch):
batch_st = batch
batch_end = batch + nbatch
batch_smb = seq_rep(
xmb[batch_st:batch_end], mmb[batch_st:batch_end],
smb[:, offset + batch_st:offset + batch_end, :])
smb[:, offset + batch_st:offset + batch_end, :] = batch_smb
features = smb[0, unsort_idxs, :]
# print('%0.3f seconds to transform %d examples' %
# (time.time() - tstart, n))
return features
self.transform = transform
"epoch": e + 1,
'step': start_step,
'scheduler_lr': scheduler._rate,
'scheduler_step': scheduler._step
}
if not os.path.isdir("./checkpoint"):
os.mkdir("./checkpoint")
torch.save(
checkpoint, './checkpoint/weights_{}_acc_{:.2f}.pth'.format(
e + 1, test_acc * 100))
return train_losses, test_losses
if __name__ == '__main__':
RESUME = True
hparams = HParams()
metadata_filename = './training_data/train.txt'
metadata, training_idx, validation_idx = train_valid_split(
metadata_filename, hparams, test_size=0.05, seed=0)
train_dataset = SpeechDataset(metadata_filename,
list(np.array(metadata)[training_idx]),
hparams)
test_dataset = SpeechDataset(metadata_filename,
list(np.array(metadata)[validation_idx]),
hparams)
train_loader = DataLoader(train_dataset,
1,
True,
num_workers=4,
pin_memory=False)
def main():
parser = argparse.ArgumentParser()
# Required Parameters
parser.add_argument(
"--data_dir",
default=None,
type=str,
required=True,
help=
"The input data dir. Should contain the .tsv files (or other data files) for the task."
)
parser.add_argument("--model_type",
default=None,
type=str,
help="bert OR lstm",
required=True)
parser.add_argument(
"--output_dir",
default=None,
type=str,
required=True,
help=
"The output_result directory where the model predictions will be written."
)
parser.add_argument("--output_mode",
default="regression",
type=str,
help="classification or regression",
required=True)
parser.add_argument("--domain",
default="celtrion",
type=str,
help="celtrion",
required=True)
parser.add_argument("--target",
default="close",
type=str,
help="close, open, volume",
required=True)
# Other Parameters
parser.add_argument("--use_gpu",
help="use gpu=True or False",
default=True)
parser.add_argument("--learning_rate",
default=5e-5,
type=float,
help="The initial learning rate for Adam.")
parser.add_argument("--num_train_epochs",
default=3.0,
type=float,
help="Total number of training epochs to perform.")
parser.add_argument("--per_gpu_train_batch_size",
default=8,
type=int,
help="Batch size per GPU/CPU for classifier.")
parser.add_argument("--per_gpu_eval_batch_size",
default=8,
type=int,
help="Batch size per GPU/CPU for classifier.")
parser.add_argument("--do_train",
action='store_true',
help="Whether to run training.")
parser.add_argument("--do_eval",
action='store_true',
help="Whether to run eval.")
parser.add_argument("--window_size",
default=50,
type=int,
help="window size for lstm")
args = parser.parse_args()
# use GPU ?
if not is_gpu_available():
args.use_gpu = False
# Model
model_type = args.model_type
output_mode = args.output_mode
# data
data_root = args.data_dir
# output
output_root = args.output_dir
prepare_dir(output_root)
fns = {
'input': {
'train': os.path.join(data_root, 'train.csv'),
'test': os.path.join(data_root, 'test.csv')
},
'output': {
# 'csv' : os.path.join() # 필요시에 ~~
},
'model': os.path.join(output_root, 'model.out')
}
# Train
if args.do_train:
hps = HParams(
# domain -------------------------------------------
domain=args.domain,
target=args.target,
# gpu setting ----------------------------------------
use_gpu=args.use_gpu,
# train settings ----------------------------------------
learning_rate=args.learning_rate,
num_train_epochs=args.num_train_epochs,
per_gpu_train_batch_size=args.per_gpu_train_batch_size,
window_size=args.window_size,
# model settings ----------------------------------------
model_type=model_type,
output_mode=output_mode)
hps.show()
print("*********** Start Training ***********")
run_train(fns['input']['train'], fns['model'], hps)
if args.do_eval:
print("*********** Start Evaluating ***********")
batch_size = args.per_gpu_eval_batch_size
run_eval(fns['input']['test'], fns['model'], batch_size)
