def train():
fluid.enable_dygraph(device)
processor = SentaProcessor(data_dir=args.data_dir,
vocab_path=args.vocab_path,
random_seed=args.random_seed)
num_labels = len(processor.get_labels())
num_train_examples = processor.get_num_examples(phase="train")
max_train_steps = args.epoch * num_train_examples // args.batch_size // dev_count
train_data_generator = processor.data_generator(
batch_size=args.batch_size,
padding_size=args.padding_size,
places=device,
phase='train',
epoch=args.epoch,
shuffle=False)
eval_data_generator = processor.data_generator(
batch_size=args.batch_size,
padding_size=args.padding_size,
places=device,
phase='dev',
epoch=args.epoch,
shuffle=False)
if args.model_type == 'cnn_net':
model = CNN(args.vocab_size, args.batch_size, args.padding_size)
elif args.model_type == 'bow_net':
model = BOW(args.vocab_size, args.batch_size, args.padding_size)
elif args.model_type == 'gru_net':
model = GRU(args.vocab_size, args.batch_size, args.padding_size)
elif args.model_type == 'bigru_net':
model = BiGRU(args.vocab_size, args.batch_size, args.padding_size)
optimizer = fluid.optimizer.Adagrad(learning_rate=args.lr,
parameter_list=model.parameters())
inputs = [Input([None, None], 'int64', name='doc')]
labels = [Input([None, 1], 'int64', name='label')]
model.prepare(optimizer,
CrossEntropy(),
Accuracy(topk=(1, )),
inputs,
labels,
device=device)
model.fit(train_data=train_data_generator,
eval_data=eval_data_generator,
batch_size=args.batch_size,
epochs=args.epoch,
save_dir=args.checkpoints,
eval_freq=args.eval_freq,
save_freq=args.save_freq)
def train(model_type, epochs, batch_size, logdir):
ds_train, ds_test = tfds.load('cifar10',
split=['train', 'test'],
as_supervised=True)
num_samples = 50000
num_samples_test = 10000
ds_train = ds_train.shuffle(num_samples)\
.batch(batch_size)\
.map(preprocess, num_parallel_calls=tf.data.experimental.AUTOTUNE)\
.repeat(epochs)\
.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
ds_test = ds_test.batch(batch_size)\
.map(preprocess, num_parallel_calls=tf.data.experimental.AUTOTUNE)\
.repeat(epochs)\
.prefetch(buffer_size=tf.data.experimental.AUTOTUNE)
kl_div_fn = (lambda q, p, _: tfd.kl_divergence(q, p) / num_samples)
if model_type == 'normal':
model = CNN(num_classes=10)
elif model_type == 'reparam':
model = ReparamCNN(num_classes=10, kernel_divergence_fn=kl_div_fn)
else:
model = FlipOutCNN(num_classes=10, kernel_divergence_fn=kl_div_fn)
# Set input_shape explicitly (before compile) to instantiate model.losses
model.build(input_shape=[None, 32, 32, 3])
optimizer = optimizers.Adam()
loss_fn = losses.SparseCategoricalCrossentropy(from_logits=True)
metrics = [tf.keras.metrics.SparseCategoricalAccuracy(name='accuracy')]
model.compile(optimizer, loss=loss_fn, metrics=metrics)
callbacks = [tf.keras.callbacks.TensorBoard(log_dir=logdir)]
model.fit(ds_train,
epochs=epochs,
callbacks=callbacks,
validation_data=ds_test,
steps_per_epoch=num_samples // batch_size,
validation_steps=num_samples_test // batch_size)
return None
'csv_logger_{}_{}.csv'.format(pct_missing, title))
# EarlyStopping
early_stopper = EarlyStopping(monitor='val_loss',
min_delta=0.001,
patience=10)
# Reduce lr on plateau
lr_reducer = ReduceLROnPlateau(factor=np.sqrt(0.1),
cooldown=0,
patience=20,
min_lr=0.5e-6)
if not data_augmentation:
print('Not using data augmentation.')
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
shuffle=True,
callbacks=[csv_logger, checkpointer, early_stopper])
else:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=False, # divide inputs by std
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
# randomly rotate images in the range (degrees, 0 to 180)
rotation_range=0,
# randomly shift images horizontally (fraction of total width)
width_shift_range=0.1,
datasetName = "Dataset"
data, labels, dataset = preProcess(datasetName)
xTrainData, xTestData, yTrainData, yTestData = train_test_split(data, labels, test_size=0.25, random_state=2)
print('\nNumber of xTrainData pairs: ', len(xTrainData))
print('\nNumber of xTestData pairs: ', len(xTestData))
print('\nNumber of yTrainData pairs: ', len(yTrainData))
print('\nNumber of yTestData pairs: ', len(yTestData))
#%% Model build and fit
model = CNN()
history = model.fit(xTrainData, yTrainData,
batch_size = 16,
epochs = 20,
validation_split= 0.25,
verbose = 2,
)
# model_test
testEvaluate = model.evaluate(xTestData, yTestData, verbose=0)
print("loss: " + str(testEvaluate[0]) + "\t accuracy: " + str(testEvaluate[1]))
#%% Save weights
model.save("my_h5_model.h5")
model.save_weights("covid19_weights.h5")
#%% Load weights
model.load_weights("my_h5_model.h5")
#%% Plotting
optimizer=opt(lr=lr),
metrics=['accuracy'])
grad_son = GradientSonification(path=fname,
model=model,
fs=fs,
duration=duration,
freq=freq)
model.compile(loss='categorical_crossentropy',
optimizer=opt(lr=lr),
metrics=['accuracy'] + grad_son.metrics)
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
callbacks=[grad_son])
# Train DNN
fname = '_'.join(['dnn', opt.__name__.lower(), str(lr), act])
fname = path + fname + '.wav'
print(fname)
model = DNN(input_shape=(28 * 28, ), activation=act)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=opt(lr=lr),
metrics=['accuracy'])
grad_son = GradientSonification(path=fname,
def main():
"""
Main Function
"""
args = Config(yaml_file='./config.yaml')
args.build()
args.Print()
if not (args.do_train or args.do_val or args.do_infer):
raise ValueError("For args `do_train`, `do_val` and `do_infer`, at "
"least one of them must be True.")
place = set_device("gpu" if args.use_cuda else "cpu")
fluid.enable_dygraph(place)
processor = EmoTectProcessor(data_dir=args.data_dir,
vocab_path=args.vocab_path,
random_seed=args.random_seed)
num_labels = args.num_labels
if args.model_type == 'cnn_net':
model = CNN(args.vocab_size, args.max_seq_len)
elif args.model_type == 'bow_net':
model = BOW(args.vocab_size, args.max_seq_len)
elif args.model_type == 'lstm_net':
model = LSTM(args.vocab_size, args.max_seq_len)
elif args.model_type == 'gru_net':
model = GRU(args.vocab_size, args.max_seq_len)
elif args.model_type == 'bigru_net':
model = BiGRU(args.vocab_size, args.batch_size, args.max_seq_len)
else:
raise ValueError("Unknown model type!")
inputs = [Input([None, args.max_seq_len], 'int64', name='doc')]
optimizer = None
labels = None
if args.do_train:
train_data_generator = processor.data_generator(
batch_size=args.batch_size,
places=place,
phase='train',
epoch=args.epoch,
padding_size=args.max_seq_len)
num_train_examples = processor.get_num_examples(phase="train")
max_train_steps = args.epoch * num_train_examples // args.batch_size + 1
print("Num train examples: %d" % num_train_examples)
print("Max train steps: %d" % max_train_steps)
labels = [Input([None, 1], 'int64', name='label')]
optimizer = fluid.optimizer.Adagrad(learning_rate=args.lr,
parameter_list=model.parameters())
test_data_generator = None
if args.do_val:
test_data_generator = processor.data_generator(
batch_size=args.batch_size,
phase='dev',
epoch=1,
places=place,
padding_size=args.max_seq_len)
elif args.do_val:
test_data_generator = processor.data_generator(
batch_size=args.batch_size,
phase='test',
epoch=1,
places=place,
padding_size=args.max_seq_len)
elif args.do_infer:
infer_data_generator = processor.data_generator(
batch_size=args.batch_size,
phase='infer',
epoch=1,
places=place,
padding_size=args.max_seq_len)
model.prepare(optimizer,
CrossEntropy(),
Accuracy(topk=(1, )),
inputs,
labels,
device=place)
if args.do_train:
if args.init_checkpoint:
model.load(args.init_checkpoint)
elif args.do_val or args.do_infer:
if not args.init_checkpoint:
raise ValueError("args 'init_checkpoint' should be set if"
"only doing validation or infer!")
model.load(args.init_checkpoint, reset_optimizer=True)
if args.do_train:
model.fit(train_data=train_data_generator,
eval_data=test_data_generator,
batch_size=args.batch_size,
epochs=args.epoch,
save_dir=args.checkpoints,
eval_freq=args.eval_freq,
save_freq=args.save_freq)
elif args.do_val:
eval_result = model.evaluate(eval_data=test_data_generator,
batch_size=args.batch_size)
print("Final eval result: acc: {:.4f}, loss: {:.4f}".format(
eval_result['acc'], eval_result['loss'][0]))
elif args.do_infer:
preds = model.predict(test_data=infer_data_generator)
preds = np.array(preds[0]).reshape((-1, args.num_labels))
if args.output_dir:
with open(os.path.join(args.output_dir, 'predictions.json'),
'w') as w:
for p in range(len(preds)):
label = np.argmax(preds[p])
result = json.dumps({
'index': p,
'label': label,
'probs': preds[p].tolist()
})
w.write(result + '\n')
print('Predictions saved at ' +
os.path.join(args.output_dir, 'predictions.json'))
