def load_data():
print("==> loading train data")
data_path = os.path.join(args.dataset_dir,
'train_data' + args.modality + '.npy')
label_path = os.path.join(args.dataset_dir, 'train_label.pkl')
valid_frame_path = os.path.join(args.dataset_dir, 'train_num_frame.npy')
train_loader = torch.utils.data.DataLoader(
dataset=Feeder(data_path,
label_path,
valid_frame_path,
normalization=args.normalization,
ftrans=args.ftrans),
batch_size=args.batch_size,
shuffle=True,
num_workers=4,
)
print("==> loading test data")
data_path = os.path.join(args.dataset_dir,
'test_data' + args.modality + '.npy')
label_path = os.path.join(args.dataset_dir, 'test_label.pkl')
valid_frame_path = os.path.join(args.dataset_dir, 'test_num_frame.npy')
test_loader = torch.utils.data.DataLoader(
dataset=Feeder(data_path,
label_path,
valid_frame_path,
normalization=args.normalization,
ftrans=args.ftrans),
batch_size=args.batch_size,
shuffle=True,
num_workers=4,
)
return (train_loader, test_loader)
def lambda_handler(event, context):
id = context.aws_request_id
logger.info('started lambda_handler with id %s' % id)
feeder = Feeder(event['url'])
while not feeder.done():
time.sleep(Config.sleep_interval)
return "finished lambda_handler with id %s" % id
def POST(self):
auth = web.ctx.env.get('HTTP_AUTHORIZATION')
authreq = False
if auth is None:
authreq = True
else:
auth = re.sub('^Basic ', '', auth)
username, password = base64.decodestring(auth).split(':')
if (username, password) in allowed:
web.header('Content-Type', 'application/json')
data = json.loads(web.data())
feedTime = data["time"]
feed = Feeder(float(feedTime))
result = feed.feed()
successDate = feed.getDate()
jsonResponse = {'result': result, 'date': successDate}
return json.dumps(jsonResponse)
else:
authreq = True
if authreq:
web.header('WWW-Authenticate', 'Basic realm="Cat Feeder"')
web.ctx.status = '401 Unauthorized'
return
def robotInit(self):
super().__init__()
# Instances of classes
# Instantiate Subsystems
#XXX DEBUGGING
self.drivetrain = Drivetrain(self)
self.shooter = Shooter(self)
self.carrier = Carrier(self)
self.feeder = Feeder(self)
self.intake = Intake(self)
#self.winch = Winch(self)
#self.climber = Climber(self)
#self.climber_big = Climber_Big(self)
#self.climber_little = Climber_Little(self)
# Instantiate Joysticks
self.left_joy = wpilib.Joystick(1)
self.right_joy = wpilib.Joystick(2)
# Instantiate Xbox
self.xbox = wpilib.Joystick(3)
# Instantiate OI; must be AFTER joysticks are inited
self.oi = OI(self)
self.timer = wpilib.Timer()
def simulate(in_runs, in_pairs, in_visitors):
target = [ [2,2,0],[2,2,1],[2,2,2] ]
genes = [ [1,1,0],[1,2,0],[2,0,0],[2,1,0] ] # simulating t110 x t110
probs = [ 4/9, 2/9, 1/9, 2/9 ] # 25/12.5/6.25/12.5
genemap = len(probs)
pairs_results = []
turtle_results = []
for run in range(in_runs):
turtle_day = -1
pairs_day = -1
turtle = Field("turtle", turtle_layout)
pairs = Field("pairs", pairs_layout)
pairer = PairBreeder()
feeder = Feeder(genes, probs, visit=in_visitors, pairs=in_pairs)
for day in range(1, 365):
# get the days flowers
feed = feeder.feed()
# print("day",day,feed)
# check for output from the pairer, put them into the pairs field
for new_pair in pairer.breed():
pairs.place(new_pair[0], new_pair[1])
# add the day's feed into the pairer and the turtle
for new_flower in feed:
pairer.place(new_flower)
turtle.place(new_flower)
# everything above this point technically "runs" the day before
# run the fields
if pairs_day == -1:
harvest = pairs.run()
# print("pairs:", pairs_harvest)
for flower in harvest:
if flower.get_genes() in target:
pairs_day = day
if turtle_day == -1:
harvest = turtle.run()
# print("turtle:", turtle_harvest)
for flower in harvest:
if flower.get_genes() in target:
turtle_day = day
# break out if they both finish
if turtle_day != -1 and pairs_day != -1:
break
if turtle_day != -1 and pairs_day != -1:
# print("run", run, "ended on day", day, "turtle", turtle_day, "pairs", pairs_day)
pairs_results.append(pairs_day)
turtle_results.append(turtle_day)
print("{}\t{}\tpairs\t{}\t{}\t{}\t{}\t{}".format(in_visitors, in_pairs, np.amin(pairs_results), np.amax(pairs_results), np.mean(pairs_results), np.median(pairs_results), np.percentile(pairs_results, 95)))
print("{}\t{}\tturtle\t{}\t{}\t{}\t{}\t{}".format(in_visitors, in_pairs, np.amin(turtle_results), np.amax(turtle_results), np.mean(turtle_results), np.median(turtle_results), np.percentile(turtle_results, 95)))
return
def lambda_handler(event, context):
id = context.aws_request_id
logger.info('started lambda_handler with id %s' % id)
monitor = Monitor(event['query_url'], event['access_id'],
event['access_key'])
while not monitor.done():
time.sleep(Config.sleep_interval)
logger.info('finished monitor query')
feeder = Feeder(event['send_url'], event['deployment'],
monitor.performance)
feeder.send()
logger.info('finished monitor send')
return "finished lambda_handler with id %s" % id
def main():
try:
if( os.path.exists('feed.xml') ):
os.remove('feed_old.xml')
os.rename('feed.xml', 'feed_old.xml')
download(uri='https://inside.teu.ac.jp/feed/', file_name='feed.xml')
except Exception as e:
save_log(message=e)
sys.exit(1)
fresh_feed = feedparser.parse(r'feed.xml')
saved_feed = feedparser.parse(r'feed_old.xml')
print('[ok] Success to parse feed*.xml')
if( has_argv(check_name="--offline") ):
print("[info] Offline mode is enabled. Not downlaod feed from remote.")
feeder = Feeder()
feeder.set(parsed_feed=saved_feed)
feeder.show(items=['title', 'uri'])
sys.exit(0)
feeder = {'fresh': Feeder(), 'saved': Feeder()}
feeder['fresh'].set(parsed_feed=fresh_feed)
feeder['saved'].set(parsed_feed=saved_feed)
print('[ok] Success to set parsed_data')
new_entries = Feeder.fetch_diff(target=feeder['fresh'].get(), base=feeder['saved'].get())
# debug:: print(str(new_entries))
if(len(new_entries) < 1):
save_log('[info] update was not found.')
sys.exit(0)
print('[ok] Success to fetch difference between fresh and saved')
for entry in new_entries:
print(entry["title"])
body = entry['title'] + ' (' + entry['date'] + ')\n' + entry['uri'] + '\n'
Feeder.notify_discord(message=body)
time.sleep(3)
def load_input_data():
print("==> loading train data")
data_path = os.path.join(args.dataset_dir, 'train_data.npy')
label_path = os.path.join(args.dataset_dir, 'train_label.pkl')
valid_frame_path = os.path.join(args.dataset_dir, 'train_num_frame.npy')
train_feeder = Feeder(data_path,
label_path,
valid_frame_path,
normalization=args.normalization,
ftrans=args.ftrans,
reshape=True)
print("==> loading test data")
data_path = os.path.join(args.dataset_dir, 'test_data.npy')
label_path = os.path.join(args.dataset_dir, 'test_label.pkl')
valid_frame_path = os.path.join(args.dataset_dir, 'test_num_frame.npy')
test_feeder = Feeder(data_path,
label_path,
valid_frame_path,
normalization=args.normalization,
ftrans=args.ftrans,
reshape=True)
return (train_feeder, test_feeder)
def _add_fecther(self, fetcher):
logger.debug("add a fether %s" % str(fetcher))
name = fetcher.name
if name in self.feeders:
logger.warning("fetcher %s in already in." % name)
if self.feeders[name].addr != fetcher.addr:
logger.error("fetcher %s has old addr %s, an new is %s" %
(name, self.feeders[name].addr, fetcher.addr))
self.feeders[name].reset(fetcher.addr)
self.dao.update_fetcher(fetcher)
else:
logger.info("add a fetcher %s with addr %s" % (name, fetcher.addr))
self.feeders[name] = Feeder(name, fetcher.addr)
self.dao.add_fetcher(fetcher)
def main():
feeder = Feeder(schedule=None)
# main app loop
while True:
# check if button is pressed
if random.random() < 0.01:
feeder.button_is_pressed = True
# update and check schedule
feeder.update()
# now sleep for a second so the loop doesn't run needlesly often
time.sleep(1)
def __init__(self, storage, marshaller, feeder_port, matching_engine_port,
uptime_in_seconds):
self.logger = logging.getLogger(__name__)
self.storage = storage
self.feeder = Feeder(marshaller=marshaller, port=feeder_port)
self.matching_engine = MatchingEngine(
storage=self.storage,
referential=self.feeder.get_referential(),
marshaller=marshaller,
port=matching_engine_port)
self.start_time = None
self.stop_time = None
if uptime_in_seconds:
self.start_time = time.time()
self.stop_time = self.start_time + uptime_in_seconds
def __init__(self,
storage: AbstractStorage,
client_authentication: bool,
marshaller,
feeder_port: int,
matching_engine_port: int,
uptime_in_seconds: Optional[int]):
self.storage = storage
self.client_authentication = client_authentication
self.feeder = Feeder(marshaller=marshaller, port=feeder_port)
self.matching_engine = MatchingEngine(self.storage, client_authentication, marshaller, port=matching_engine_port)
self.matching_engine.initialize_order_books(referential=self.feeder.get_referential())
self.start_time = None
self.stop_time = None
if uptime_in_seconds:
self.start_time = time.time()
self.stop_time = self.start_time + uptime_in_seconds
def load_train_data():
print("==> loading train data")
data_path = os.path.join(args.dataset_dir, 'all_data.npy')
label_path = os.path.join(args.dataset_dir, 'all_label.pkl')
valid_frame_path = os.path.join(args.dataset_dir, 'all_num_frame.npy')
train_loader = torch.utils.data.DataLoader(
dataset=Feeder(data_path,
label_path,
valid_frame_path,
normalization=args.normalization,
ftrans=args.ftrans,
reshape=True),
batch_size=args.batch_size,
shuffle=True,
num_workers=4,
)
return train_loader
def __init__(self, opt):
self.opt = opt
if opt.path_load is not None and (opt.path_load.endswith('.yaml') or opt.path_load.endswith('.yml')):
self._model = JointScorer(opt)
else:
self._model = Scorer(opt)
if opt.path_load is not None:
self._model.load(opt.path_load)
self.parallel()
if opt.task != 'play':
if opt.fld_data is not None:
self.feeder = Feeder(opt)
if opt.task == 'train':
opt.save()
os.makedirs(opt.fld_out + '/ckpt', exist_ok=True)
self.path_log = self.opt.fld_out + '/log.txt'
else:
self.path_log = self.opt.fld_out + '/log_infer.txt'
Created on 16 Sep 2017
@author: pingshiyu
'''
from PIL import Image
import numpy as np
from feeder import Feeder
from scipy.misc import toimage
# for debug purposes
def to_2d_image(array):
'''
1d flattened array of a square image, converted to image object
Returns the image object
'''
side_length = int(np.sqrt(array.size))
np_2d_arr = np.reshape(array, (side_length, side_length))
return Image.fromarray(np_2d_arr, 'L')
if __name__ == '__main__':
data = Feeder('./data/cleanData.csv')
xs, ys = data.next_batch(10)
for x, y in zip(xs, ys):
toimage(np.reshape(x, (45, 45))).show()
print(y)
wait = input('')
model = DenseNet(growth_rate=32,
block_config=(6, 12, 24, 16),
num_init_features=64,
bn_size=4,
drop_rate=0.3,
num_classes=args.num_classes)
# model = Wide_ResNet(16, 8, 0.3, args.num_classes)
if args.cuda:
model = model.cuda()
print('cuda_weights')
if not os.path.isdir(args.save_dir):
os.mkdir(args.save_dir)
train_dl = torch.utils.data.DataLoader(dataset=Feeder(
args.train_folder_path),
batch_size=32,
shuffle=True,
num_workers=4,
drop_last=True)
test_dl = torch.utils.data.DataLoader(dataset=Feeder(args.test_folder_path,
is_training=False),
batch_size=16,
shuffle=False,
num_workers=1,
drop_last=False)
test_sensitive_dl = torch.utils.data.DataLoader(dataset=Feeder(
args.test_folder_path, is_training=False, target_index=0),
batch_size=16,
def main(args):
eval_fn = os.path.join(args.model_dir, 'eval-detailed.txt')
assert os.path.exists(args.model_dir), 'Model dir does not exist.'
assert args.overwrite or not os.path.exists(
eval_fn), 'Evaluation file already exists.'
os.environ["CUDA_VISIBLE_DEVICES"] = "%d" % args.gpu
print '\n' + '=' * 30 + ' ARGUMENTS ' + '=' * 30
params = myutils.load_params(args.model_dir)
for k, v in params.__dict__.iteritems():
print 'TRAIN | {}: {}'.format(k, v)
for k, v in args.__dict__.iteritems():
print 'EVAL | {}: {}'.format(k, v)
sys.stdout.flush()
DURATION = 0.1
BATCH_SIZE = 16
with tf.device('/cpu:0'), tf.variable_scope('feeder'):
feeder = Feeder(params.db_dir,
subset_fn=args.subset_fn,
ambi_order=params.ambi_order,
audio_rate=params.audio_rate,
video_rate=params.video_rate,
context=params.context,
duration=DURATION,
return_video=VIDEO in params.encoders,
img_prep=myutils.img_prep_fcn(),
return_flow=FLOW in params.encoders,
frame_size=(224, 448),
queue_size=BATCH_SIZE * 5,
n_threads=4,
for_eval=True)
batches = feeder.dequeue(BATCH_SIZE)
ambix_batch = batches['ambix']
video_batch = batches['video'] if VIDEO in params.encoders else None
flow_batch = batches['flow'] if FLOW in params.encoders else None
audio_mask_batch = batches['audio_mask']
ss = int(params.audio_rate * params.context) / 2
t = int(params.audio_rate * DURATION)
audio_input = ambix_batch[:, :, :params.ambi_order**2]
audio_target = ambix_batch[:, ss:ss + t, params.ambi_order**2:]
print '\n' + '=' * 20 + ' MODEL ' + '=' * 20
sys.stdout.flush()
with tf.device('/gpu:0'):
# Model
num_sep = params.num_sep_tracks if params.separation != NO_SEPARATION else 1
net_params = SptAudioGenParams(
sep_num_tracks=num_sep,
ctx_feats_fc_units=params.context_units,
loc_fc_units=params.loc_units,
sep_freq_mask_fc_units=params.freq_mask_units,
sep_fft_window=params.fft_window)
model = SptAudioGen(ambi_order=params.ambi_order,
audio_rate=params.audio_rate,
video_rate=params.video_rate,
context=params.context,
sample_duration=DURATION,
encoders=params.encoders,
separation=params.separation,
params=net_params)
# Inference
pred_t = model.inference_ops(audio=audio_input,
video=video_batch,
flow=flow_batch,
is_training=False)
# Losses and evaluation metrics
with tf.variable_scope('metrics'):
w_t = audio_input[:, ss:ss + t]
_, stft_dist_ps, lsd_ps, mse_ps, snr_ps = model.evaluation_ops(
pred_t,
audio_target,
w_t,
mask_channels=audio_mask_batch[:, params.ambi_order**2:])
# Loader
vars2save = [
v for v in tf.global_variables()
if not v.op.name.startswith('metrics')
]
saver = tf.train.Saver(vars2save)
print '\n' + '=' * 30 + ' VARIABLES ' + '=' * 30
model_vars = tf.global_variables()
import numpy as np
for v in model_vars:
if 'Adam' in v.op.name.split('/')[-1]:
continue
print ' * {:50s} | {:20s} | {:7s} | {:10s}'.format(
v.op.name, str(v.get_shape()), str(np.prod(v.get_shape())),
str(v.dtype))
print '\n' + '=' * 30 + ' EVALUATION ' + '=' * 30
sys.stdout.flush()
config = tf.ConfigProto(allow_soft_placement=True,
gpu_options=tf.GPUOptions(allow_growth=True))
with tf.Session(config=config) as sess:
print 'Loading model...'
sess.run(model.init_ops)
saver.restore(sess, tf.train.latest_checkpoint(args.model_dir))
print 'Initializing data feeders...'
coord = tf.train.Coordinator()
tf.train.start_queue_runners(sess, coord)
feeder.start_threads(sess)
all_metrics = [
'amplitude/predicted', 'amplitude/gt', 'mse/avg', 'mse/X', 'mse/Y',
'mse/Z', 'stft/avg', 'stft/X', 'stft/Y', 'stft/Z', 'lsd/avg',
'lsd/X', 'lsd/Y', 'lsd/Z', 'mel_lsd/avg', 'mel_lsd/X', 'mel_lsd/Y',
'mel_lsd/Z', 'snr/avg', 'snr/X', 'snr/Y', 'snr/Z', 'env_mse/avg',
'env_mse/X', 'env_mse/Y', 'env_mse/Z', 'emd/dir', 'emd/dir2'
]
metrics = OrderedDict([(key, []) for key in all_metrics])
sample_ids = []
telapsed = deque(maxlen=20)
print 'Start evaluation...'
it = -1
# run_options = tf.RunOptions(timeout_in_ms=60*1000)
while True:
it += 1
if feeder.done(sess):
break
start_time = time.time()
outs = sess.run([
batches['id'], audio_mask_batch, w_t, audio_target, pred_t,
stft_dist_ps, lsd_ps, mse_ps, snr_ps
])
video_id, layout, mono, gt, pred = outs[:5]
gt_m = np.concatenate(
(mono, gt), axis=2) * layout[:, np.newaxis, :]
pred_m = np.concatenate(
(mono, pred), axis=2) * layout[:, np.newaxis, :]
stft_dist, lsd, mse, snr = outs[5:]
_env_time = 0.
_emd_time = 0.
_pow_time = 0.
_lsd_time = 0.
for smp in range(BATCH_SIZE):
metrics['stft/avg'].append(np.mean(stft_dist[smp]))
for i, ch in zip(range(3), 'YZX'):
metrics['stft/' + ch].append(stft_dist[smp, i])
metrics['lsd/avg'].append(np.mean(lsd[smp]))
for i, ch in zip(range(3), 'YZX'):
metrics['lsd/' + ch].append(lsd[smp, i])
metrics['mse/avg'].append(np.mean(mse[smp]))
for i, ch in zip(range(3), 'YZX'):
metrics['mse/' + ch].append(mse[smp, i])
metrics['snr/avg'].append(np.nanmean(snr[smp]))
for i, ch in zip(range(3), 'YZX'):
metrics['snr/' + ch].append(snr[smp, i])
# Compute Mel LSD distance
_t = time.time()
mel_lsd = myutils.compute_lsd_dist(pred[smp], gt[smp],
params.audio_rate)
metrics['mel_lsd/avg'].append(np.mean(mel_lsd))
for i, ch in zip(range(3), 'YZX'):
metrics['mel_lsd/' + ch].append(mel_lsd[i])
_lsd_time += (time.time() - _t)
# Compute envelope distances
_t = time.time()
env_mse = myutils.compute_envelope_dist(pred[smp], gt[smp])
metrics['env_mse/avg'].append(np.mean(env_mse))
for i, ch in zip(range(3), 'YZX'):
metrics['env_mse/' + ch].append(env_mse[i])
_env_time += (time.time() - _t)
# Compute EMD (for speed, only compute emd over first 0.1s of every 1sec)
_t = time.time()
emd_dir, emd_dir2 = ambix_emd(pred_m[smp],
gt_m[smp],
model.snd_rate,
ang_res=30)
metrics['emd/dir'].append(emd_dir)
metrics['emd/dir2'].append(emd_dir2)
_emd_time += (time.time() - _t)
# Compute chunk power
_t = time.time()
metrics['amplitude/gt'].append(np.abs(gt[smp]).max())
metrics['amplitude/predicted'].append(np.abs(pred[smp]).max())
_pow_time += (time.time() - _t)
sample_ids.append(video_id[smp])
telapsed.append(time.time() - start_time)
#print '\nTotal:', telapsed[-1]
#print 'Env:', _env_time
#print 'LSD:', _lsd_time
#print 'EMD:', _emd_time
#print 'POW:', _pow_time
if it % 100 == 0:
# Store evaluation metrics
with open(eval_fn, 'w') as f:
f.write('SampleID | {}\n'.format(' '.join(metrics.keys())))
for smp in range(len(sample_ids)):
f.write('{} | {}\n'.format(
sample_ids[smp], ' '.join(
[str(metrics[key][smp]) for key in metrics])))
if it % 5 == 0:
stats = OrderedDict([(m, np.mean(metrics[m]))
for m in all_metrics])
myutils.print_stats(stats.values(),
stats.keys(),
BATCH_SIZE,
telapsed,
it,
tag='EVAL')
sys.stdout.flush()
# Print progress
stats = OrderedDict([(m, np.mean(metrics[m])) for m in all_metrics])
myutils.print_stats(stats.values(),
stats.keys(),
BATCH_SIZE,
telapsed,
it,
tag='EVAL')
sys.stdout.flush()
with open(eval_fn, 'w') as f:
f.write('SampleID | {}\n'.format(' '.join(metrics.keys())))
for smp in range(len(sample_ids)):
f.write('{} | {}\n'.format(
sample_ids[smp],
' '.join([str(metrics[key][smp]) for key in metrics])))
print('\n' + '#' * 60)
print('End of evaluation.')
from feeder import Feeder
from datetime import datetime, timedelta
datetime_object = datetime.strptime(Feeder.getDate(), '%Y-%m-%d %H:%M:%S')
if datetime_object < datetime.now() - timedelta(hours=4):
feed = Feeder()
feed.feed()
from params import *
from feeder import Feeder
from model import GAN
################################
# Main
################################
if __name__ == '__main__':
# Create and train the GAN
model = GAN(noise_dim=NOISE_DIM,
image_dim=IMAGE_DIM,
name='gan',
debug=False)
feed = Feeder(IMAGES_BASE_FOLDER, LABEL_BASE_FOLDER, batch_size=BATCH_SIZE)
model.train(feed, epochs=EPOCHS)
# Save submission
with ZipFile(OUTPUT_ZIP_NAME, 'w') as zip:
batch_size = 100
num_batches = int(10000 / batch_size)
for idx_batch in tqdm(range(num_batches), desc='Writing test images'):
images_gen = (
model.generate(num_images=batch_size, seed=idx_batch + 1) *
255).astype(np.uint8)
for idx_image, image_gen in enumerate(images_gen):
image_name = '{}.png'.format((idx_batch + 1) * batch_size +
idx_image)
cv2.imwrite(image_name, image_gen)
zip.write(image_name)
def main(args):
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu)
if not os.path.exists(args.model_dir):
os.makedirs(args.model_dir)
print('\n' + '=' * 30 + ' ARGUMENTS ' + '=' * 30)
sys.stdout.flush()
if args.resume:
params = myutils.load_params(args.model_dir)
args.encoders = params.encoders
args.separation = params.separation
args.ambi_order = params.ambi_order
args.audio_rate = params.audio_rate
args.video_rate = params.video_rate
args.context = params.context
args.sample_dur = params.sample_dur
else:
myutils.save_params(args)
myutils.print_params(args)
# Feeder
min_t = min([args.context, args.sample_dur, 1. / args.video_rate])
args.video_rate = int(1. / min_t)
with tf.device('/cpu:0'), tf.variable_scope('feeder'):
feeder = Feeder(args.db_dir,
subset_fn=args.subset_fn,
ambi_order=args.ambi_order,
audio_rate=args.audio_rate,
video_rate=args.video_rate,
context=args.context,
duration=args.sample_dur,
return_video=VIDEO in args.encoders,
img_prep=myutils.img_prep_fcn(),
return_flow=FLOW in args.encoders,
frame_size=(224, 448),
queue_size=args.batch_size * 5,
n_threads=4,
for_eval=False)
batches = feeder.dequeue(args.batch_size)
ambix_batch = batches['ambix']
video_batch = batches['video'] if 'video' in args.encoders else None
flow_batch = batches['flow'] if 'flow' in args.encoders else None
audio_mask_batch = batches['audio_mask']
t = int(args.audio_rate * args.sample_dur)
ss = int(args.audio_rate * args.context) / 2
n_chann_in = args.ambi_order**2
audio_input = ambix_batch[:, :, :n_chann_in]
audio_target = ambix_batch[:, ss:ss + t, n_chann_in:]
print('\n' + '=' * 20 + ' MODEL ' + '=' * 20)
sys.stdout.flush()
with tf.device('/gpu:0'):
# Model
num_sep = args.num_sep_tracks if args.separation != NO_SEPARATION else 1
params = SptAudioGenParams(sep_num_tracks=num_sep,
ctx_feats_fc_units=args.context_units,
loc_fc_units=args.loc_units,
sep_freq_mask_fc_units=args.freq_mask_units,
sep_fft_window=args.fft_window)
model = SptAudioGen(ambi_order=args.ambi_order,
audio_rate=args.audio_rate,
video_rate=args.video_rate,
context=args.context,
sample_duration=args.sample_dur,
encoders=args.encoders,
separation=args.separation,
params=params)
ambix_pred = model.inference_ops(audio=audio_input,
video=video_batch,
flow=flow_batch,
is_training=True)
# Losses and evaluation metrics
print(audio_mask_batch)
with tf.variable_scope('metrics'):
metrics_t, _, _, _, _ = model.evaluation_ops(
ambix_pred,
audio_target,
audio_input[:, ss:ss + t],
mask_channels=audio_mask_batch[:, args.ambi_order**2:])
step_t = tf.Variable(0, trainable=False, name='step')
with tf.variable_scope('loss'):
loss_t = model.loss_ops(metrics_t, step_t)
losses_t = {l: loss_t[l] for l in loss_t}
regularizers = tf.get_collection(
tf.GraphKeys.REGULARIZATION_LOSSES)
if regularizers and 'regularization' in losses_t:
losses_t['regularization'] = tf.add_n(regularizers)
losses_t['total_loss'] = tf.add_n(losses_t.values())
# Optimizer
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.variable_scope('optimization') and tf.control_dependencies(
update_ops):
train_op, lr_t = myutils.optimize(losses_t['total_loss'], step_t,
args)
# Initialization
rest_ops = model.init_ops
init_op = [
tf.global_variables_initializer(),
tf.local_variables_initializer()
]
saver = tf.train.Saver(max_to_keep=1)
# Tensorboard
metrics_t['training_loss'] = losses_t['total_loss']
metrics_t['queue'] = feeder.queue_state
metrics_t['lr'] = lr_t
myutils.add_scalar_summaries(metrics_t.values(), metrics_t.keys())
summary_ops = tf.summary.merge(
tf.get_collection(tf.GraphKeys.SUMMARIES))
summary_writer = tf.summary.FileWriter(args.model_dir, flush_secs=30)
#summary_writer.add_graph(tf.get_default_graph())
print('\n' + '=' * 30 + ' VARIABLES ' + '=' * 30)
model_vars = tf.global_variables()
import numpy as np
for v in model_vars:
if 'Adam' in v.op.name.split('/')[-1]:
continue
print(' * {:50s} | {:20s} | {:7s} | {:10s}'.format(
v.op.name, str(v.get_shape()), str(np.prod(v.get_shape())),
str(v.dtype)))
print('\n' + '=' * 30 + ' TRAINING ' + '=' * 30)
sys.stdout.flush()
config = tf.ConfigProto(allow_soft_placement=True,
gpu_options=tf.GPUOptions(allow_growth=True))
with tf.Session(config=config) as sess:
print('Initializing network...')
sess.run(init_op)
if rest_ops:
sess.run(rest_ops)
print('Initializing data feeders...')
coord = tf.train.Coordinator()
tf.train.start_queue_runners(sess, coord)
feeder.start_threads(sess)
tf.get_default_graph().finalize()
# Restore model
init_step = 0
if args.resume:
print('Restoring previously saved model...')
ckpt = tf.train.latest_checkpoint(args.model_dir)
if ckpt:
saver.restore(sess, ckpt)
init_step = sess.run(step_t)
try:
print('Start training...')
duration = deque(maxlen=20)
for step in range(init_step, args.n_iters):
start_time = time.time()
if step % 20 != 0:
sess.run(train_op)
else:
outs = sess.run(
[train_op, summary_ops, losses_t['total_loss']] +
losses_t.values() + metrics_t.values())
if math.isnan(outs[2]):
raise ValueError(
'Training produced a NaN metric or loss.')
duration.append(time.time() - start_time)
if step % 20 == 0: # Print progress to terminal and tensorboard
myutils.print_stats(outs[3:],
losses_t.keys() + metrics_t.keys(),
args.batch_size,
duration,
step,
tag='TRAIN')
summary_writer.add_summary(outs[1], step)
sys.stdout.flush()
if step % 5000 == 0 and step != 0: # Save checkpoint
saver.save(sess,
args.model_dir + '/model.ckpt',
global_step=step_t)
print('=' * 60 + '\nCheckpoint saved\n' + '=' * 60)
except Exception, e:
print(str(e))
finally:
# model = ResNet(Bottleneck, layers=[3, 4, 6, 3], num_classes=args.num_classes)
# model = Inception3(num_classes=10, aux_logits=False)
model = DenseNet(growth_rate=32, block_config=(6, 12, 24, 16),
num_init_features=64, bn_size=4, drop_rate=0.3, num_classes=args.num_classes)
# model = Wide_ResNet(16, 8, 0.3, args.num_classes)
if args.cuda:
model = model.cuda()
print('cuda_weights')
if not os.path.isdir(args.save_dir):
os.mkdir(args.save_dir)
train_dl = torch.utils.data.DataLoader(dataset=Feeder(args.train_folder_path),
batch_size=32,
shuffle=True,
num_workers=4,
drop_last=True)
test_dl = torch.utils.data.DataLoader(dataset=Feeder(args.test_folder_path, is_training=False),
batch_size=16,
shuffle=False,
num_workers=1,
drop_last=False)
test_nothot_dl = torch.utils.data.DataLoader(dataset=Feeder(args.test_folder_path, is_training=False, target_index=0),
batch_size=16,
shuffle=False,
if __name__ == '__main__':
args = parse_args()
model = DenseNet(growth_rate=32, block_config=(6, 12, 24, 16),
num_init_features=64, bn_size=4, drop_rate=0.3, num_classes=args.num_classes)
if args.cuda:
model = model.cuda()
print('cuda_weights')
if not os.path.isdir(args.save_dir):
os.mkdir(args.save_dir)
train_dl = torch.utils.data.DataLoader(dataset=Feeder(args.train_folder_path),
batch_size=16,
shuffle=True,
num_workers=1,
drop_last=True)
test_dl = torch.utils.data.DataLoader(dataset=Feeder(args.test_folder_path, is_training=False),
batch_size=16,
shuffle=False,
num_workers=1,
drop_last=False)
if args.mode == 'train':
xyz = np.zeros(s)
unit_z = np.zeros_like(xyz[..., 0])
unit_z[..., 2] = 1
for i in range(1, len(self.dfs)):
joint = self.dfs[i]
parent = self.parents[joint]
if parent != -1:
v = q_rotate(q[..., joint], unit_z)
xyz[...,
joint] = normalize(v) * bone_lens[joint] + xyz[..., parent]
return xyz
if __name__ == '__main__':
import ntu_info
sk = Skeleton(parents=ntu_info.PARENTS)
print(sk.children)
from feeder import Feeder
train_data_path = '/home/xuan/data/NTU-RGB-D/xyz/xsub/train_data.npy'
train_label_path = '/home/xuan/data/NTU-RGB-D/xyz/xsub/train_label.pkl'
train_data = Feeder(train_data_path,
train_label_path,
num_samples=-1,
num_frames=20,
mmap=True)
xyz, _ = train_data[0]
xyz = xyz[:, 0, :]
print(xyz.shape)
print(sk.compute_bone_lens(xyz))
def train(log_dir, args, hparams, use_hvd=False):
if use_hvd:
import horovod.tensorflow as hvd
# Initialize Horovod.
hvd.init()
else:
hvd = None
eval_dir, eval_plot_dir, eval_wav_dir, meta_folder, plot_dir, save_dir, tensorboard_dir, wav_dir = init_dir(
log_dir)
checkpoint_path = os.path.join(save_dir, 'centaur_model.ckpt')
input_path = os.path.join(args.base_dir, args.input_dir)
log('Checkpoint path: {}'.format(checkpoint_path))
log('Loading training data from: {}'.format(input_path))
log('Using model: {}'.format(args.model))
log(hparams_debug_string())
# Start by setting a seed for repeatability
tf.set_random_seed(hparams.random_seed)
# Set up data feeder
coord = tf.train.Coordinator()
with tf.variable_scope('datafeeder'):
feeder = Feeder(coord, input_path, hparams)
# Set up model:
global_step = tf.Variable(0, name='global_step', trainable=False)
model, stats = model_train_mode(feeder, hparams, global_step, hvd=hvd)
eval_model = model_test_mode(feeder, hparams)
# Embeddings metadata
char_embedding_meta = os.path.join(meta_folder, 'CharacterEmbeddings.tsv')
if not os.path.isfile(char_embedding_meta):
with open(char_embedding_meta, 'w', encoding='utf-8') as f:
for symbol in symbols:
if symbol == ' ':
symbol = '\\s' # For visual purposes, swap space with \s
f.write('{}\n'.format(symbol))
char_embedding_meta = char_embedding_meta.replace(log_dir, '..')
# Book keeping
step = 0
time_window = ValueWindow(100)
loss_window = ValueWindow(100)
saver = tf.train.Saver(max_to_keep=2)
log('Centaur training set to a maximum of {} steps'.format(
args.train_steps))
# Memory allocation on the GPU as needed
config = tf.ConfigProto()
config.allow_soft_placement = True
config.gpu_options.allow_growth = True
if use_hvd:
config.gpu_options.visible_device_list = str(hvd.local_rank())
# Train
with tf.Session(config=config) as sess:
try:
# Init model and load weights
sess.run(tf.global_variables_initializer())
sess.run(tf.local_variables_initializer())
sess.run(tf.tables_initializer())
# saved model restoring
if args.restore:
# Restore saved model if the user requested it, default = True
restore_model(saver, sess, global_step, save_dir,
checkpoint_path, args.reset_global_step)
else:
log('Starting new training!', slack=True)
saver.save(sess, checkpoint_path, global_step=global_step)
# initializing feeder
start_step = sess.run(global_step)
feeder.start_threads(sess, start_step=start_step)
# Horovod bcast vars across workers
if use_hvd:
# Horovod: broadcast initial variable states from rank 0 to all other processes.
# This is necessary to ensure consistent initialization of all workers when
# training is started with random weights or restored from a checkpoint.
bcast = hvd.broadcast_global_variables(0)
bcast.run()
log('Worker{}: Initialized'.format(hvd.rank()))
# Training loop
summary_writer = tf.summary.FileWriter(tensorboard_dir, sess.graph)
while not coord.should_stop() and step < args.train_steps:
start_time = time.time()
step, loss, opt = sess.run(
[global_step, model.loss, model.train_op])
if use_hvd:
main_process = hvd.rank() == 0
if main_process:
time_window.append(time.time() - start_time)
loss_window.append(loss)
message = 'Step {:7d} [{:.3f} sec/step, loss={:.5f}, avg_loss={:.5f}]'.format(
step, time_window.average, loss, loss_window.average)
log(message,
end='\r',
slack=(step % args.checkpoint_interval == 0))
if np.isnan(loss) or loss > 100.:
log('Loss exploded to {:.5f} at step {}'.format(
loss, step))
raise Exception('Loss exploded')
if step % args.summary_interval == 0:
log('\nWriting summary at step {}'.format(step))
summary_writer.add_summary(sess.run(stats), step)
if step % args.eval_interval == 0:
run_eval(args, eval_dir, eval_model, eval_plot_dir,
eval_wav_dir, feeder, hparams, sess, step,
summary_writer)
if step % args.checkpoint_interval == 0 or step == args.train_steps or step == 300:
save_current_model(args, checkpoint_path, global_step,
hparams, loss, model, plot_dir,
saver, sess, step, wav_dir)
if step % args.embedding_interval == 0 or step == args.train_steps or step == 1:
update_character_embedding(char_embedding_meta,
save_dir, summary_writer)
log('Centaur training complete after {} global steps!'.format(
args.train_steps),
slack=True)
return save_dir
except Exception as e:
log('Exiting due to exception: {}'.format(e), slack=True)
traceback.print_exc()
coord.request_stop(e)
# for NNs
import tensorflow as tf
# pre-made custom layers
from tensorflow_layers import fc_layer, conv_layer, flatten_2d
# constants:
CLASSES = 24
IMG_SIZE = 40
IMG_SIZE_FLAT = IMG_SIZE * IMG_SIZE
TRAIN_BATCH_SIZE = 128
MODELNUM = 3
TENSORBOARD_DIR = './tmp/{}/'.format(MODELNUM)
# load in the data saved in './data/warped_40x40/warped_data_240k.csv'
data = Feeder(file_path='./data/warped_40x40/warped_data_240k.csv',
classes=CLASSES)
def feed_dict(train=True, all_test_data=False):
'''
Return the feed_dict for train or testing mode (since it is called a lot)
``all_test_data`` returns all of the testing data, which may be slow to
evaluate.
'''
if train:
xs, ys = data.next_batch(TRAIN_BATCH_SIZE)
p = 0.5
# here we use testing data, but do we use ``all_test_data``?
elif not all_test_data:
xs, ys = (data.test[0])[:500], (data.test[1])[:500]
p = 1.0
def _load_fetchers(self):
"""Load fetchers from db when start"""
fetchers = self.dao.load_fetchers()
for fetcher in fetchers:
self.feeders[fetcher.name] = Feeder(fetcher.name, fetcher.addr)
logger.info("load %s fetchers from db." % len(self.feeders))
def main():
# Hyperparameters
parser = argparse.ArgumentParser()
# in_dir = ~/wav
parser.add_argument("--in_dir",
type=str,
required=True,
help="input data(pickle) dir")
parser.add_argument(
"--ckpt_dir",
type=str,
required=True,
help="checkpoint to save/ start with for train/inference")
parser.add_argument("--mode",
default="train",
choices=["train", "test", "infer"],
help="setting mode for execution")
# Saving Checkpoints, Data... etc
parser.add_argument("--max_step",
type=int,
default=500000,
help="maximum steps in training")
parser.add_argument("--checkpoint_freq",
type=int,
default=100,
help="how often save checkpoint")
# Data
parser.add_argument("--segment_length",
type=float,
default=1.6,
help="segment length in seconds")
parser.add_argument("--spectrogram_scale",
type=int,
default=40,
help="scale of the input spectrogram")
# Ininitialization
parser.add_argument("--init_type",
type=str,
default="uniform",
help="type of initializer")
parser.add_argument("--init_weight_range",
type=float,
default=0.1,
help="initial weight ranges from -0.1 to 0.1")
# Optimization
parser.add_argument("--loss_type",
default="softmax",
choices=["softmax", "contrast"],
help="loss type for optimization")
parser.add_argument("--optimizer",
type=str,
default="sgd",
help="type of optimizer")
parser.add_argument("--learning_rate",
type=float,
default=0.01,
help="learning rate")
parser.add_argument("--l2_norm_clip",
type=float,
default=3.0,
help="L2-norm of gradient is clipped at")
# Train
parser.add_argument("--num_spk_per_batch",
type=int,
default=64,
help="N speakers of batch size N*M")
parser.add_argument("--num_utt_per_batch",
type=int,
default=10,
help="M utterances of batch size N*M")
# LSTM
parser.add_argument("--lstm_proj_clip",
type=float,
default=0.5,
help="Gradient scale for projection node in LSTM")
parser.add_argument("--num_lstm_stacks",
type=int,
default=3,
help="number of LSTM stacks")
parser.add_argument("--num_lstm_cells",
type=int,
default=768,
help="number of LSTM cells")
parser.add_argument("--dim_lstm_projection",
type=int,
default=256,
help="dimension of LSTM projection")
# Scaled Cosine similarity
parser.add_argument(
"--scale_clip",
type=float,
default=0.01,
help="Gradient scale for scale values in scaled cosine similarity")
# Collect hparams
args = parser.parse_args()
# Set up Queue
global_queue = queue.Queue()
# Set up Feeder
libri_feeder = Feeder(args, "train", "libri")
libri_feeder.set_up_feeder(global_queue)
vox1_feeder = Feeder(args, "train", "vox1")
vox1_feeder.set_up_feeder(global_queue)
vox2_feeder = Feeder(args, "train", "vox2")
vox2_feeder.set_up_feeder(global_queue)
# Set up Model
model = GE2E(args)
graph = model.set_up_model("train")
# Training
with graph.as_default():
saver = tf.train.Saver()
with tf.Session(graph=graph) as sess:
train_writer = tf.summary.FileWriter(args.ckpt_dir, sess.graph)
ckpt = tf.train.get_checkpoint_state(args.ckpt_dir)
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
print('Restoring Variables from {}'.format(
ckpt.model_checkpoint_path))
saver.restore(sess, ckpt.model_checkpoint_path)
start_step = sess.run(model.global_step)
else:
print('start from 0')
init_op = tf.global_variables_initializer()
sess.run(init_op)
start_step = 1
for num_step in range(start_step, args.max_step + 1):
print("current step: " + str(num_step) + "th step")
batch = global_queue.get()
summary, training_loss, _ = sess.run(
[model.sim_mat_summary, model.total_loss, model.optimize],
feed_dict={
model.input_batch: batch[0],
model.target_batch: batch[1]
})
train_writer.add_summary(summary, num_step)
print("batch loss:" + str(training_loss))
if num_step % args.checkpoint_freq == 0:
save_path = saver.save(sess,
args.ckpt_dir + "/model.ckpt",
global_step=model.global_step)
print("model saved in file: %s / %d th step" %
(save_path, sess.run(model.global_step)))
def main():
# Hyperparameters
parser = argparse.ArgumentParser()
# Path
# wav name formatting: id_clip_uttnum.wav
parser.add_argument("--in_dir", type=str, required=True, help="input dir")
parser.add_argument("--out_dir", type=str, required=True, help="out dir")
parser.add_argument("--batch_inference",
action="store_true",
help="set whether to use the batch inference")
parser.add_argument("--dataset", type=str, default="libri", help="out dir")
parser.add_argument("--in_wav1", type=str, help="input wav1 dir")
parser.add_argument("--in_wav2",
default="temp.wav",
type=str,
help="input wav2 dir")
#/home/hdd2tb/ninas96211/dev_wav_set
parser.add_argument("--mode",
default="infer",
choices=["train", "test", "infer"],
help="setting mode for execution")
parser.add_argument("--ckpt_file",
type=str,
default='./xckpt/model.ckpt-58100',
help="checkpoint to start with for inference")
# Data
#parser.add_argument("--window_length", type=int, default=160, help="sliding window length(frames)")
parser.add_argument("--segment_length",
type=float,
default=1.6,
help="segment length in seconds")
parser.add_argument("--overlap_ratio",
type=float,
default=0.5,
help="overlaping percentage")
parser.add_argument("--spectrogram_scale",
type=int,
default=40,
help="scale of the input spectrogram")
# Enrol
parser.add_argument("--num_spk_per_batch",
type=int,
default=5,
help="N speakers of batch size N*M")
parser.add_argument("--num_utt_per_batch",
type=int,
default=10,
help="M utterances of batch size N*M")
# LSTM
parser.add_argument("--num_lstm_stacks",
type=int,
default=3,
help="number of LSTM stacks")
parser.add_argument("--num_lstm_cells",
type=int,
default=768,
help="number of LSTM cells")
parser.add_argument("--dim_lstm_projection",
type=int,
default=256,
help="dimension of LSTM projection")
parser.add_argument('--gpu', default='0', help='Path to model checkpoint')
parser.add_argument('--gpu_num',
default=4,
help='Path to model checkpoint')
# Collect hparams
args = parser.parse_args()
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
feeder = Feeder(args)
feeder.set_up_feeder()
model = GE2E(args)
graph = model.set_up_model()
#Training
with graph.as_default():
saver = tf.train.Saver()
#num_gpu=4
#sess_arr=[]
#for i in range(num_gpu):
# gpu_options = tf.GPUOptions(visible_device_list=str(i))
# sess_arr.append(tf.Session(graph=graph, config=tf.ConfigProto(gpu_options=gpu_options)))
# saver.restore(sess_arr[i], args.ckpt_file)
# t = Thread(target=worker)
# t.daemon = True
# t.start()
# save_dvector_of_dir_parallel(sess_arr, feeder, model, args)
with tf.Session(graph=graph) as sess:
# restore from checkpoints
saver.restore(sess, args.ckpt_file)
#get_dvector_of_dir(sess, feeder, model, args)
t = Thread(target=worker)
t.daemon = True
t.start()
save_dvector_of_dir_parallel(sess, feeder, model, args)
def train(self):
coord = tf.train.Coordinator()
self.data_generator = Feeder(coord, args)
self.validation_data_generator = self.data_generator
self.lr = tf.train.exponential_decay(args.lr, self.global_step,
args.lr_decay_steps,
args.lr_decay_rate)
self.lr = tf.minimum(tf.maximum(self.lr, 0.0000001), 0.001)
self.optimizer = tf.train.AdamOptimizer(learning_rate=self.lr)
self.grad = self.optimizer.compute_gradients(self.loss,
var_list=self.t_vars)
self.op = self.optimizer.apply_gradients(self.grad,
global_step=self.global_step)
varset = list(set(tf.global_variables()) | set(tf.local_variables()))
self.saver = tf.train.Saver(var_list=varset, max_to_keep=5)
num_batch = self.data_generator.n_examples // args.batch_size
do_initialzie = True
if args.loading_path:
if self.load():
start_epoch = self.global_step.eval() // num_batch
do_initialzie = False
else:
print("Error Loading Model! Training From Initial State...")
if do_initialzie:
init_op = tf.global_variables_initializer()
start_epoch = 0
self.sess.run(init_op)
self.writer = tf.summary.FileWriter(args.summary_dir, None)
with tf.name_scope("summaries"):
self.s_logdet_loss = tf.summary.scalar('logdet_loss',
self.logdet_loss)
self.s_logs_loss = tf.summary.scalar('logs_loss', self.logs_loss)
self.s_prior_loss = tf.summary.scalar('prior_loss',
self.prior_loss)
self.s_loss = tf.summary.scalar('total_loss', self.loss)
self.merged = tf.summary.merge([
self.s_logdet_loss, self.s_logs_loss, self.s_prior_loss,
self.s_loss
])
# self.procs = self.data_generator.start_enqueue()
# self.val_procs = self.validation_data_generator.start_enqueue()
# self.procs += self.val_procs
self.data_generator.start(self.sess)
self.sample(0)
try:
for epoch in range(start_epoch, args.epoch):
clr = self.sess.run(self.lr)
print("Current learning rate: %.6e" % clr)
loss_names = [
"Total Loss", "LogS Loss", "LogDet Loss", "Prior Loss"
]
buffers = buff(loss_names)
for batch in tqdm(range(num_batch)):
input_data = self.data_generator.dequeue()
feed_dict = dict(zip(self.placeholders, input_data))
_, loss, logs_loss, logdet_loss, prior_loss, summary, step = self.sess.run(
[
self.op, self.loss, self.logs_loss,
self.logdet_loss, self.prior_loss, self.merged,
self.global_step
],
feed_dict=feed_dict)
self.gate_add_summary(summary, step)
buffers.put([loss, logs_loss, logdet_loss, prior_loss],
[0, 1, 2, 3])
if (batch + 1) % args.display_step == 0:
buffers.printout([epoch + 1, batch + 1, num_batch])
if (epoch + 1) % args.saving_epoch == 0 and args.saving_path:
try:
self.save(epoch + 1)
except:
print("Failed saving model, maybe no space left...")
traceback.print_exc()
if (epoch + 1) % args.sample_epoch == 0 and args.sampling_path:
self.sample(epoch + 1)
except KeyboardInterrupt:
print("KeyboardInterrupt")
except:
traceback.print_exc()
finally:
'''
def main():
# Hyperparameters
parser = argparse.ArgumentParser()
# Path
# wav name formatting: id_clip_uttnum.wav
parser.add_argument("--test_dir",
type=str,
required=True,
help="input test dir")
#/home/hdd2tb/ninas96211/dev_wav_set
parser.add_argument("--ckpt_file",
type=str,
required=True,
help="checkpoint to start with for inference")
# Data
#parser.add_argument("--window_length", type=int, default=160, help="sliding window length(frames)")
parser.add_argument("--segment_length",
type=float,
default=1.6,
help="segment length in seconds")
parser.add_argument("--overlap_ratio",
type=float,
default=0.5,
help="overlaping percentage")
parser.add_argument("--spectrogram_scale",
type=int,
default=40,
help="scale of the input spectrogram")
# Enrol
parser.add_argument("--num_spk_per_batch",
type=int,
default=5,
help="N speakers of batch size N*M")
parser.add_argument("--num_utt_per_batch",
type=int,
default=10,
help="M utterances of batch size N*M")
# LSTM
parser.add_argument("--num_lstm_stacks",
type=int,
default=3,
help="number of LSTM stacks")
parser.add_argument("--num_lstm_cells",
type=int,
default=768,
help="number of LSTM cells")
parser.add_argument("--dim_lstm_projection",
type=int,
default=256,
help="dimension of LSTM projection")
# Total Score
# (Sum of True Scores) - (Sum of False Scores)
# if the model is perfect, the score will be num_of_true_pairs
# if the model really sucks, the score will be - num_of_false_pairs
# Collect hparams
args = parser.parse_args()
global_queue = queue.Queue()
feeder = Feeder(args, "test")
feeder.set_up_feeder(global_queue)
model = GE2E(args)
graph = model.set_up_model("test")
with graph.as_default():
saver = tf.train.Saver()
with tf.Session(graph=graph) as sess:
# restore from checkpoints
saver.restore(sess, args.ckpt_file)
total_score = 0
num_true_pairs = 0
num_false_pairs = 0
while len(feeder.wav_pairs) > 0:
wav1_data, wav2_data, match = global_queue.get()
wav1_out = sess.run(model.norm_out,
feed_dict={model.input_batch: wav1_data})
wav2_out = sess.run(model.norm_out,
feed_dict={model.input_batch: wav2_data})
wav1_dvector = np.mean(wav1_out, axis=0)
wav2_dvector = np.mean(wav2_out, axis=0)
final_score = np.dot(wav1_dvector, wav2_dvector) / (
np.linalg.norm(wav1_dvector) * np.linalg.norm(wav2_dvector))
print("final score:" + str(final_score))
print("same? :" + str(match))
if match == True:
total_score += final_score
num_true_pairs += 1
if match == False:
total_score -= final_score
num_false_pairs += 1
print("in total: " + str(total_score))
print("num true pairs: " + str(num_true_pairs))
print("num false pairs: " + str(num_false_pairs))
