def main(config):
print('seed', '=', set_seed(config.seed))
net = DNN()
criterion = Loss()
net.initialize(init=mxnet.initializer.Normal(sigma=config.init_stddev),
ctx=mxnet.gpu())
trainer = mxnet.gluon.Trainer(net.collect_params(), 'rmsprop', {
'learning_rate': config.learning_rate,
'wd': config.reg
})
if config.load_from:
load_from = config.load_from
# TODO: Load from models
else:
load_from = 0
train_set, eval_set, test_set = get_data(path='audioset/small',
split=config.split,
train_noise=config.train_noise,
train_copy=config.train_copy)
print(train_set.shape)
print(eval_set.shape)
print(test_set.shape)
eval_X = mxnet.nd.array(eval_set.X, ctx=mxnet.gpu())
eval_y = mxnet.nd.array(eval_set.y, ctx=mxnet.gpu())
test_X = mxnet.nd.array(test_set.X, ctx=mxnet.gpu())
test_y = mxnet.nd.array(test_set.y, ctx=mxnet.gpu())
for epoch in range(load_from + 1, load_from + config.n_epoch + 1):
X_batch, y_batch, l_batch = train_set.batch(size=config.batch_size)
X_batch = mxnet.nd.array(X_batch, mxnet.gpu())
y_batch = mxnet.nd.array(y_batch, mxnet.gpu())
with mxnet.autograd.record():
results = net(X_batch.as_in_context(mxnet.gpu()))
train_loss = criterion(results, y_batch)
train_loss.backward()
trainer.step(batch_size=config.batch_size)
if epoch % config.print_period == 0 or epoch == load_from:
results = net(eval_X.as_in_context(mxnet.gpu()))
eval_predicts = mxnet.nd.sigmoid(results)
eval_loss = criterion(results, eval_y.as_in_context(mxnet.gpu()))
auc, ap = metrics(eval_set.y, eval_predicts.asnumpy())
print('epoch {}/{} train loss: {} eval: loss: {} auc: {} ap: {}'.
format(epoch, load_from + config.n_epoch,
train_loss.asscalar(), eval_loss.asscalar(), auc, ap))
results = net(test_X.as_in_context(mxnet.gpu()))
test_predicts = mxnet.nd.sigmoid(results)
test_loss = criterion(results, test_y.as_in_context(mxnet.gpu()))
auc, ap = metrics(test_set.y, test_predicts.asnumpy())
print('test: loss: {} auc: {} ap: {}'.format(test_loss, auc, ap))
def main(config):
print('seed', '=', set_seed(config.seed))
net = DNN()
net.cuda()
optimizer = torch.optim.RMSprop(net.parameters(), config.learning_rate)
if config.load_from:
load_from = config.load_from
# TODO: Load from models
else:
load_from = 0
train_set, eval_set, test_set = get_data(path='audioset/small',
split=config.split,
train_noise=config.train_noise,
train_copy=config.train_copy)
print(train_set.shape)
print(eval_set.shape)
print(test_set.shape)
criterion = torch.nn.BCELoss()
eval_X = torch.autograd.Variable(torch.from_numpy(eval_set.X).cuda())
eval_y = torch.autograd.Variable(torch.from_numpy(eval_set.y).cuda())
test_X = torch.autograd.Variable(torch.from_numpy(test_set.X).cuda())
test_y = torch.autograd.Variable(torch.from_numpy(test_set.y).cuda())
for epoch in range(load_from + 1, load_from + config.n_epoch + 1):
X_batch, y_batch, l_batch = train_set.batch(size=config.batch_size)
X_batch = torch.from_numpy(X_batch).cuda()
y_batch = torch.from_numpy(y_batch).cuda()
X_batch = torch.autograd.Variable(X_batch)
y_batch = torch.autograd.Variable(y_batch)
optimizer.zero_grad()
outputs = net(X_batch)
train_loss = criterion(outputs, y_batch.float())
train_loss.backward()
optimizer.step()
if epoch % config.print_period == 0 or epoch == load_from:
eval_predicts = net(eval_X)
eval_loss = criterion(eval_predicts, eval_y.float())
auc, ap = metrics(eval_set.y, eval_predicts.data)
print('epoch {}/{} train loss: {} eval: loss: {} auc: {} ap: {}'.
format(epoch, load_from + config.n_epoch, train_loss,
eval_loss, auc, ap))
test_predicts = net(test_X)
test_loss = criterion(test_predicts, test_y.float())
auc, ap = metrics(test_set.y, test_predicts.data)
print('test: loss: {} auc: {} ap: {}'.format(test_loss, auc, ap))
def main(_):
config = tf.flags.FLAGS
print('seed', '=', set_seed(config.seed))
with tf.variable_scope('network'):
with tf.variable_scope('utility'):
initializer = tf.truncated_normal_initializer(mean=0, stddev=0.01)
regularizer = tf.contrib.layers.l2_regularizer(config.reg)
with tf.variable_scope('inputs'):
training = tf.placeholder(tf.bool)
learning_rate = tf.placeholder(tf.float32)
lengths = tf.placeholder(tf.int32, shape=[None])
inputs = tf.placeholder(tf.float32, shape=[None, 10, 128])
answers = tf.placeholder(tf.float32, shape=[None, 527])
with tf.variable_scope('process'):
hidden = inputs
lstm_stacked = tf.contrib.rnn.MultiRNNCell([
tf.nn.rnn_cell.LSTMCell(2048, activation=tf.nn.tanh)
for _ in range(10)
])
_, final_state = tf.nn.dynamic_rnn(lstm_stacked,
hidden,
dtype=tf.float32)
hidden0 = tf.concat(final_state[0], axis=1)
hidden1 = tf.concat(final_state[1], axis=1)
hidden = tf.concat((hidden0, hidden1), axis=1)
hidden = tf.layers.batch_normalization(hidden)
hidden, _, _ = dense(hidden, 1024, None, initializer, regularizer)
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden, training=training)
with tf.variable_scope('outputs'):
scores, _, _ = dense(hidden, 527, None, initializer, regularizer)
predicts = tf.nn.sigmoid(scores)
with tf.variable_scope('loss'):
cls_loss = tf.reduce_mean(
tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(
labels=answers, logits=scores),
axis=-1))
reg_loss = tf.losses.get_regularization_loss()
loss = cls_loss + reg_loss
with tf.variable_scope('train'):
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
gradients, variables = zip(*optimizer.compute_gradients(loss))
if config.clip_by_norm:
gradients = [
None if gradient is None else tf.clip_by_norm(
gradient, config.clip_by_norm)
for gradient in gradients
]
train = optimizer.apply_gradients(zip(gradients, variables))
if config.load_from:
load_from = config.load_from
# TODO: Load from models
else:
load_from = 0
session = tf.Session(config=tensorflow_gpu_config())
session.run(tf.global_variables_initializer())
train_set, eval_set, test_set = get_data(path='audioset/small',
split=config.split,
train_noise=config.train_noise,
train_copy=config.train_copy)
print(train_set.shape)
print(eval_set.shape)
print(test_set.shape)
plt_X, plt_train, plt_eval, plt_AUC, plt_AP = [], [], [], [], []
for epoch in range(load_from + 1, load_from + config.n_epoch + 1):
X_batch, y_batch, l_batch = train_set.batch(size=config.batch_size)
_, train_loss, train_cls_loss, train_reg_loss = \
session.run([train, loss, cls_loss, reg_loss], feed_dict={
inputs: X_batch,
answers: y_batch,
lengths: l_batch,
training: True,
learning_rate: config.learning_rate
})
if epoch % config.print_period == 0 or epoch == load_from:
eval_predicts = []
eval_loss = []
eval_reg_loss = []
eval_cls_loss = []
for i in range(0, len(eval_set.X), 500):
current_loss, current_cls_loss, current_reg_loss, current_predicts = \
session.run((loss, cls_loss, reg_loss, predicts),
feed_dict={
inputs: eval_set.X[i:i + 500],
answers: eval_set.y[i:i + 500],
lengths: eval_set.length[i:i + 500],
training: False
})
eval_predicts.append(current_predicts)
eval_loss.append(current_loss)
eval_reg_loss.append(current_reg_loss)
eval_cls_loss.append(current_cls_loss)
eval_predicts = numpy.concatenate(eval_predicts, axis=0)
eval_loss = numpy.mean(numpy.asarray(eval_loss))
eval_cls_loss = numpy.mean(numpy.asarray(eval_cls_loss))
eval_reg_loss = numpy.mean(numpy.asarray(eval_reg_loss))
auc, ap = metrics(eval_set.y, eval_predicts)
print('epoch {}/{} train loss: {} eval: loss: {} auc: {} ap: {}'.
format(epoch, load_from + config.n_epoch,
(train_loss, train_cls_loss, train_reg_loss),
(eval_loss, eval_cls_loss, eval_reg_loss), auc, ap))
plt_X.append(epoch)
plt_train.append(train_loss)
plt_eval.append(eval_loss)
plt_AUC.append(auc)
plt_AP.append(ap)
plot(((plt_X, plt_train), (plt_X, plt_eval)),
legends=('Train', 'Eval'),
log='rnn-loss.log',
fig='rnn-loss.png')
plot(((plt_X, plt_AUC), ),
legends=('Eval AUC', ),
log='rnn-AUC.log',
fig='rnn-AUC.png')
plot(((plt_X, plt_AP), ),
legends=('Eval AP', ),
log='rnn-AP.log',
fig='rnn-AP.png')
eval_predicts = []
eval_loss = []
eval_reg_loss = []
eval_cls_loss = []
for i in range(0, len(test_set.X), 500):
current_loss, current_cls_loss, current_reg_loss, current_predicts = \
session.run((loss, cls_loss, reg_loss, predicts), feed_dict={
inputs: test_set.X[i:i + 500],
answers: test_set.y[i:i + 500],
lengths: test_set.length[i:i + 500],
training: False
})
eval_predicts.append(current_predicts)
eval_loss.append(current_loss)
eval_reg_loss.append(current_reg_loss)
eval_cls_loss.append(current_cls_loss)
eval_predicts = numpy.concatenate(eval_predicts, axis=0)
eval_loss = numpy.mean(numpy.asarray(eval_loss))
eval_cls_loss = numpy.mean(numpy.asarray(eval_cls_loss))
eval_reg_loss = numpy.mean(numpy.asarray(eval_reg_loss))
auc, ap = metrics(test_set.y, eval_predicts)
print('test: loss: {} auc: {} ap: {}'.format(
(eval_loss, eval_cls_loss, eval_reg_loss), auc, ap))
with open('rnn.predicts', 'wb') as writer:
joblib.dump(eval_predicts, writer)
def main(_):
config = tf.flags.FLAGS
print('seed', '=', set_seed(config.seed))
with tf.variable_scope('network'):
with tf.variable_scope('utility'):
initializer = tf.truncated_normal_initializer(mean=0, stddev=0.001)
regularizer = tf.contrib.layers.l2_regularizer(config.reg)
with tf.variable_scope('inputs'):
training = tf.placeholder(tf.bool)
learning_rate = tf.placeholder(tf.float32)
lengths = tf.placeholder(tf.int32, shape=[None])
inputs = tf.placeholder(tf.float32, shape=[None, 10, 128])
answers = tf.placeholder(tf.float32, shape=[None, 527])
with tf.variable_scope('process'):
hidden = inputs
hidden = tf.reshape(hidden, shape=[-1, 1280])
hidden = tf.layers.batch_normalization(hidden)
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden1 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden = tf.layers.batch_normalization(hidden)
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden2 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden = tf.layers.batch_normalization(hidden)
hidden += hidden1
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden3 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden = tf.layers.batch_normalization(hidden)
hidden += hidden2
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden4 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden = tf.layers.batch_normalization(hidden)
hidden += hidden3
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden5 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden += hidden4 + hidden5
hidden = tf.layers.batch_normalization(hidden)
hidden = tf.concat((hidden1, hidden), axis=1)
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden6 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden = tf.layers.batch_normalization(hidden)
hidden = tf.concat((hidden2, hidden), axis=1)
hidden, _, _ = dense(hidden, 600, None, initializer, regularizer)
hidden7 = hidden
hidden = tf.nn.leaky_relu(hidden)
hidden = tf.layers.dropout(hidden)
hidden += hidden6 + hidden7
with tf.variable_scope('outputs'):
scores, _, _ = dense(hidden, 527, None, initializer, regularizer)
predicts = tf.nn.sigmoid(scores)
with tf.variable_scope('loss'):
cls_loss = tf.reduce_mean(
tf.reduce_sum(tf.nn.sigmoid_cross_entropy_with_logits(
labels=answers, logits=scores),
axis=-1))
reg_loss = tf.losses.get_regularization_loss()
loss = cls_loss + reg_loss
with tf.variable_scope('train'):
optimizer = tf.train.RMSPropOptimizer(learning_rate=learning_rate)
gradients, variables = zip(*optimizer.compute_gradients(loss))
if config.clip_by_norm:
gradients = [
None if gradient is None else tf.clip_by_norm(
gradient, config.clip_by_norm)
for gradient in gradients
]
train = optimizer.apply_gradients(zip(gradients, variables))
if config.load_from:
load_from = config.load_from
# TODO: Load from models
else:
load_from = 0
session = tf.Session(config=tensorflow_gpu_config())
session.run(tf.global_variables_initializer())
train_set, eval_set, test_set = get_data(path='audioset/small',
split=config.split,
train_noise=config.train_noise,
train_copy=config.train_copy)
print(train_set.shape)
print(eval_set.shape)
print(test_set.shape)
plt_X, plt_train, plt_eval, plt_AUC, plt_AP = [], [], [], [], []
for epoch in range(load_from + 1, load_from + config.n_epoch + 1):
X_batch, y_batch, l_batch = train_set.batch(size=config.batch_size)
_, train_loss, train_cls_loss, train_reg_loss = \
session.run([train, loss, cls_loss, reg_loss], feed_dict={
inputs: X_batch,
answers: y_batch,
lengths: l_batch,
training: True,
learning_rate: config.learning_rate
})
if epoch % config.print_period == 0 or epoch == load_from:
eval_loss, eval_cls_loss, eval_reg_loss, eval_predicts = \
session.run((loss, cls_loss, reg_loss, predicts), feed_dict={
inputs: eval_set.X,
answers: eval_set.y,
lengths: eval_set.length,
training: False
})
auc, ap = metrics(eval_set.y, eval_predicts)
print('epoch {}/{} train loss: {} eval: loss: {} auc: {} ap: {}'.
format(epoch, load_from + config.n_epoch,
(train_loss, train_cls_loss, train_reg_loss),
(eval_loss, eval_cls_loss, eval_reg_loss), auc, ap))
plt_X.append(epoch)
plt_train.append(train_loss)
plt_eval.append(eval_loss)
plt_AUC.append(auc)
plt_AP.append(ap)
plot(((plt_X, plt_train), (plt_X, plt_eval)),
legends=('Train', 'Eval'),
log='dnn-loss.log',
fig='dnn-loss.png')
plot(((plt_X, plt_AUC), ),
legends=('Eval AUC', ),
log='dnn-AUC.log',
fig='dnn-AUC.png')
plot(((plt_X, plt_AP), ),
legends=('Eval AP', ),
log='dnn-AP.log',
fig='dnn-AP.png')
test_loss, test_cls_loss, test_reg_loss, test_predicts = \
session.run((loss, cls_loss, reg_loss, predicts), feed_dict={
inputs: test_set.X,
answers: test_set.y,
lengths: test_set.length,
training: False
})
auc, ap = metrics(test_set.y, test_predicts)
print('test: loss: {} auc: {} ap: {}'.format(
(test_loss, test_cls_loss, test_reg_loss), auc, ap))
with open('dnn.predicts', 'wb') as writer:
joblib.dump(test_predicts, writer)
import glob
import numpy
from sklearn.externals import joblib
from project.utils import get_data, metrics
if __name__ == '__main__':
train_set, eval_set, test_set = get_data(path='audioset/small',
split=0.3,
train_noise=0,
train_copy=1)
predicts = []
for path in glob.glob('*.predicts'):
print('Loading from', path)
with open(path, 'rb') as reader:
predicts.append(joblib.load(reader))
predicts = numpy.asarray(predicts)
predicts = numpy.mean(predicts, axis=0)
auc, ap = metrics(test_set.y, predicts)
with open("final_output.pkl", 'wb') as writer:
numpy.save(writer, predicts)
print("AUC={}, AP={}".format(auc, ap))