def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=400,
type=int,
help='number of epochs to learn')
parser.add_argument('--unit',
'-u',
default=30,
type=int,
help='number of units')
parser.add_argument('--batchsize',
'-b',
type=int,
default=25,
help='learning minibatch size')
parser.add_argument('--label',
'-l',
type=int,
default=5,
help='number of labels')
parser.add_argument('--epocheval',
'-p',
type=int,
default=5,
help='number of epochs per evaluation')
parser.add_argument('--test', dest='test', action='store_true')
parser.set_defaults(test=False)
args = parser.parse_args()
vocab = {}
max_size = None
train_trees = data.read_corpus('trees/train.txt', max_size)
test_trees = data.read_corpus('trees/test.txt', max_size)
if args.gpu >= 0:
chainer.cuda.get_device(args.gpu).use()
xp = cuda.cupy
else:
xp = numpy
train_data = [linearize_tree(vocab, t, xp) for t in train_trees]
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_data = [linearize_tree(vocab, t, xp) for t in test_trees]
test_iter = chainer.iterators.SerialIterator(test_data,
args.batchsize,
repeat=False,
shuffle=False)
model = ThinStackRecursiveNet(len(vocab), args.unit, args.label)
if args.gpu >= 0:
model.to_gpu()
optimizer = chainer.optimizers.AdaGrad(0.1)
optimizer.setup(model)
updater = training.StandardUpdater(train_iter,
optimizer,
device=None,
converter=convert)
trainer = training.Trainer(updater, (args.epoch, 'epoch'))
trainer.extend(extensions.Evaluator(test_iter,
model,
converter=convert,
device=None),
trigger=(args.epocheval, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.MicroAverage('main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage('validation/main/correct',
'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
trainer.run()
def train(args):
""" Training model with chainer backend.
This function is called from eend/bin/train.py with
parsed command-line arguments.
"""
np.random.seed(args.seed)
os.environ['CHAINER_SEED'] = str(args.seed)
chainer.global_config.cudnn_deterministic = True
train_set = KaldiDiarizationDataset(
args.train_data_dir,
chunk_size=args.num_frames,
context_size=args.context_size,
input_transform=args.input_transform,
frame_size=args.frame_size,
frame_shift=args.frame_shift,
subsampling=args.subsampling,
rate=args.sampling_rate,
use_last_samples=True,
label_delay=args.label_delay,
n_speakers=args.num_speakers,
)
dev_set = KaldiDiarizationDataset(
args.valid_data_dir,
chunk_size=args.num_frames,
context_size=args.context_size,
input_transform=args.input_transform,
frame_size=args.frame_size,
frame_shift=args.frame_shift,
subsampling=args.subsampling,
rate=args.sampling_rate,
use_last_samples=True,
label_delay=args.label_delay,
n_speakers=args.num_speakers,
)
# Prepare model
Y, T = train_set.get_example(0)
if args.model_type == 'BLSTM':
model = BLSTMDiarization(
in_size=Y.shape[1],
n_speakers=args.num_speakers,
hidden_size=args.hidden_size,
n_layers=args.num_lstm_layers,
embedding_layers=args.embedding_layers,
embedding_size=args.embedding_size,
dc_loss_ratio=args.dc_loss_ratio,
)
elif args.model_type == 'Transformer':
model = TransformerDiarization(
args.num_speakers,
Y.shape[1],
n_units=args.hidden_size,
n_heads=args.transformer_encoder_n_heads,
n_layers=args.transformer_encoder_n_layers,
dropout=args.transformer_encoder_dropout)
else:
raise ValueError('Possible model_type are "Transformer" and "BLSTM"')
if args.gpu >= 0:
gpuid = use_single_gpu()
print('GPU device {} is used'.format(gpuid))
model.to_gpu()
else:
gpuid = -1
print('Prepared model')
# Setup optimizer
if args.optimizer == 'adam':
optimizer = optimizers.Adam(alpha=args.lr)
elif args.optimizer == 'sgd':
optimizer = optimizers.SGD(lr=args.lr)
elif args.optimizer == 'noam':
optimizer = optimizers.Adam(alpha=0, beta1=0.9, beta2=0.98, eps=1e-9)
else:
raise ValueError(args.optimizer)
optimizer.setup(model)
if args.gradclip > 0:
optimizer.add_hook(
chainer.optimizer_hooks.GradientClipping(args.gradclip))
# Init/Resume
if args.initmodel:
print('Load model from', args.initmodel)
serializers.load_npz(args.initmodel, model)
train_iter = iterators.MultiprocessIterator(
train_set,
batch_size=args.batchsize,
repeat=True, shuffle=True,
# shared_mem=64000000,
shared_mem=None,
n_processes=4, n_prefetch=2)
dev_iter = iterators.MultiprocessIterator(
dev_set,
batch_size=args.batchsize,
repeat=False, shuffle=False,
# shared_mem=64000000,
shared_mem=None,
n_processes=4, n_prefetch=2)
if args.gradient_accumulation_steps > 1:
updater = GradientAccumulationUpdater(
train_iter, optimizer, converter=_convert, device=gpuid)
else:
updater = training.StandardUpdater(
train_iter, optimizer, converter=_convert, device=gpuid)
trainer = training.Trainer(
updater,
(args.max_epochs, 'epoch'),
out=os.path.join(args.model_save_dir))
evaluator = extensions.Evaluator(
dev_iter, model, converter=_convert, device=gpuid)
trainer.extend(evaluator)
if args.optimizer == 'noam':
trainer.extend(
NoamScheduler(args.hidden_size,
warmup_steps=args.noam_warmup_steps,
scale=args.noam_scale),
trigger=(1, 'iteration'))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
# MICRO AVERAGE
metrics = [
('diarization_error', 'speaker_scored', 'DER'),
('speech_miss', 'speech_scored', 'SAD_MR'),
('speech_falarm', 'speech_scored', 'SAD_FR'),
('speaker_miss', 'speaker_scored', 'MI'),
('speaker_falarm', 'speaker_scored', 'FA'),
('speaker_error', 'speaker_scored', 'CF'),
('correct', 'frames', 'accuracy')]
for num, den, name in metrics:
trainer.extend(extensions.MicroAverage(
'main/{}'.format(num),
'main/{}'.format(den),
'main/{}'.format(name)))
trainer.extend(extensions.MicroAverage(
'validation/main/{}'.format(num),
'validation/main/{}'.format(den),
'validation/main/{}'.format(name)))
trainer.extend(extensions.LogReport(log_name='log_iter',
trigger=(1000, 'iteration')))
trainer.extend(extensions.LogReport())
trainer.extend(extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/diarization_error_rate',
'validation/main/diarization_error_rate',
'elapsed_time']))
trainer.extend(extensions.PlotReport(
['main/loss', 'validation/main/loss'],
x_key='epoch',
file_name='loss.png'))
trainer.extend(extensions.PlotReport(
['main/diarization_error_rate',
'validation/main/diarization_error_rate'],
x_key='epoch',
file_name='DER.png'))
trainer.extend(extensions.ProgressBar(update_interval=100))
trainer.extend(extensions.snapshot(
filename='snapshot_epoch-{.updater.epoch}'))
trainer.extend(extensions.dump_graph('main/loss', out_name="cg.dot"))
trainer.run()
print('Finished!')
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--gpu',
'-g',
default=-1,
type=int,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--epoch',
'-e',
default=400,
type=int,
help='number of epochs to learn')
parser.add_argument('--unit',
'-u',
default=30,
type=int,
help='number of units')
parser.add_argument('--batchsize',
'-b',
type=int,
default=25,
help='learning minibatch size')
parser.add_argument('--label',
'-l',
type=int,
default=5,
help='number of labels')
parser.add_argument('--epocheval',
'-p',
type=int,
default=5,
help='number of epochs per evaluation')
parser.add_argument('--test', dest='test', action='store_true')
parser.add_argument('--root',
'-r',
type=str,
default="",
help='the root directory of the input dataset')
parser.set_defaults(test=False)
args = parser.parse_args()
n_epoch = args.epoch # number of epochs
n_units = args.unit # number of units per layer
batchsize = args.batchsize # minibatch size
n_label = args.label # number of labels
epoch_per_eval = args.epocheval # number of epochs per evaluation
if args.test:
max_size = 10
else:
max_size = None
vocab = {}
train_data = [
convert_tree(vocab, tree) for tree in data.read_corpus(
os.path.join(args.root + 'trees/train.txt'), max_size)
]
train_iter = chainer.iterators.SerialIterator(train_data, batchsize)
validation_data = [
convert_tree(vocab, tree)
for tree in data.read_corpus(os.path.join(args.root +
'trees/dev.txt'), max_size)
]
validation_iter = chainer.iterators.SerialIterator(validation_data,
batchsize,
repeat=False,
shuffle=False)
test_data = [
convert_tree(vocab, tree) for tree in data.read_corpus(
os.path.join(args.root + 'trees/test.txt'), max_size)
]
model = RecursiveNet(len(vocab), n_units, n_label)
if args.gpu >= 0:
model.to_gpu()
# Setup optimizer
optimizer = optimizers.AdaGrad(lr=0.1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(0.0001))
def _convert(batch, _):
return batch
# Setup updater
updater = chainer.training.StandardUpdater(train_iter,
optimizer,
device=args.gpu,
converter=_convert)
# Setup trainer and run
trainer = chainer.training.Trainer(updater, (n_epoch, 'epoch'))
trainer.extend(extensions.Evaluator(validation_iter,
model,
device=args.gpu,
converter=_convert),
trigger=(epoch_per_eval, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.MicroAverage('main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage('validation/main/correct',
'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
trainer.run()
print('Test evaluation')
evaluate(model, test_data)
def main():
parser = argparse.ArgumentParser(
description='Chainer example: POS-tagging')
parser.add_argument('--batchsize', '-b', type=int, default=30,
help='Number of images in each mini batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--gpu', '-g', type=int, default=-1,
help='GPU ID (negative value indicates CPU)')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
args = parser.parse_args()
vocab = collections.defaultdict(lambda: len(vocab))
pos_vocab = collections.defaultdict(lambda: len(pos_vocab))
# Convert word sequences and pos sequences to integer sequences.
nltk.download('brown')
data = []
for sentence in nltk.corpus.brown.tagged_sents():
xs = numpy.array([vocab[lex] for lex, _ in sentence], numpy.int32)
ys = numpy.array([pos_vocab[pos] for _, pos in sentence], numpy.int32)
data.append((xs, ys))
print('# of sentences: {}'.format(len(data)))
print('# of words: {}'.format(len(vocab)))
print('# of pos: {}'.format(len(pos_vocab)))
model = CRF(len(vocab), len(pos_vocab))
if args.gpu >= 0:
chainer.backends.cuda.get_device_from_id(args.gpu).use()
model.to_gpu(args.gpu)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
test_data, train_data = datasets.split_dataset_random(
data, len(data) // 10, seed=0)
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_data, args.batchsize,
repeat=False, shuffle=False)
updater = training.updaters.StandardUpdater(
train_iter, optimizer, converter=convert, device=args.gpu)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
evaluator = extensions.Evaluator(
test_iter, model, device=args.gpu, converter=convert)
# Only validate in each 1000 iteration
trainer.extend(evaluator, trigger=(1000, 'iteration'))
trainer.extend(extensions.LogReport(trigger=(100, 'iteration')),
trigger=(100, 'iteration'))
trainer.extend(
extensions.MicroAverage(
'main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage(
'validation/main/correct', 'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']),
trigger=(100, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--device',
'-d',
type=str,
default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--epoch',
'-e',
default=400,
type=int,
help='number of epochs to learn')
parser.add_argument('--unit',
'-u',
default=30,
type=int,
help='number of units')
parser.add_argument('--batchsize',
'-b',
type=int,
default=25,
help='learning minibatch size')
parser.add_argument('--label',
'-l',
type=int,
default=5,
help='number of labels')
parser.add_argument('--epocheval',
'-p',
type=int,
default=5,
help='number of epochs per evaluation')
parser.add_argument('--test', dest='test', action='store_true')
parser.set_defaults(test=False)
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu',
'-g',
dest='device',
type=int,
nargs='?',
const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == numpy.float16:
warnings.warn('This example may cause NaN in FP16 mode.',
RuntimeWarning)
vocab = {}
max_size = None
train_trees = data.read_corpus('trees/train.txt', max_size)
test_trees = data.read_corpus('trees/test.txt', max_size)
device = chainer.get_device(args.device)
device.use()
xp = device.xp
train_data = [linearize_tree(vocab, t, xp) for t in train_trees]
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_data = [linearize_tree(vocab, t, xp) for t in test_trees]
test_iter = chainer.iterators.SerialIterator(test_data,
args.batchsize,
repeat=False,
shuffle=False)
model = ThinStackRecursiveNet(len(vocab), args.unit, args.label)
model.to_device(device)
optimizer = chainer.optimizers.AdaGrad(0.1)
optimizer.setup(model)
updater = training.StandardUpdater(train_iter,
optimizer,
converter=convert,
device=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'))
trainer.extend(extensions.Evaluator(test_iter,
model,
converter=convert,
device=device),
trigger=(args.epocheval, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.MicroAverage('main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage('validation/main/correct',
'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
trainer.extend(extensions.ProgressBar(update_interval=10))
trainer.run()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--device',
'-d',
type=str,
default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--out',
'-o',
default='result',
type=str,
help='Directory to ouput the result')
parser.add_argument('--resume',
'-r',
type=str,
help='Resume the training from snapshot')
parser.add_argument('--epoch',
'-e',
default=400,
type=int,
help='number of epochs to learn')
parser.add_argument('--unit',
'-u',
default=30,
type=int,
help='number of units')
parser.add_argument('--batchsize',
'-b',
type=int,
default=25,
help='learning minibatch size')
parser.add_argument('--label',
'-l',
type=int,
default=5,
help='number of labels')
parser.add_argument('--epocheval',
'-p',
type=int,
default=5,
help='number of epochs per evaluation')
parser.add_argument('--test', dest='test', action='store_true')
parser.set_defaults(test=False)
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu',
'-g',
dest='device',
type=int,
nargs='?',
const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == np.float16:
warnings.warn('This example may cause NaN in FP16 mode.',
RuntimeWarning)
n_epoch = args.epoch # number of epochs
n_units = args.unit # number of units per layer
batchsize = args.batchsize # minibatch size
n_label = args.label # number of labels
epoch_per_eval = args.epocheval # number of epochs per evaluation
if args.test:
max_size = 10
else:
max_size = None
device = chainer.get_device(args.device)
device.use()
vocab = {}
train_data = [
convert_tree(vocab, tree)
for tree in data.read_corpus('trees/train.txt', max_size)
]
train_iter = chainer.iterators.SerialIterator(train_data, batchsize)
validation_data = [
convert_tree(vocab, tree)
for tree in data.read_corpus('trees/dev.txt', max_size)
]
validation_iter = chainer.iterators.SerialIterator(validation_data,
batchsize,
repeat=False,
shuffle=False)
test_data = [
convert_tree(vocab, tree)
for tree in data.read_corpus('trees/test.txt', max_size)
]
model = RecursiveNet(len(vocab), n_units, n_label)
model.to_device(device)
# Setup optimizer
optimizer = optimizers.AdaGrad(lr=0.1)
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(0.0001))
# Setup updater
updater = chainer.training.StandardUpdater(train_iter,
optimizer,
converter=convert,
device=device)
# Setup trainer and run
trainer = chainer.training.Trainer(updater, (n_epoch, 'epoch'), args.out)
trainer.extend(extensions.Evaluator(validation_iter,
model,
converter=convert,
device=device),
trigger=(epoch_per_eval, 'epoch'))
trainer.extend(extensions.LogReport())
trainer.extend(
extensions.MicroAverage('main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage('validation/main/correct',
'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport([
'epoch', 'main/loss', 'validation/main/loss', 'main/accuracy',
'validation/main/accuracy', 'elapsed_time'
]))
trainer.extend(
extensions.snapshot(filename='snapshot_epoch_{.updater.epoch}'),
trigger=(epoch_per_eval, 'epoch'))
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume is not None:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
print('Test evaluation')
evaluate(model, test_data)
def main():
parser = argparse.ArgumentParser(
description='Chainer example: POS-tagging')
parser.add_argument('--batchsize', '-b', type=int, default=30,
help='Number of images in each mini batch')
parser.add_argument('--epoch', '-e', type=int, default=20,
help='Number of sweeps over the dataset to train')
parser.add_argument('--device', '-d', type=str, default='-1',
help='Device specifier. Either ChainerX device '
'specifier or an integer. If non-negative integer, '
'CuPy arrays with specified device id are used. If '
'negative integer, NumPy arrays are used')
parser.add_argument('--out', '-o', default='result',
help='Directory to output the result')
parser.add_argument('--resume', '-r', default='',
help='Resume the training from snapshot')
group = parser.add_argument_group('deprecated arguments')
group.add_argument('--gpu', '-g', dest='device',
type=int, nargs='?', const=0,
help='GPU ID (negative value indicates CPU)')
args = parser.parse_args()
if chainer.get_dtype() == numpy.float16:
warnings.warn(
'This example may cause NaN in FP16 mode.', RuntimeWarning)
vocab = collections.defaultdict(lambda: len(vocab))
pos_vocab = collections.defaultdict(lambda: len(pos_vocab))
# Convert word sequences and pos sequences to integer sequences.
nltk.download('brown')
data = []
for sentence in nltk.corpus.brown.tagged_sents():
xs = numpy.array([vocab[lex] for lex, _ in sentence], numpy.int32)
ys = numpy.array([pos_vocab[pos] for _, pos in sentence], numpy.int32)
data.append((xs, ys))
print('# of sentences: {}'.format(len(data)))
print('# of words: {}'.format(len(vocab)))
print('# of pos: {}'.format(len(pos_vocab)))
device = chainer.get_device(args.device)
device.use()
model = CRF(len(vocab), len(pos_vocab))
model.to_device(device)
optimizer = chainer.optimizers.Adam()
optimizer.setup(model)
optimizer.add_hook(chainer.optimizer.WeightDecay(0.0001))
test_data, train_data = datasets.split_dataset_random(
data, len(data) // 10, seed=0)
train_iter = chainer.iterators.SerialIterator(train_data, args.batchsize)
test_iter = chainer.iterators.SerialIterator(test_data, args.batchsize,
repeat=False, shuffle=False)
updater = training.updaters.StandardUpdater(
train_iter, optimizer, converter=convert, device=device)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)
evaluator = extensions.Evaluator(
test_iter, model, device=device, converter=convert)
# Only validate in each 1000 iteration
trainer.extend(evaluator, trigger=(1000, 'iteration'))
trainer.extend(extensions.LogReport(trigger=(100, 'iteration')),
trigger=(100, 'iteration'))
trainer.extend(
extensions.MicroAverage(
'main/correct', 'main/total', 'main/accuracy'))
trainer.extend(
extensions.MicroAverage(
'validation/main/correct', 'validation/main/total',
'validation/main/accuracy'))
trainer.extend(
extensions.PrintReport(
['epoch', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'elapsed_time']),
trigger=(100, 'iteration'))
trainer.extend(extensions.ProgressBar(update_interval=10))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
