def train_from_parser(parser):
"""
:param parser: ``ArgumentParser`` object
"""
parser.add_argument("--config", type=str, required=True)
parser.add_argument("--savedir", type=str, required=True)
args = parser.parse_args()
config = load_config(args.config)
serialization_dir = os.path.join(DATA_DIR, args.savedir)
if not os.path.exists(serialization_dir):
os.makedirs(serialization_dir)
def call_training_func(plugins):
for p in plugins:
p.on_before_call(config, serialization_dir)
# TODO(tomwesolowski): Add config overriding from params.
train_from_config(config=config, serialization_dir=serialization_dir)
for p in plugins:
p.on_after_call(config, serialization_dir)
run_with_redirection(os.path.join(serialization_dir, 'stdout.txt'),
os.path.join(serialization_dir, 'stderr.txt'),
call_training_func)([MetaSaver()])
def create_loss_functions(input_var, network, target_var, margin, scale):
config = load_config(None, join(get_common(), 'config.cfg'))
# define loss expression
train_prediction = lasagne.layers.get_output(network)
train_loss = cosface_loss(train_prediction, target_var, margin, scale)
test_prediction = lasagne.layers.get_output(network, deterministic=True)
test_loss = cosface_loss(test_prediction, target_var, margin, scale)
# define update expression for training
train_params = lasagne.layers.get_all_params(network, trainable=True)
train_updates = lasagne.updates.adadelta(
train_loss, train_params,
config.getfloat('pairwise_cosface', 'adadelta_learning_rate'),
config.getfloat('pairwise_cosface', 'adadelta_rho'),
config.getfloat('pairwise_cosface', 'adadelta_epsilon'))
test_class_predict = T.argmax(test_prediction)
# compile theano functions for training and validation/accuracy
train_fn = theano.function([input_var, target_var],
train_loss,
updates=train_updates)
val_fn = theano.function([input_var, target_var],
[test_loss, test_class_predict])
return train_fn, val_fn
def dump_from_args(args):
config = load_config(args.config)
rng = prepare_environment(config)
experiment = Experiment.from_config(config, rng=rng)
model = experiment.model
names, outputs = get_all_layer_outputs(model, experiment.streams.train)
save_outputs(args.savedir, names, outputs)
def setUp(self):
super(BuildTest, self).setUp()
self.TEST_FIXTURES_ROOT = self.FIXTURES_ROOT / "build"
self.files = {
"config": "esim-snli.json",
}
self.config = load_config(self.TEST_FIXTURES_ROOT /
self.files['config'])
def main():
length = 500
n_pairs = 50
cfg = load_config('..\\cfg.json')
dg = DataGatherer(cfg)
dg.video_catalog = get_catalog(length)
dg.pairs = get_pairs(dg.video_catalog, n_pairs)
sorted_catalog = dg.sort_by_pairs()
print sorted_catalog
def __init__(self, config_name=DEFAULT_CONFIG,
setup=DEFAULT_SETUP, networks=DEFAULT_NETWORKS, train=DEFAULT_TRAIN, test=DEFAULT_TEST,
plot=DEFAULT_PLOT, best=DEFAULT_BEST, dev=DEFAULT_DEV):
self.config_name = config_name
self.config = load_config(None, join(get_configs(), config_name + '.cfg'))
self.setup = setup
self.networks = networks
self.train = train
self.test = test
self.plot = plot
self.best = best
self.dev = dev
self.network_controllers = []
def create_net(self):
config = load_config(None, join(get_common(), 'config.cfg'))
model = Sequential()
model.add(Bidirectional(LSTM(self.n_hidden1, return_sequences=True), input_shape=self.input))
model.add(Dropout(0.50))
model.add(Bidirectional(LSTM(self.n_hidden2)))
model.add(Dense(self.n_classes * 10))
model.add(Dropout(0.25))
model.add(Dense(self.n_classes * 5))
model.add(Dense(self.n_classes))
model.add(Activation('softmax'))
adam = keras.optimizers.Adam(config.getfloat('pairwise_lstm', 'adam_lr'), config.getfloat('pairwise_lstm', 'adam_beta_1'), config.getfloat('pairwise_lstm', 'adam_beta_2'), config.getfloat('pairwise_lstm', 'adam_epsilon'), config.getfloat('pairwise_lstm', 'adam_decay'))
# ada = keras.optimizers.Adadelta(lr=1.0, rho=0.95, epsilon=1e-08, decay=0.0)
model.compile(loss=kld.pairwise_kl_divergence,
optimizer=adam,
metrics=['accuracy'])
return model
def _add_cluster_subplot(grid, position, y_label, colspan=1):
"""
Adds a cluster subplot to the current figure.
:param grid: a tuple that contains number of rows as the first entry and number of columns as the second entry
:param position: the position of this subplot
:param y_label: the label of the y axis
:param colspan: number of columns for the x axis, default is 1
:return: the subplot itself
"""
config = load_config(None, join(get_common(), 'config.cfg'))
plot_width = config.getint('common', 'plot_width')
subplot = plt.subplot2grid(grid, position, colspan=colspan)
subplot.set_ylabel(y_label)
subplot.set_xlabel('number of clusters')
subplot.set_xlim([-3, plot_width + 3])
subplot.set_ylim([-0.05, 1.05])
return subplot
:param test_size: size of test set. It must be a float between 0 and 1
:param random_state: random state / bean
:param shuffle: boolean that determines if data should be shuffled
:param stratify: If True, data is split in a stratified fashion
:return:
"""
train_x, test_x, train_y, test_y = \
self.get_train_test_split(test_size=test_size,
random_state=random_state,
shuffle=shuffle,
stratify=stratify)
self.save_train_test_sets(inputs=(train_x, test_x),
targets=(train_y, test_y),
names=('training', 'test'))
if __name__ == '__main__':
cfg = load_config('./conf/conf.yaml')
init_logger(cfg['logging'], cfg['logging']['name'])
prep = Preprocessor(cfg['data']['raw_path'],
cfg['preprocess']['criteria'],
cfg['data']['file_name_format'],
cfg['data']['classes_list'],
cfg['preprocess']['classes_ranges'],
cfg['preprocess']['dest_path'])
prep.run(test_size=cfg['preprocess']['test_size'],
random_state=cfg['preprocess']['random_state'],
shuffle=cfg['preprocess']['shuffle'],
stratify=True)
import numpy as np
import theano
import theano.tensor as T
import common.spectrogram.speaker_train_splitter as sts
from common.spectrogram.spectrogram_extractor import extract_spectrogram
from common.utils import pickler
from common.utils.paths import *
from common.utils.load_config import *
from . import network_factory as nf
from .objectives_clustering import create_loss_functions_kl_div
from ..core import analytics
from ..core.batch_iterators import SpectTrainBatchIterator, SpectValidBatchIterator
from common.spectrogram.speaker_dev_selector import get_sentences_for_speaker_index
config = load_config(None, join(get_common(), 'config.cfg'))
def create_and_train(num_epochs=1000, batch_size=100, epoch_batches=10, network_params_file_in=None,
network_params_file_out=None,
train_file=None,
network_fun=nf.create_network_10_speakers, with_validation=True):
# load training data
with open(train_file, 'rb') as f:
(X, y, speaker_names) = pickle.load(f)
# create symbolic theano variables
input_var = T.tensor4('inputs')
target_var = T.ivector('targets')
margin = T.scalar('margin')
# create network
import numpy as np
import torch
import zarr
from dask import delayed, compute
from dask.diagnostics import ProgressBar
from skimage.io import imread
from skimage.transform import resize
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
import common
from common.utils import extract_video_frames, load_config, load_cnn
load_config()
URL = 'https://cloud.xibalba.com.mx/s/swZKJGnSFqdBXj4/download'
SPLITS_URL = 'https://cloud.xibalba.com.mx/s/X248be2WBPwsbzM/download'
FILENAME = 'ucf101-videos.tar.gz'
SPLITS_FILENAME = 'ucf101-splits.tar.gz'
DATASETS_DIR = os.getenv('DATASETS_DIR')
DS_DIR = join(DATASETS_DIR, 'ucf101')
SPLITS_DIR = join(DS_DIR, 'splits')
VIDEOS_DIR = join(DS_DIR, 'videos')
FRAMES_DIR = join(DS_DIR, 'frames')
FPS = 24
NAME_PADDING = 3
RESNET_INPUT_SIZE = (224, 224)
REPS_2048_DIR = join(DS_DIR, 'resnet50_2048.zarr')
REPS_1024_DIR = join(DS_DIR, 'resnet50_1024.zarr')
REPS_0512_DIR = join(DS_DIR, 'resnet50_0512.zarr')
action='store_true',
help='NCHW Format, GPU only')
parser.add_argument('-ckpt',
dest='ckpt',
type=int,
help='Desired Checkpoint',
required=True)
parser.add_argument('-list',
dest='list',
type=int,
default=1,
help='Desired List to test. Default: List 1')
args = parser.parse_args()
cfg = load_config(path_master_config, args.config)
logger = get_logger('cluster', logging.INFO)
# Select List
if args.list == 1:
list = 'test_list1'
elif args.list == 2:
list = 'test_list2'
elif args.list == 3:
list = 'test_list3'
output_layer_name = cfg.get('test', 'output_layer')
# Output folder
output_layer_name_folder = output_layer_name.replace('/', '-')
def __init__(self, n_classes=100, regularizer=None, **kwargs):
super(CosFace, self).__init__(**kwargs)
config = load_config(None, join(get_common(), 'config.cfg'))
self.n_classes = config.getint('pairwise_lstm_cosface', 'n_classes')
self.regularizer = regularizer
def train_network(config, clear, debug, nchw):
# Read config
path_master_config = get_configs('master')
config = load_config(path_master_config, config)
flow_me = "flow_me"
flow_me_logs = get_experiment_logs(flow_me)
flow_me_nets = get_experiment_nets(flow_me)
if clear:
try:
shutil.rmtree(flow_me_logs)
except OSError:
pass
if debug:
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '0'
logger = get_logger('network', logging.DEBUG)
else:
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' # Filter warnings out
logger = get_logger('network', logging.INFO)
add_file_handler(logger, get_experiment_logs(flow_me, "training.log"))
if not check_config(config):
logger.critical('Config file {0} seems not valid.'.format(config.get('exp', 'name')))
logger.info('Check if logfiles already exists or cannot be deleted.')
sys.exit('Exit')
logger.info('Experiment: \t' + config.get('exp', 'name'))
logger.info('Description:\t' + config.get('exp', 'desc'))
# Set parameters for network for nhwc oder nchw
if nchw:
data_format = 'channels_first'
norm_axis = 1
shape_ph_input_data = (
None, 1, config.getint('spectrogram', 'frequency_elements'), config.getint('spectrogram', 'duration'))
else:
data_format = 'channels_last'
norm_axis = 3
shape_ph_input_data = (
None, config.getint('spectrogram', 'frequency_elements'), config.getint('spectrogram', 'duration'), 1)
logger.info("Starting to build Network")
# placeholder
with tf.name_scope('placeholders'):
ph_input_data = tf.placeholder(tf.float32, shape=shape_ph_input_data, name='input_data')
ph_map_labels = tf.placeholder(tf.int32, shape=(config.getint('net', 'batch_size')), name='map_labels')
ph_class_input_data = tf.placeholder(tf.float32, shape=(config.getint(
'train', 'total_speakers'), config.getfloat('net', 'dense10_factor') * config.getint('train',
'total_speakers')),
name='class_input_data')
ph_train_mode = tf.placeholder(tf.bool, shape=[], name='train_mode')
if debug:
tf.summary.histogram('input', ph_input_data)
if not nchw:
tf.summary.image('input_image', ph_input_data, max_outputs=3)
# L1: convolution (#32)
with tf.name_scope('l1_conv'):
l1 = tf.layers.conv2d(ph_input_data, filters=config.getint('net', 'conv1_filter'), kernel_size=[config.getint(
'net', 'conv_kernel'), config.getint('net', 'conv_kernel')], padding=config.get('net', 'conv_pad'),
data_format=data_format, activation=tf.nn.relu)
# L2: batch-norm
with tf.name_scope('l2_batch'):
if config.getboolean('net', 'norm_on'):
l2 = tf.layers.batch_normalization(l1, axis=norm_axis, epsilon=config.getfloat('net', 'norm_eps'),
momentum=config.getfloat('net', 'norm_mom'), training=ph_train_mode)
else:
l2 = l1
# L3: max-pooling (4x4)
with tf.name_scope('l3_max_pooling'):
l3 = tf.layers.max_pooling2d(inputs=l2, pool_size=[config.getint('net', 'pool_size'), config.getint(
'net', 'pool_size')], strides=config.getint('net', 'pool_strides'), data_format=data_format)
# L4: convolution (#64)
with tf.name_scope('l4_conv'):
l4 = tf.layers.conv2d(inputs=l3, filters=config.getint('net', 'conv4_filter'), kernel_size=[config.getint(
'net', 'conv_kernel'), config.getint('net', 'conv_kernel')], padding=config.get('net', 'conv_pad'),
data_format=data_format, activation=tf.nn.relu)
# L5: batch-norm
with tf.name_scope('l5_batch'):
if config.getboolean('net', 'norm_on'):
l5 = tf.layers.batch_normalization(l4, axis=norm_axis, epsilon=config.getfloat('net', 'norm_eps'),
momentum=config.getfloat('net', 'norm_mom'), training=ph_train_mode)
else:
l5 = l4
# L6: max-pooling (4x4)
with tf.name_scope('l6_max_pooling'):
l6 = tf.layers.max_pooling2d(inputs=l5, pool_size=[config.getint('net', 'pool_size'), config.getint(
'net', 'pool_size')], strides=config.getint('net', 'pool_strides'), data_format=data_format)
# L6: reshape after last conv
with tf.name_scope('l6_reshape'):
dim_flatted = int(np.prod(l6.shape[1:]))
l6 = tf.reshape(l6, [-1, dim_flatted])
# L7: dense
with tf.name_scope('l7_dense'):
l7 = tf.layers.dense(inputs=l6, units=(config.getfloat('net', 'dense7_factor') *
config.getint('train', 'total_speakers')), activation=tf.nn.relu)
# L8: batch-norm
with tf.name_scope('l8_batch'):
if config.getboolean('net', 'norm_on'):
l8 = tf.layers.batch_normalization(l7, axis=1, epsilon=config.getfloat('net', 'norm_eps'),
momentum=config.getfloat('net', 'norm_mom'), training=ph_train_mode)
else:
l8 = l7
# L9: dropout
with tf.name_scope('l9_dropout'):
l9 = tf.layers.dropout(inputs=l8, rate=config.getfloat('net', 'dropout_rate'), training=ph_train_mode)
# L10: dense
with tf.name_scope('l10_dense'):
l10 = tf.layers.dense(inputs=l9, units=(config.getfloat('net', 'dense10_factor') *
config.getint('train', 'total_speakers')), activation=tf.nn.relu)
# L11: dense
with tf.name_scope('l11_dense'):
l11 = tf.layers.dense(inputs=l10, units=(config.getfloat('net', 'dense11_factor') *
config.getint('train', 'total_speakers')), activation=None)
# loss
with tf.name_scope('loss'):
loss = tf.map_fn(lambda x: tf.add(tf.norm(tf.subtract(x[0], ph_class_input_data[x[1]]), ord='euclidean'),
tf.log(tf.add(1e-6, tf.reduce_sum(
tf.map_fn(lambda z: tf.exp(tf.negative(tf.norm(tf.subtract(x[0], z),
ord='euclidean'))),
ph_class_input_data), 0)))), (l10, ph_map_labels),
dtype=tf.float32)
loss = tf.reduce_mean(loss)
tf.summary.scalar('loss', loss)
if debug:
with tf.name_scope('debug'):
tf.summary.histogram('emb', l10)
all_vars = tf.trainable_variables()
for var in all_vars:
tf.summary.histogram(var.name, var)
# optimizer
with tf.name_scope('optimizer'):
if config.get('optimizer', 'name') == 'adam':
optimizer = tf.train.AdamOptimizer(learning_rate=config.getfloat('optimizer', 'learning_rate'),
beta1=config.getfloat(
'optimizer', 'beta1'), beta2=config.getfloat('optimizer', 'beta2'),
epsilon=config.getfloat('optimizer', 'eps'))
elif config.get('optimizer', 'name') == 'adadelta':
optimizer = tf.train.AdadeltaOptimizer(learning_rate=config.getfloat(
'optimizer', 'learning_rate'), rho=config.getfloat('optimizer', 'rho'),
epsilon=config.getfloat('optimizer', 'eps'))
else:
optimizer = tf.train.MomentumOptimizer(learning_rate=config.getfloat(
'optimizer', 'learning_rate'), momentum=config.getfloat('optimizer', 'momentum'), use_nesterov=True)
train = optimizer.minimize(loss)
logger.info("Finished building network")
# Init
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
# TensorBoard ops
summary = tf.summary.merge_all()
saver = tf.train.Saver(max_to_keep=1000)
train_writer = tf.summary.FileWriter(flow_me_logs, sess.graph)
# load training and test data
train_data_gen = DataGen.DataGen(config, data_set='train')
validation_data_gen = DataGen.DataGen(config, data_set='validation')
# training loop
for step in range(config.getint('net', 'max_iter')):
start_time = time.time()
input_data_train, class_input_data_train, map_labels = train_data_gen.create_batch()
if not nchw:
input_data_train = np.transpose(input_data_train, axes=(0, 2, 3, 1))
class_input_data_train = np.transpose(class_input_data_train, axes=(0, 2, 3, 1))
# run z
# it has to be ph_input_data, seems strange, but is right
class_embeddings = sess.run(l10, feed_dict={ph_input_data: class_input_data_train, ph_train_mode: False})
# run x
_, loss_value = sess.run([train, loss], feed_dict={ph_input_data: input_data_train,
ph_map_labels: map_labels,
ph_class_input_data: class_embeddings,
ph_train_mode: True})
duration = time.time() - start_time
logger.info('Step {}: loss = {:.4f} ({:.3f} sec)'.format(step, loss_value, duration))
# Write the summaries and print an overview every x-th step.
if step % config.getint('net', 'sum_iter') == 0:
# Print status
start_time = time.time()
# Update events file
summary_str = sess.run(summary, feed_dict={ph_input_data: input_data_train,
ph_map_labels: map_labels,
ph_class_input_data: class_embeddings,
ph_train_mode: False})
train_writer.add_summary(summary_str, step)
train_writer.flush()
duration = time.time() - start_time
logger.debug('Step {}: Summary ({:.3f} sec)'.format(step, duration))
# Save a checkpoint and evaluate the model periodically.
if (step + 1) % config.getint('net', 'chkp_iter') == 0 or (step + 1) == config.getint('net', 'max_iter'):
start_time = time.time()
step_folder = 'step_{:05d}'.format(step)
step_path = join(flow_me_logs, step_folder)
test_writer = tf.summary.FileWriter(step_path, sess.graph)
# Evaluate against the training set.
input_data_test, map_labels = validation_data_gen.get_random_samples(config.getint('validation', 'samples'))
if not nchw:
input_data_test = np.transpose(input_data_test, axes=(0, 2, 3, 1))
labels = validation_data_gen.get_labels()
embeddings_test = sess.run(l10, feed_dict={ph_input_data: input_data_test, ph_train_mode: False})
# Embeddings
emb_var = tf.Variable(embeddings_test, name='embeddings')
init_vars = tf.variables_initializer([emb_var])
sess.run(init_vars)
projector_config = projector.ProjectorConfig()
embedding = projector_config.embeddings.add()
embedding.tensor_name = emb_var.name
# Save metafile with labels and link it to tensorboard.
metafile_path = join(step_path, 'metadata.tsv')
metafile_dir = os.path.dirname(metafile_path)
if not os.path.exists(metafile_dir):
os.makedirs(metafile_dir)
with open(metafile_path, mode='w+') as f:
for label_no in map_labels:
f.write(str(labels[label_no]) + '\n')
embedding.metadata_path = metafile_path
projector.visualize_embeddings(test_writer, projector_config)
emb_saver = tf.train.Saver([emb_var])
emb_saver.save(sess, join(step_path, 'emb.ckpt'), global_step=step)
# Checkpoint
saver.save(sess, join(flow_me_nets, 'model.ckpt'), global_step=step)
duration = time.time() - start_time
logger.info('Step {}: Checkpoint and Evaluation ({:.3f} sec)'.format(step, duration))
sess.close()
from sqlalchemy import create_engine, MetaData
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
from common.utils import load_config
from models.video import Video
__author__ = 'Rugnar'
cfg = load_config('..\\cfg.json')
Base = declarative_base()
engine = create_engine(cfg['db_address'], echo=True)
metadata = MetaData()
Session = sessionmaker(bind=engine)
def db_transaction(f):
def magic(*args, **kwargs):
session = args[0].db_session
session.begin(subtransactions=True)
try:
ret = f(*args, **kwargs)
session.commit()
session.commit()
return ret
except BaseException:
session.rollback()
raise
return magic
class DBStage(object):
def __init__(self):
def _plot_curves(plot_file_name, curve_names, metric_sets,
number_of_embeddings):
"""
Plots all specified curves and saves the plot into a file.
:param plot_file_name: String value of save file name
:param curve_names: Set of names used in legend to describe this curve
:param metric_sets: A list of 2D matrices, each row of a metrics 2D matrix describes one dataset for a curve
:param number_of_embeddings: set of integers, each integer describes how many embeddings is in this curve
"""
logger = get_logger('analysis', logging.INFO)
logger.info('Plot results')
config = load_config(None, join(get_common(), 'config.cfg'))
plot_width = config.getint('common', 'plot_width')
fig_width = config.getint('common', 'fig_width')
fig_height = config.getint('common', 'fig_height')
#Slice results to only 1-80 clusters
for i in range(0, len(metric_sets)):
for j in range(0, len(metric_sets[i])):
metric_sets[i][j] = metric_sets[i][j][-plot_width:]
print(len(metric_sets[i][j]))
best_results = [[] for _ in metric_names]
for m, min_value in enumerate(metric_min_values):
for results in metric_sets[m]:
if (metric_min_values[m] == 0):
best_results[m].append(np.max(results))
else:
best_results[m].append(np.min(results))
'''
This code is used to sort the lines by min mr. Because we now use mutliple metrics and dont sort by a single
metric, this code is not used anymore, but we keep it for now.
min_mrs, curve_names, mrs, acps, aris, homogeneity_scores, completeness_scores, number_of_embeddings = \
(list(t) for t in
zip(*sorted(zip(min_mrs, curve_names, mrs, acps, aris, homogeneity_scores, completeness_scores, number_of_embeddings))))
'''
# How many lines to plot
number_of_lines = len(curve_names)
# Get various colors needed to plot
color_map = plt.get_cmap('gist_rainbow')
colors = [color_map(i) for i in np.linspace(0, 1, number_of_lines)]
#Set fontsize for all plots
plt.rcParams.update({'font.size': 12})
# Define number of figures
fig1 = plt.figure(figsize=(fig_width, fig_height))
# Define Plots
plot_grid = (3, 2)
plots = [None] * len(metric_names)
plots[0] = _add_cluster_subplot(plot_grid, (0, 0), metric_names[0], 1)
plots[1] = _add_cluster_subplot(plot_grid, (0, 1), metric_names[1], 1)
plots[2] = _add_cluster_subplot(plot_grid, (1, 0), metric_names[2], 1)
plots[3] = _add_cluster_subplot(plot_grid, (1, 1), metric_names[3], 1)
#Set the horizontal space between subplots
plt.subplots_adjust(hspace=0.3)
# Define curves and their values
curves = [[] for _ in metric_names]
for m, metric_set in enumerate(metric_sets):
curves[m] = [plots[m], metric_set]
# Plot all curves
for index in range(number_of_lines):
label = curve_names[index]
for m, metric_name in enumerate(metric_names):
label = label + '\n {} {}: {}'.format(
'Max' if metric_min_values[m] == 0 else 'Min', metric_name,
str(best_results[m][index]))
color = colors[index]
number_of_clusters = np.arange(plot_width, 0, -1)
for plot, value in curves:
plot.plot(number_of_clusters,
value[index],
color=color,
label=label)
# Add legend and save the plot
fig1.legend(loc='upper center', bbox_to_anchor=(0.5, 0.33), ncol=4)
#fig1.show()
fig1.savefig(get_result_png(plot_file_name))
fig1.savefig(get_result_png(plot_file_name + '.svg'), format='svg')
def test(checkpoint, list, configPath, nchw):
path_master_config = './config/master.cfg'
config = load_config(path_master_config, configPath)
logger = get_logger('cluster', logging.INFO)
list = 'test_list' + list.__str__()
output_layer_name = config.get('test', 'output_layer')
# Output folder
output_layer_name = output_layer_name.replace('\\', '/')
# output_layer_name = output_layer_name.replace(':', '')
output_layer_name_folder = output_layer_name.replace(
'\\', '-') # NOTE: Windows modification, change for deploy
output_layer_name_folder = output_layer_name_folder.replace(':', '')
output_folder = os.path.join(config.get('output', 'plot_path'),
config.get('exp',
'name'), output_layer_name_folder,
'ckpt_{:05d}'.format(checkpoint),
config.get(list, 'name'))
if not os.path.exists(output_folder):
os.makedirs(output_folder)
add_file_handler(logger, os.path.join(output_folder, 'mr.log'))
# Load Session
path_meta_graph = os.path.join(config.get('output', 'log_path'),
'train_' + config.get('exp', 'name'),
'model.ckpt-' + str(checkpoint) + '.meta')
path_ckpt = os.path.join(config.get('output', 'log_path'),
'train_' + config.get('exp', 'name'),
'model.ckpt-' + str(checkpoint))
sess, input_layer, output_layer, train_mode = restore_session(
path_meta_graph, path_ckpt, output_layer_name)
# Load test data
data_gen_8 = DataGen.DataGen(config, data_set=list, pickle_no='pickle1')
data_gen_2 = DataGen.DataGen(config, data_set=list, pickle_no='pickle2')
input_data_8, map_labels_8 = data_gen_8.get_timit_test_set(
sentence_pickle=config.getint(list, 'sentences_pickle1'))
input_data_2, map_labels_2 = data_gen_2.get_timit_test_set(
sentence_pickle=config.getint(list, 'sentences_pickle2'))
labels = data_gen_8.get_labels(
) # Both data_gen instances should return the same labels
if not nchw:
input_data_8 = np.transpose(input_data_8, axes=(0, 2, 3, 1))
input_data_2 = np.transpose(input_data_2, axes=(0, 2, 3, 1))
batch_size = config.getint('net', 'batch_size')
input_data_8 = input_data_8[0:batch_size][:][:][:]
input_data_2 = input_data_2[0:batch_size][:][:][:]
# (858, 128, 100, 1)
# (?, 128, 100, 1)
print(np.shape(input_data_8))
print(np.shape(input_data_2))
label_colors = get_colors(len(labels))
# Pass samples trough network, get embeddings
embeddings_8 = sess.run(output_layer,
feed_dict={
input_layer: input_data_8,
train_mode: False
})
embeddings_2 = sess.run(output_layer,
feed_dict={
input_layer: input_data_2,
train_mode: False
})
sess.close()
# Reduce to mean, merge to one list of embeddings
# Init data structures according to used embeddings dimension
if 'l10_dense' in config.get('test', 'output_layer'):
embeddings_mean_8 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense10_factor') *
config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense10_factor') *
config.getint('train', 'total_speakers'))))
elif 'l11_dense' in config.get('test', 'output_layer'):
embeddings_mean_8 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense11_factor') *
config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense11_factor') *
config.getint('train', 'total_speakers'))))
else:
embeddings_mean_8 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense7_factor') *
config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros(
(config.getint(list, 'total_speakers'),
int(
config.getfloat('net', 'dense7_factor') *
config.getint('train', 'total_speakers'))))
# Sum of all embeddings
for embedding, label in zip(embeddings_8, map_labels_8):
embeddings_mean_8[label] += embedding
for embedding, label in zip(embeddings_2, map_labels_2):
embeddings_mean_2[label] += embedding
# Divsion trough count of embeddings from the same speaker
unique_8, counts_8 = np.unique(map_labels_8, return_counts=True)
for label, count in zip(unique_8, counts_8):
embeddings_mean_8[label] /= count
unique_2, counts_2 = np.unique(map_labels_2, return_counts=True)
for label, count in zip(unique_2, counts_2):
embeddings_mean_2[label] /= count
# Concatenate to one date set for analysis
embeddings = np.concatenate((embeddings_mean_8, embeddings_mean_2))
map_labels = np.concatenate((unique_8, unique_2))
map_labels_full = []
for label_no in map_labels:
map_labels_full.append(labels[label_no])
# Cluster embeddings
embeddings += 0.00001 # hotfix for division by zero = nan
embeddings_dist, embeddings_linkage = cluster_embeddings(embeddings)
# Dendogram
if config.getint(list, 'total_speakers') > 10:
draw_dendogram(embeddings_linkage,
embeddings_dist,
labels,
map_labels,
map_labels_full,
label_colors,
figsize=(20, 4.8))
elif config.getint(list, 'total_speakers') > 40:
draw_dendogram(embeddings_linkage,
embeddings_dist,
labels,
map_labels,
map_labels_full,
label_colors,
figsize=(50, 4.8))
else:
draw_dendogram(embeddings_linkage, embeddings_dist, labels, map_labels,
map_labels_full, label_colors)
plt.savefig(os.path.join(output_folder, 'dendo.png'), bbox_inches='tight')
plt.savefig(os.path.join(output_folder, 'dendo.svg'), bbox_inches='tight')
axes = plt.gca()
axes.set_ylim([0, 0.1])
plt.yticks(np.arange(0, 0.1, 0.005))
plt.grid(axis='y', linestyle='dotted')
plt.draw()
plt.savefig(os.path.join(output_folder, 'dendo_0.1.png'),
bbox_inches='tight')
plt.savefig(os.path.join(output_folder, 'dendo_0.1.svg'),
bbox_inches='tight')
# t-SNE Plot
''' Take out tsne because of sklearn misbehaving
if config.getint(list, 'total_speakers') > 20:
legend = False
else:
legend = True
draw_t_sne(embeddings, labels, map_labels, label_colors, legend=legend)
plt.savefig(os.path.join(output_folder, 'tsne.png'), bbox_inches='tight')
plt.savefig(os.path.join(output_folder, 'tsne.svg'), bbox_inches='tight')
# t-SNE Plot of some random (raw) embeddings
plt.clf()
embeddings_raw = np.concatenate((embeddings_8, embeddings_2)) # original embeddings
map_labels_raw = np.concatenate((map_labels_8, map_labels_2))
embeddings_raw, map_labels_raw = shuffle(embeddings_raw, map_labels_raw)
draw_t_sne(embeddings_raw[:50], labels, map_labels_raw[:50], label_colors, legend=legend)
plt.savefig(os.path.join(output_folder, 'tsne_rand.png'), bbox_inches='tight')
plt.savefig(os.path.join(output_folder, 'tsne_rand.svg'), bbox_inches='tight')
'''
# Calculate MR
mr, map_clusters, threshold = calculate_minimal_mr(embeddings_linkage,
map_labels)
legacy_mr = calculate_legacy_minimal_mr(
embeddings_linkage, map_labels, config.getint(list, 'total_speakers'))
# Save Matching of samples to clusters for the minimal MR
with open(os.path.join(output_folder, 'cluster_map.txt'), mode='w+') as f:
f.write('Matching of segments and clusters with minimal MR:\n')
f.write('| {:8s} | {:8s} |\n'.format('Speaker', 'Cluster'))
for label_no, cluster_no in zip(map_labels, map_clusters):
f.write('| {:8s} | {:8d} |\n'.format(labels[label_no], cluster_no))
# Print results
logger.info(
'MR = {:.4f} \t Threshold = {:.4f} \t (Legacy MR = {:.4f})'.format(
mr, threshold, legacy_mr))
def __init__(self, name, net_path):
super().__init__()
self.network_name = name
self.logger = get_logger("luvo", logging.INFO)
self.net_path = net_path
self.config = load_config(None, join(get_common(), 'config.cfg'))
def test(self, checkpoint=0, list=1, config_path=None):
if config_path is None:
config_path = self.config_path
path_master_config = get_configs('master')
config = load_config(path_master_config, get_configs(config_path))
logger = get_logger('cluster', logging.INFO)
list = 'test_list' + str(list)
# Log Output folder
folder_name = str(config.get(list, 'total_speakers')) + "_speakers"
checkpoint_folder = 'checkpoint_{:05d}'.format(checkpoint)
output_folder = get_experiment_logs("flow_me", folder_name, checkpoint_folder)
if not os.path.exists(output_folder):
os.makedirs(output_folder)
add_file_handler(logger, join(output_folder, 'mr.log'))
# Load test data
logger.info("Loading Test Data")
data_gen_8 = DataGen.DataGen(config, data_set=list, pickle_no='pickle1')
data_gen_2 = DataGen.DataGen(config, data_set=list, pickle_no='pickle2')
input_data_8, map_labels_8 = data_gen_8.get_timit_test_set(
sentence_pickle=config.getint(list, 'sentences_pickle1'))
input_data_2, map_labels_2 = data_gen_2.get_timit_test_set(
sentence_pickle=config.getint(list, 'sentences_pickle2'))
labels = data_gen_8.get_labels() # Both data_gen instances should return the same labels
if not self.nchw:
input_data_8 = np.transpose(input_data_8, axes=(0, 2, 3, 1))
input_data_2 = np.transpose(input_data_2, axes=(0, 2, 3, 1))
# Load Session
output_layer_name = config.get('test', 'output_layer')
output_layer_name = output_layer_name.replace('\\', '/')
flow_me_nets = get_experiment_nets("flow_me")
path_meta_graph = join(flow_me_nets, 'model.ckpt-' + str(checkpoint) + '.meta')
path_ckpt = join(flow_me_nets, 'model.ckpt-' + str(checkpoint))
sess, input_layer, output_layer, train_mode = restore_session(path_meta_graph, path_ckpt, output_layer_name)
logger.info("Restored Session:\tCheckpoint = {:}\t{:}".format(checkpoint, folder_name))
# Pass samples trough network, get embeddings
embeddings_8 = sess.run(output_layer, feed_dict={input_layer: input_data_8, train_mode: False})
embeddings_2 = sess.run(output_layer, feed_dict={input_layer: input_data_2, train_mode: False})
sess.close()
logger.info("Created Embeddings")
# Reduce to mean, merge to one list of embeddings
# Init data structures according to used embeddings dimension
if 'l10_dense' in config.get('test', 'output_layer'):
embeddings_mean_8 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense10_factor') * config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense10_factor') * config.getint('train', 'total_speakers'))))
elif 'l11_dense' in config.get('test', 'output_layer'):
embeddings_mean_8 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense11_factor') * config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense11_factor') * config.getint('train', 'total_speakers'))))
else:
embeddings_mean_8 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense7_factor') * config.getint('train', 'total_speakers'))))
embeddings_mean_2 = np.zeros((config.getint(list, 'total_speakers'), int(config.getfloat(
'net', 'dense7_factor') * config.getint('train', 'total_speakers'))))
# Sum of all embeddings
for embedding, label in zip(embeddings_8, map_labels_8):
embeddings_mean_8[label] += embedding
for embedding, label in zip(embeddings_2, map_labels_2):
embeddings_mean_2[label] += embedding
# Divsion trough count of embeddings from the same speaker
unique_8, counts_8 = np.unique(map_labels_8, return_counts=True)
for label, count in zip(unique_8, counts_8):
embeddings_mean_8[label] /= count
unique_2, counts_2 = np.unique(map_labels_2, return_counts=True)
for label, count in zip(unique_2, counts_2):
embeddings_mean_2[label] /= count
# Concatenate to one date set for analysis
embeddings = np.concatenate((embeddings_mean_8, embeddings_mean_2))
map_labels = np.concatenate((unique_8, unique_2))
return embeddings, map_labels
