def main(_):
print("Start preprocessing data...")
if FLAGS.actions == "random":
data = data_preprocessing.data_prep(FLAGS.dataset, FLAGS.num_actions,
FLAGS.total_num_actions)
else:
actions = FLAGS.actions.split(",")
data = data_preprocessing.data_prep(FLAGS.dataset, FLAGS.num_actions,
FLAGS.total_num_actions, actions)
video_dir = os.path.normpath(
os.path.join(FLAGS.video_dir, FLAGS.dataset,
"{0}_actions".format(FLAGS.num_actions),
'_'.join(data.actions)))
tf.reset_default_graph()
print("Create model...")
model = seq2seq_model.Seq2SeqModel(len(data.dim_use), FLAGS.source_seq_len,
FLAGS.target_seq_len, FLAGS.rnn_size,
FLAGS.batch_size, FLAGS.learning_rate)
sess = training.get_session()
#perform segmentations with pre-trained model
if FLAGS.load > 0:
model = training.load_model(sess, model, train_dir, FLAGS.load)
else:
#train new model
if FLAGS.load <= 0:
current_step = 0
print("Creating model with fresh parameters.")
sess.run(tf.global_variables_initializer())
#continue training given a checkpoint
else:
current_step = FLAGS.load + 1
model = training.load_model(sess, model, train_dir, FLAGS.load)
print("Training is in process...")
training.train_model(sess, model, train_dir, data, model.batch_size,
current_step, FLAGS.iterations)
print("Finding temporal segments...")
test_states, all_states, cuts = segmentation.find_cuts(
sess, model, data.norm_complete_train)
print("Doing clustering...")
pred_labels, reduced_states, labels_true, all_labels = segmentation.clustering(
model, cuts, test_states, all_states, data.trainData,
FLAGS.num_actions)
labels_true, labels_pred = segmentation.order_labels(
labels_true, all_labels)
colors = viz.get_color(labels_true)
xyz_gt = get_gt(data.complete_train)
print("Generate results...")
print("length of gt:{0}, pred:{1},reduced:{2}:".format(
len(labels_true), len(labels_pred), len(reduced_states)))
generate_video(video_dir, labels_true, labels_pred, xyz_gt, reduced_states,
colors, FLAGS.gen_video)
def kfold(dataset, config, train_id, num_completed=0):
# Initialize the model
model = load_model(config["model"])
logging.info("Total Data: %s samples" % len(dataset))
logging.info("Running %sfold validation" % config["kfold"])
best_vals = []
completed = set(range(num_completed))
for i, (train_data, val_data) in enumerate(
dataset.kfold(k=config["kfold"],
shuffle=True,
seed=np.random.randint(2**32))):
if i in completed:
continue
logging.info("Training Fold%s" % (i + 1))
train_id = train_id + "_fold%s" % i
# TODO add load model functinoality
model, tr_logs, val_logs = train_model(model,
train_id,
config["optimizer"],
train_data,
val_data,
epochs=config["epochs"],
batch_size=config["batch_size"],
plot=PLOT,
load_model=False)
best_vals.append(min(val_logs['loss']))
logging.info("Average val loss: %s" % (sum(best_vals) / len(best_vals)))
return model
def __init_tacotron(self, tacotron_model_path, map_location):
temp_model = torch.load(tacotron_model_path, map_location=map_location)
state_dict = temp_model['state_dict']
# load trained tacotron 2 model:
hparams = tacotron_params
model = load_model(hparams)
model.load_state_dict(state_dict)
_ = model.eval()
return model
def instantiate_players(mode):
full_mode_name = {
'dd': 'two dummies',
'hd': 'human vs dummy',
'ai': 'ai vs dummy'
}
print("Game mode:", full_mode_name[mode], '\n')
instructions_for_creation = {
'dd': [DummyPlayer(name) for name in NAMES_FOR_TESTING],
'hd': [
combatent(NAMES_FOR_TESTING[i])
for i, combatent in enumerate([HumanPlayer, DummyPlayer])
],
'ai': [
AiPlayer(NAMES_FOR_TESTING[0], load_model(NAMES_FOR_TESTING[0])),
AiPlayer(NAMES_FOR_TESTING[1], load_model(NAMES_FOR_TESTING[1]))
]
}
pair_of_players = instructions_for_creation[mode]
relate_opponents(pair_of_players)
return pair_of_players
def test(dataset, test_img_sizes, config, train_id, model=None):
if model is None:
model = load_model(config["model"])
if not config["kfold"]:
raise NotImplementedError("Non-kfold testing is not implemented")
predictions = 0.
for i in range(config["kfold"]):
logging.info("Predicting fold %s/%s" % (i + 1, config["kfold"]))
predictions = predictions + test_model(model, train_id + "_fold%s" % i,
dataset, config["batch_size"])
predictions = predictions / config["kfold"]
_, _, _, submission_file = create_filenames(train_id)
# Make the submission
dsb.save_submission(dataset.ids, expit(predictions), test_img_sizes,
submission_file)
from text import text_to_sequence
import sys
sys.path.append('waveglow/')
predicted_melspec_folder = '/homedtic/apeiro/GST_Tacotron2_pitch_intensity_contour_sparse_SoftMax/Predicted_melspec/'
audio_path = '/homedtic/apeiro/GST_Tacotron2_pitch_intensity_contour_sparse_SoftMax/Synth_wavs/'
common_clip_name = '_78000steps_softmax_3tokens_'
hparams = tacotron_params
MAX_WAV_VALUE = 32768.0
# load trained tacotron 2 model:
checkpoint_path = "outputs/checkpoint_78000"
model = load_model(hparams)
model.load_state_dict(torch.load(checkpoint_path)['state_dict'])
_ = model.eval()
# load pre trained waveglow model for mel2audio:
waveglow_path = 'waveglow/waveglow_old.pt'
waveglow = torch.load(waveglow_path)['model']
waveglow.cuda()
'''
# short sentences:
test_text_short = ("That is not only my accusation.",
"provided by other agencies.",
"There were others less successful.")
# medium sentences:
def main(args=None):
'''
Initializes and trains model with its specified configuration,
evaluates each on the test set, and records its performance to
tensorboard.
'''
print("Using GPU: {}".format(torch.cuda.is_available()))
model = getattr(training.Models, Constants.model_str)
optimizer = training.init_optimizer(model, args.optimizer)
loss_func = torch.nn.CrossEntropyLoss()
# handle model loading, if the flag is set
if args.load_model == "wide-resnet":
model = torchvision.models.wide_resnet50_2(pretrained=False,
progress=True)
elif args.load_model:
model, optimizer, pretrained_epochs, loss = training.load_model(
args.load_model, model, optimizer)
print("Loaded model with {} epochs and {} loss.".format(
pretrained_epochs, loss))
Constants.save_str = display.build_model_save_str(args)
writer = SummaryWriter(
Path(__file__).parent.parent / "runs" / Constants.save_str)
train_dlr, valid_dlr, test_dlr = data_loading.build_wrapped_dl(
args.augmentation, args.dataset, verbose=args.verbose)
bar = progressbar.ProgressBar(max_value=args.epochs * len(train_dlr) *
Constants.batch_size,
max_error=False)
# show images and model graph
images, _ = iter(train_dlr).__next__()
display.show_images(writer,
images,
Constants.batch_size,
title="Images",
verbose=args.verbose)
display.show_graph(writer, model, images)
print(
'Training {} model with a \'{}\' optimization and \'{}\' augmentation over {} epochs'
.format(Constants.model_str, args.optimizer, args.augmentation,
args.epochs),
file=open(
Path(__file__).parent.parent / "logs" /
'{}.txt'.format(Constants.save_str), 'a'))
try: # run, log training
for epoch in range(args.epochs):
with torch.no_grad(): # validation
validation_acc, validation_loss = training.run_epoch(
model,
loss_func,
valid_dlr,
verbose=args.verbose,
fast=args.fast)
# training
train_acc, train_loss = training.run_epoch(model, loss_func,
train_dlr, epoch, bar,
optimizer, args.verbose,
args.fast)
display.write_epoch_stats(writer, epoch, validation_acc,
validation_loss, train_acc, train_loss)
except: # gracefully handle crashes during training
training.save_model(model, optimizer, train_loss,
"CRASH-{}".format(Constants.save_str), epoch)
raise Exception(
'Error on epoch {} of training. Data dumped.'.format(epoch))
if args.save_model:
training.save_model(model, optimizer, train_loss, Constants.save_str,
args.epochs)
test_acc, _ = training.run_epoch(model,
loss_func,
test_dlr,
verbose=args.verbose,
fast=args.fast)
display.print_final_model_stats(train_acc, validation_acc, test_acc)
writer.close()
def main(args):
if args.test:
print("Testing mode.")
args.fast = 1
args.choices = 20
args.setsize = 1
if not args.load_model:
saved_models_path = Path(
__file__).parent.parent.resolve().parent / 'saved_models'
model_path = saved_models_path / saved_models_path.iterdir().__next__(
).name
else:
model_path = Path(
__file__).parent.parent.resolve().parent / args.load_model
print("Using evaluator model: {}".format(model_path))
# load evaluator model
model = getattr(training.Models, Constants.model_str)
model, _, epoch, loss = training.load_model(model_path, model)
loss_func = torch.nn.CrossEntropyLoss()
GMaxupConsts.save_str = display.build_gmaxup_save_str(args)
writer = SummaryWriter(
Path(__file__).parent / '../runs/{}'.format(GMaxupConsts.save_str))
# dictionary containing statistics on which transformations gmaxup selects
augment_stats = {}
for _, _, _, augment_str in augmentations.augment_list(args.range):
augment_stats[augment_str] = {
"count": 0,
"average_loss": 0.0,
"incorrect_preds": 0,
"average_mag": 0
}
augmented_batch = []
# initializes loading bar
dataset_batches = GMaxupConsts.dataset_batches_dict[args.dataset]
samples_per_batch = args.fast if args.fast else GMaxupConsts.samples_per_batch
bar = progressbar.ProgressBar(max_value=len(dataset_batches) *
samples_per_batch,
max_error=False)
# iterates through all batches of the dataset
for batch_num, curr_batch_str in enumerate(dataset_batches):
images, labels = data_loading.load_data_by_path(
Path(__file__).parent.parent.resolve().parent / 'saved_data' /
args.dataset / curr_batch_str)
# iterates through all samples in a batch
for sample_num, (x, y) in enumerate(zip(images, labels)):
if sample_num < samples_per_batch: # early exit if -f
run_gmaxup_on_sample(sample_num, x, y, loss_func, model,
augmented_batch, args, augment_stats,
writer)
bar.update(batch_num * samples_per_batch + sample_num)
for key in augment_stats:
if augment_stats[key]["count"] > 0:
augment_stats[key]["average_loss"] /= augment_stats[key][
"count"]
augment_stats[key]["average_mag"] /= augment_stats[key][
"count"]
if args.test:
break
augmented_cifar10_ds = data_loading.DatasetFromTupleList(augmented_batch)
with open(
Path(__file__).parent.parent / "gmaxup_data" /
GMaxupConsts.save_str, 'wb') as handle:
pickle.dump(augmented_cifar10_ds,
handle,
protocol=pickle.HIGHEST_PROTOCOL)
display.print_augment_stats(augment_stats)
nEpochs=st.sidebar.slider('Training Epochs', value=35, min_value=1, max_value=100),
lr=0.001,
seed=123,
)
st.sidebar.markdown("## Hardware Options")
device_opts = DeviceOptions(
cuda=st.sidebar.checkbox('Use CUDA', value=False),
threads=st.sidebar.slider('Dataloader Threads', value=4, min_value=1, max_value=16),
batchSize=st.sidebar.slider('Training Batch Size', value=4, min_value=1, max_value=256),
testBatchSize=st.sidebar.slider('Testing Batch Size', value=100, min_value=1, max_value=256),
)
st.code(f"Using: upscale={training_opts.upscale_factor}x, "
f"nEpochs={training_opts.nEpochs}")
model = load_model(training_opts, device_opts)
input_image = st.file_uploader("Upload an image", ["png", "jpg"], encoding=None)
if input_image is None:
input_image = 'leon.png'
st.image(open_image(input_image))
st.write('Super Resolution:')
st.image(super_resolve(model, input_image, False))
st.write('Naive Upscale:')
st.image(resize_naive(input_image, training_opts.upscale_factor))
from combatents import AiPlayer
from match import Match
from training import load_model, MatchThread
from tqdm import tqdm
CYCLES = 500
NUM_THREADS = 20
NAMES = ['Carlos', 'Emar']
win_register = {name: 0 for name in NAMES}
win_register[None] = 0
models = [load_model(name) for name in NAMES]
for i in tqdm(range(CYCLES)):
matches = [
Match([AiPlayer(NAMES[i], models[i]) for i in range(2)])
for _ in range(NUM_THREADS)
]
threads = [MatchThread(match) for match in matches]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
for match in matches:
win_register[match.get_winner().name] += 1
for name in NAMES:
print(f"{name}'s win count: {win_register[name]}.")
# prepare image generator
real_gen = ImageDataGenerator(rescale=None, preprocessing_function=pre)
# train model
train(wgan, latent_dim, n_epochs, n_epochs, n_batch, n_blocks,
real_gen, DATA_DIR, SAVE_DIR, args.dynamic_resize)
elif mode == 'resume':
g_model_dir = args.g_model_path
d_model_dir = args.d_model_path
# size of the latent space
latent_dim = 512
wgan, n_blocks, cur_block = load_model(g_model_dir, d_model_dir,
latent_dim)
print('loaded')
# prepare image generator
real_gen = ImageDataGenerator(rescale=None, preprocessing_function=pre)
# train model
if not args.extra_epochs:
train(wgan, latent_dim, n_epochs, n_epochs, n_batch, int(n_blocks),
real_gen, DATA_DIR, SAVE_DIR, args.dynamic_resize,
int(cur_block))
else:
extra_epochs(wgan, latent_dim, n_epochs, n_epochs, n_batch,
int(n_blocks), real_gen, DATA_DIR, SAVE_DIR,
args.dynamic_resize, int(cur_block))
train(wgan, latent_dim, n_epochs, n_epochs, n_batch, int(n_blocks),
