def main(args):
scores_rl = []
scores_randomforest = []
for _ in range(3):
utils.prepare_dirs(args)
utils.save_args(args)
# max_step = range(100,1000,100)
dataset = get_dataset(args.dataset)
maxscore_randomforest = randomforest(dataset)
scores_randomforest.append(maxscore_randomforest)
# scores_autosklearn = auto_sklearn(dataset)
# scores_tpot = tpot_(dataset)
trnr = trainer.Trainer(dataset,
args.n_tranformers,
args.n_scalers,
args.n_constructers,
args.n_selecters,
args.n_models,
args.lstm_size,
args.temperature,
args.tanh_constant,
args.save_dir,
func_names=func_names,
model_dir=args.model_dir,
log_step=args.log_step,
controller_max_step=args.controller_max_step)
bset = trnr.train_controller()
scores_rl.append(bset)
print(bset)
print(scores_rl)
# method_names = ['RandomForest', 'AutoSklearn', 'TPOT', 'RL']
# result_map = {'RandomForest': scores_randomforest, 'AutoSklearn':scores_autosklearn,
# 'TPOT': scores_tpot, 'RL': scores_rl}
result_map = {'RandomForest': scores_randomforest, 'RL': scores_rl}
df = pd.DataFrame(data=result_map)
path = os.path.join(args.model_dir, 'df.csv')
df.to_csv(path)
def main(_):
#Directory generating.. for saving
prepare_dirs(config)
#Random seed settings
rng = np.random.RandomState(config.random_seed)
tf.set_random_seed(config.random_seed)
#Model training
trainer = Trainer(config, rng)
save_config(config.model_dir, config)
if config.is_train:
trainer.train()
else:
if not config.load_path:
raise Exception("[!] You should specify `load_path` to "
"load a pretrained model")
trainer.test()
def main(_):
config, unparsed = get_config()
prepare_dirs(config)
#rng = np.random.RandomState(config.random_seed)
#tf.set_random_seed(config.random_seed)
trainer = Trainer(config)
#writer = tf.summary.FileWriter('dbg_logs', sess.graph)
#[n.name for n in sess.graph.as_graph_def().node]
#save_config(config.model_dir, config)
if config.is_train:
trainer.train()
else:
if not config.load_path:
raise Exception(
"[!] You should specify `load_path` to load a pretrained model"
)
trainer.test()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir', default='logs')
parser.add_argument('--data_paths', default='datasets/kr_example')
parser.add_argument('--load_path', default=None)
parser.add_argument('--initialize_path', default=None)
parser.add_argument('--num_test_per_speaker', type=int, default=2)
parser.add_argument('--random_seed', type=int, default=123)
parser.add_argument('--summary_interval', type=int, default=100)
parser.add_argument('--test_interval', type=int, default=500)
parser.add_argument('--checkpoint_interval', type=int, default=1000)
parser.add_argument('--skip_path_filter',
type=str2bool, default=False, help='Use only for debugging')
parser.add_argument('--slack_url',
help='Slack webhook URL to get periodic reports.')
parser.add_argument('--git', action='store_true',
help='If set, verify that the client is clean.')
config = parser.parse_args()
config.data_paths = config.data_paths.aplit(",")
setattr(hparams, "num_sepakers", len(config.data_paths))
prepare_dirs(config, hparams)
log_path = os.path.join(config.model_dir, 'train.log')
infolog.init(log_path, config.model_dir, config.slack_url)
tf.set_random_seed(config.random_seed)
if any("krbook" not in data_path for data_path in config.data_paths) and \
hparams.sample_rate != 20000:
warning("Detect non-krbook dataset. Set sampling rate from {} to 20000.".\
format(hparams.sample_rate))
if config.load_path is not None and config.initialize_path is not None:
raise Excpetion(" [!] Only one of load_path and initialize_path should be set")
train(config.model_dir, config)
def main():
prepare_dirs(config)
rng = np.random.RandomState(config.random_seed) # 123
tf.set_random_seed(config.random_seed)
model = Trainer(config, rng)
latest_checkpoint = tf.train.latest_checkpoint(config.model_dir)
trainer.saver.restore(sess, latest_checkpoint)
with DeepExplain(session=sess) as de:
logits = trainer.model
xi, yi = trainer.data_loader.next_batch(0)
reshaped = xi.reshape([
trainer.config.batch_size, trainer.config.num_time_steps,
trainer.config.feat_in, trainer.config.num_node
])
# [20,50,1,50]->[20,50,1,50] batchsize,num_node,1,numtime_steps
xi = np.transpose(reshaped, (0, 3, 2, 1))
# x = np.reshape(xi[0, :, :, 0], [110, 2])
yreshaped = yi.reshape([
trainer.config.batch_size, trainer.config.num_time_steps,
trainer.config.feat_in, trainer.config.num_node
])
yi = np.transpose(yreshaped, (0, 3, 2, 1))
# y = np.reshape(yi[0, :, :, 0], [110, 2])
applyy = tf.multiply(logits, yi)
print("[*] Checking if previous run exists in {}"
"".format(trainer.config.model_dir))
latest_checkpoint = tf.train.latest_checkpoint(trainer.model_dir)
trainer.saver.restore(sess, latest_checkpoint) # 加载到当前环境中
print("[*] Saved result exists! loading...")
print("asdfghjklweeeeeerty")
print(logits)
# data_loader=BatchLoader(data_dir, dataset_name,
# batch_size, num_time_steps)
print("ok")
attributions = de.explain('grad*input', applyy,
trainer.model.rnn_input_seq, xi)
np.savetxt('0_features.csv', attributions[0], delimiter=', ')
print('Done')
def main(config):
# ensure directories are setup
prepare_dirs(config)
# ensure reproducibility
#torch.manual_seed(config.random_seed)
kwargs = {}
if config.use_gpu:
#torch.cuda.manual_seed_all(config.random_seed)
kwargs = {
'num_workers': config.num_workers,
'pin_memory': config.pin_memory
}
#torch.backends.cudnn.deterministic = True
# instantiate data loaders
test_data_loader = get_test_loader(config.data_dir, config.batch_size,
**kwargs)
if config.is_train:
train_data_loader = get_train_loader(config.data_dir,
config.batch_size,
config.random_seed,
config.shuffle, **kwargs)
data_loader = (train_data_loader, test_data_loader)
else:
data_loader = test_data_loader
# instantiate trainer
trainer = Trainer(config, data_loader)
# either train
if config.is_train:
save_config(config)
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main(config):
# ensure data directories are set up
write_torch_dataset(config.modelnet_dir)
# ensure directories are set up
prepare_dirs(config)
# ensure reproducibility
torch.manual_seed(config.random_seed)
kwargs = {}
if config.use_gpu:
torch.cuda.manual_seed(config.random_seed)
kwargs = {'num_workers': 1, 'pin_memory': True}
# instantiate data loaders
if config.is_train:
data_loader = get_train_valid_loader(
config.partition_dict, config.labels_dict,
config.batch_size, config.random_seed,
config.valid_size, config.shuffle, config.show_sample,
**kwargs
)
else:
data_loader = get_test_loader(
config.partition_dict, config.labels_dict,
config.batch_size,
**kwargs
)
# instantiate trainer
trainer = Trainer(config, data_loader)
# either train
if config.is_train:
save_config(config)
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main(config):
utils.prepare_dirs(config)
# ensure reproducibility
torch.manual_seed(config.random_seed)
kwargs = {"num_workers": config.num_workers}
if config.use_gpu:
torch.cuda.manual_seed(config.random_seed)
kwargs = {"num_workers": config.num_workers, "pin_memory": True}
# instantiate data loaders
if config.is_train:
dloader = data_loader.get_train_valid_loader(
config.data_dir,
config.batch_size,
config.random_seed,
config.valid_size,
config.shuffle,
config.show_sample,
**kwargs,
)
else:
dloader = data_loader.get_test_loader(
config.data_dir,
config.batch_size,
**kwargs,
)
cls_train = Trainer
if config.train_dynamic:
cls_train = TrainerDynamic
trainer = cls_train(config, dloader)
# either train
if config.is_train:
utils.save_config(config)
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main(args): # pylint:disable=redefined-outer-name
"""main: Entry point."""
utils.prepare_dirs(args) #data_dir="./data/ptb"
torch.manual_seed(args.random_seed)
if args.num_gpu > 0:
#Sets the seed for generating random numbers for the current GPU. It’s safe to call this function if CUDA is not available; in that case, it is silently ignored.
torch.cuda.manual_seed(args.random_seed)
if args.network_type == 'rnn':
dataset = data.text.Corpus(args.data_path) #将文本数据读入字典，生成词对应的序号的Tensor
elif args.dataset == 'cifar':
dataset = data.image.Image(args.data_path)
else:
raise NotImplementedError("{}is not supported".format(args.dataset))
trnr = trainer.Trainer(args, dataset)
if args.mode == 'train':
utils.save_args(args)
trnr.train()
elif args.mode == 'derive':
assert args.load_path != "", (
"`--load_path` should be given in `derive` mode")
trnr.derive()
elif args.mode == 'test':
if not args.load_path:
raise Exception(
"[!] You should specify `load_path` to load a pretrained model"
)
trnr.test()
elif args.mode == 'single':
if not args.dag_path:
raise Exception("[!] You should specify `dag_path` to load a dag")
utils.save_args(args)
trnr.train(single=True)
else:
raise Exception("[!] Mode not found: {}".format(args.mode))
def main(_):
# for rm in [0.5]:
# for ds_ind in range(1):
for rm in [0.6, 0.7, 0.8]:
for ds_ind in range(5):
config.data_rm = rm
config.ds_ind = ds_ind
#Directory generating.. for saving
prepare_dirs(config)
prepare_config_date(config, config.ds_ind)
#Random seed settings
rng = np.random.RandomState(config.random_seed)
tf.set_random_seed(config.random_seed)
#Model training
trainer = Trainer(config, rng)
save_config(config.model_dir, config)
config.load_path = config.model_dir
if config.is_train:
trainer.train(save=False)
result_dict = trainer.test()
else:
if not config.load_path:
raise Exception("[!] You should specify `load_path` to "
"load a pretrained model")
result_dict = trainer.test()
save_results(config.result_dir, result_dict)
accept_rate = evaluate_result(result_dict,
method='KS-test',
alpha=0.05)
kl_div = evaluate_result(result_dict, method='KL')
wasser_dis = evaluate_result(result_dict, method='wasser')
sig_test = evaluate_result(result_dict, method='sig_test')
print("The accept rate of KS test is ", accept_rate)
print("The final KL div is ", kl_div)
print("The wasser distance is ", wasser_dis)
print("The AR of Sign Test is ", sig_test)
def main(args): # pylint:disable=redefined-outer-name
"""main: Entry point."""
utils.prepare_dirs(args)
torch.manual_seed(args.random_seed)
if args.num_gpu > 0:
torch.cuda.manual_seed(args.random_seed)
if args.network_type == 'rnn':
dataset = data.text.Corpus(args.data_path)
elif args.dataset == 'cifar':
#dataset = data.image.Image(args.data_path)
dataset = data.image.Image(args)
else:
raise NotImplementedError(f"{args.dataset} is not supported")
trnr = trainer.Trainer(args, dataset)
if args.mode == 'train':
utils.save_args(args)
trnr.train()
elif args.mode == 'derive':
assert args.load_path != "", ("`--load_path` should be given in "
"`derive` mode")
trnr.derive()
elif args.mode == 'test':
if not args.load_path:
raise Exception("[!] You should specify `load_path` to load a "
"pretrained model")
trnr.test()
elif args.mode == 'single':
if not args.dag_path:
raise Exception("[!] You should specify `dag_path` to load a dag")
utils.save_args(args)
trnr.train(single=True)
else:
raise Exception(f"[!] Mode not found: {args.mode}")
def main(args): # pylint:disable=redefined-outer-name
"""main: Entry point."""
utils.prepare_dirs(args)
torch.manual_seed(args.random_seed)
trnr = trainer.Trainer(args)
if args.mode == 'train':
utils.save_args(args)
trnr.train()
elif args.mode == 'derive':
assert args.load_path != "", ("`--load_path` should be given in "
"`derive` mode")
trnr.derive()
elif args.mode == 'single':
if not args.dag_path:
raise Exception("[!] You should specify `dag_path` to load a dag")
utils.save_args(args)
trnr.train(single=True)
else:
raise Exception(f"[!] Mode not found: {args.mode}")
def main(config):
# ensure directories are setup
prepare_dirs(config)
# ensure reproducibility
torch.manual_seed(config.random_seed)
kwargs = {}
if config.use_gpu:
torch.cuda.manual_seed(config.random_seed)
kwargs = {'num_workers': 1, 'pin_memory': True}
# instantiate data loaders
if config.is_train:
data_loader = get_train_valid_loader(config.data_dir,
config.batch_size,
config.random_seed,
config.valid_size, config.shuffle,
config.show_sample, **kwargs)
else:
data_loader = get_test_loader(config.data_dir, config.batch_size,
**kwargs)
wandb.config.learned_state = config.learned_start
wandb.config.random_seed = config.random_seed
wandb.config.task = 'malaria'
wandb.config.std = config.std
# instantiate trainer
trainer = Trainer(config, data_loader)
# either train
if config.is_train:
save_config(config)
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main(args): # pylint:disable=redefined-outer-name
"""main: Entry point."""
utils.prepare_dirs(args)
torch.manual_seed(args.random_seed)
if args.num_gpu > 0:
torch.cuda.manual_seed(args.random_seed)
if args.network_type == 'rnn':
assert args.network_type in ('rnn', 'cnn')
dataset = data.text.Corpus(args.data_path)
elif args.dataset == 'cifar':
args.network_type in ('rnn', 'cnn')
dataset = data.image.Image(args)
else:
args.network_type not in ('rnn', 'cnn')
dataset = data.tabular.Tabular(args)
if args.network_type in ('rnn', 'cnn'):
trnr = trainer.Trainer(args, dataset)
else:
trnr = trainer2.Trainer(args, dataset)
if args.mode == 'train':
utils.save_args(args)
trnr.train()
elif args.mode == 'derive':
assert args.load_path != "", ("`--load_path` should be given in "
"`derive` mode")
trnr.derive()
else:
if not args.load_path:
raise Exception("[!] You should specify `load_path` to load a "
"pretrained model")
trnr.test()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir', default='logdir-tacotron')
parser.add_argument('--data_paths', default='.\\data\\moon,.\\data\\son')
parser.add_argument('--load_path',
default=None) # 아래의 'initialize_path'보다 우선 적용
#parser.add_argument('--load_path', default='logdir-tacotron/moon+son_2018-12-25_19-03-21')
parser.add_argument(
'--initialize_path',
default=None) # ckpt로 부터 model을 restore하지만, global step은 0에서 시작
parser.add_argument('--batch_size', type=int, default=32)
parser.add_argument('--num_test_per_speaker', type=int, default=2)
parser.add_argument('--random_seed', type=int, default=123)
parser.add_argument('--summary_interval', type=int, default=100000)
parser.add_argument('--test_interval', type=int, default=500) # 500
parser.add_argument('--checkpoint_interval', type=int,
default=2000) # 2000
parser.add_argument('--skip_path_filter',
type=str2bool,
default=False,
help='Use only for debugging')
parser.add_argument('--slack_url',
help='Slack webhook URL to get periodic reports.')
parser.add_argument(
'--git',
action='store_true',
help='If set, verify that the client is clean.'
) # The store_true option automatically creates a default value of False.
config = parser.parse_args()
config.data_paths = config.data_paths.split(",")
setattr(hparams, "num_speakers", len(config.data_paths))
prepare_dirs(config, hparams)
log_path = os.path.join(config.model_dir, 'train.log')
infolog.init(log_path, config.model_dir, config.slack_url)
tf.set_random_seed(config.random_seed)
print(config.data_paths)
if any("krbook" not in data_path for data_path in
config.data_paths) and hparams.sample_rate != 20000:
warning(
"Detect non-krbook dataset. May need to set sampling rate from {} to 20000"
.format(hparams.sample_rate))
if any('LJ' in data_path for data_path in
config.data_paths) and hparams.sample_rate != 22050:
warning("Detect LJ Speech dataset. Set sampling rate from {} to 22050".
format(hparams.sample_rate))
if config.load_path is not None and config.initialize_path is not None:
raise Exception(
" [!] Only one of load_path and initialize_path should be set")
train(config.model_dir, config)
__author__ = 'Weili Nie'
import os
from MNIST import GAN_MNIST
from CelebA import GAN_CelebA
from GMM import GAN_GMM
from RenderData import GAN_RenderData
from config import get_config
from utils import prepare_dirs
config, unparsed = get_config()
os.environ['CUDA_VISIBLE_DEVICES'] = config.gpus
prepare_dirs(config, config.dataset_img)
if config.dataset_img == 'CelebA':
gan_model = GAN_CelebA.GAN_model(config)
elif config.dataset_img == 'MNIST':
gan_model = GAN_MNIST.GAN_model(config)
elif config.dataset_img == 'GMM':
gan_model = GAN_GMM.GAN_model(config)
elif config.dataset_img in ['RenderBall', 'RenderBallTri']:
gan_model = GAN_RenderData.GAN_model(config)
else:
raise Exception("[!] Unrecognized dataset_name!")
if config.is_train:
gan_model.train()
else:
if not config.load_path:
raise Exception(
"[!] You should specify `load_path` to load a pretrained model")
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir', default='logdir-tacotron2')
# C:\Users\ibk\Tacotron2-Wavenet-Korean-TTS\datasets\LJSpeech_1_0\data
parser.add_argument(
'--data_paths',
default=
'C:\\Users\\ibk\\Tacotron2-Wavenet-Korean-TTS\\datasets\\LJSpeech_1_0\\data'
)
#parser.add_argument('--data_paths', default='D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\moon,D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\son')
#parser.add_argument('--data_paths', default='D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\small1,D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\small2')
parser.add_argument('--load_path',
default=None) # 아래의 'initialize_path'보다 우선 적용
#parser.add_argument('--load_path', default='logdir-tacotron2/moon+son_2019-03-01_10-35-44')
parser.add_argument(
'--initialize_path',
default=None) # ckpt로 부터 model을 restore하지만, global step은 0에서 시작
parser.add_argument('--batch_size', type=int, default=32)
parser.add_argument('--num_test_per_speaker', type=int, default=1)
parser.add_argument('--random_seed', type=int, default=123)
parser.add_argument('--summary_interval', type=int, default=100)
parser.add_argument('--test_interval', type=int, default=500) # 500
parser.add_argument('--checkpoint_interval', type=int,
default=2000) # 2000
parser.add_argument('--skip_path_filter',
type=str2bool,
default=False,
help='Use only for debugging')
parser.add_argument('--slack_url',
help='Slack webhook URL to get periodic reports.')
parser.add_argument(
'--git',
action='store_true',
help='If set, verify that the client is clean.'
) # The store_true option automatically creates a default value of False.
config = parser.parse_args()
config.data_paths = config.data_paths.split(",")
setattr(hparams, "num_speakers", len(config.data_paths))
prepare_dirs(config, hparams)
log_path = os.path.join(config.model_dir, 'train.log')
infolog.init(log_path, config.model_dir, config.slack_url)
tf.set_random_seed(config.random_seed)
print(config.data_paths)
if config.load_path is not None and config.initialize_path is not None:
raise Exception(
" [!] Only one of load_path and initialize_path should be set")
train(config.model_dir, config)
def main(config):
# ensure directories are setup
prepare_dirs(config)
# create Omniglot data loaders
torch.manual_seed(config.random_seed)
kwargs = {}
if config.use_gpu:
torch.cuda.manual_seed(config.random_seed)
kwargs = {'num_workers': 1, 'pin_memory': True}
if config.is_train:
data_loader = get_train_valid_loader(
config.data_dir, config.batch_size,
config.num_train, config.augment,
config.way, config.valid_trials,
config.shuffle, config.random_seed,
**kwargs
)
else:
data_loader = get_test_loader(
config.data_dir, config.way,
config.test_trials, config.random_seed,
**kwargs
)
# sample 3 layer wise hyperparams if first time training
if config.is_train and not config.resume:
print("[*] Sampling layer hyperparameters.")
layer_hyperparams = {
'layer_init_lrs': [],
'layer_end_momentums': [],
'layer_l2_regs': []
}
for i in range(6):
# sample
lr = random.uniform(1e-4, 1e-1)
mom = random.uniform(0, 1)
reg = random.uniform(0, 0.1)
# store
layer_hyperparams['layer_init_lrs'].append(lr)
layer_hyperparams['layer_end_momentums'].append(mom)
layer_hyperparams['layer_l2_regs'].append(reg)
try:
save_config(config, layer_hyperparams)
except ValueError:
print(
"[!] Samples already exist. Either change the model number,",
"or delete the json file and rerun.",
sep=' '
)
return
# else load it from config file
else:
try:
layer_hyperparams = load_config(config)
except FileNotFoundError:
print("[!] No previously saved config. Set resume to False.")
return
trainer = Trainer(config, data_loader, layer_hyperparams)
if config.is_train:
trainer.train()
else:
trainer.test()
plot_spectrogram_to_numpy("reconstruction", outputs['recon'][0].numpy().T),
epoch)
if __name__=="__main__":
def parse_args():
parser = argparse.ArgumentParser(description="")
parser.add_argument('--name', type=str, default="test")
parser.add_argument('--save_path', type=str, default="/hd0/voice_mixer/VAEAutoVC/")
parser.add_argument('--data_dir', type=str, default='/hd0/voice_mixer/preprocessed/VCTK20_f0_norm_all/seen')
args = parser.parse_args()
return args
args = parse_args()
model_dir, log_dir, sample_dir = prepare_dirs(args)
train_loader, val_loader, testset = prepare_dataloaders(args.data_dir, hparams)
solver = FastVC(model_dir,
log_dir,
sample_dir)
solver.train(
train_loader,
val_loader,
testset,
hparams.nepochs,
hparams.save_every,
verbose=True)
def main(_):
config = load_config(flags.FLAGS.flag_values_dict())
print(config)
if config.prepare:
# load data from original csv
data = load_data(config.raw_data)
# random shuffle the data and split it into train, dev and test
random.shuffle(data)
train_data = data[:int(0.8 * len(data))]
dev_data = data[int(0.8 * len(data)):int(0.9 * len(data))]
test_data = data[int(0.9 * len(data)):]
# save the split data to files
save_data(train_data, os.path.join(config.data_dir, 'train'))
save_data(dev_data, os.path.join(config.data_dir, 'dev'))
save_data(test_data, os.path.join(config.data_dir, 'test'))
# prepare vocab
word_vocab = Vocab(
fins=[os.path.join(config.data_dir, 'train', 'sentences.txt')])
label_vocab = Vocab(
fins=[os.path.join(config.data_dir, 'train', 'labels.txt')])
if not os.path.exists(config.vocab_dir):
os.mkdir(config.vocab_dir)
word_vocab.save_to(os.path.join(config.vocab_dir, 'word_vocab.pkl'))
label_vocab.save_to(os.path.join(config.vocab_dir, 'label_vocab.pkl'))
print('Saving vocab to {}'.format(config.vocab_dir))
# save global config
global_config = {
'train_size': len(train_data),
'dev_size': len(dev_data),
'test_size': len(test_data),
'word_vocab_size': word_vocab.size(),
'label_vocab_size': label_vocab.size()
}
with open(config.global_config, 'w') as f:
json.dump(global_config, f, indent=4)
print('Saving global config to {}'.format(config.global_config))
if config.train:
# modify the config
if config.global_config:
config = load_config(config, config.global_config)
if config.config_path:
config = load_config(config, config.config_path)
# prepare dirs
config = prepare_dirs(config)
# save current config to the experiment directory
with open(os.path.join(config.exp_dir, 'config.json'), 'w') as f:
json.dump(config._asdict(), f, indent=4)
# set logger
set_logger(config)
# load vocab
word_vocab = Vocab()
word_vocab.load_from(os.path.join(config.vocab_dir, 'word_vocab.pkl'))
label_vocab = Vocab()
label_vocab.load_from(os.path.join(config.vocab_dir,
'label_vocab.pkl'))
# load dataset
train_set = build_dataset(config, 'train', word_vocab, label_vocab)
dev_set = build_dataset(config, 'dev', word_vocab, label_vocab)
# build inputs
inputs = build_inputs(train_set.output_types, train_set.output_shapes)
# build model
# model = BaselineModel(config, inputs, word_vocab, label_vocab)
model = build_model(config, inputs, word_vocab, label_vocab)
# train the model
model.train(train_set, dev_set)
if config.predict:
# TODO: finish the predict part
pass
import os
from GLO_model import GLO_model
from config import get_config
from utils import prepare_dirs
config, unparsed = get_config()
os.environ['CUDA_VISIBLE_DEVICES'] = config.gpus
prepare_dirs(config, config.dataset)
glo_model = GLO_model(config)
if config.is_train:
glo_model.train()
else:
if not config.load_path:
raise Exception(
"[!] You should specify `load_path` to load a pretrained model")
glo_model.test()
action='store_true',
help="Skip rotations, for faster runs.")
args = None
try:
if comm.Get_rank() == 0:
# parse the command line
args = parser.parse_args()
finally:
args = comm.bcast(args, root=0)
if args is None:
comm.Abort()
return args
if __name__ == '__main__':
import signal
signal.signal(signal.SIGINT, lambda x, y: sys.exit(0))
# init MPI
comm = MPI.COMM_WORLD
args = parse_arguments(comm)
if comm.Get_rank() == 0:
utils.prepare_dirs(args)
main(args, comm)
@app.route('/css/<path:path>')
def send_css(path):
return send_from_directory(
os.path.join(static_path, 'css'), path)
@app.route('/audio/<path:path>')
def send_audio(path):
return send_from_directory(
os.path.join(static_path, 'audio'), path)
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('--load_path', required=True)
parser.add_argument('--checkpoint_step', default=None, type=int)
parser.add_argument('--num_speakers', default=1, type=int)
parser.add_argument('--port', default=51000, type=int)
parser.add_argument('--debug', default=False, type=str2bool)
parser.add_argument('--is_korean', default=True, type=str2bool)
config = parser.parse_args()
if os.path.exists(config.load_path):
prepare_dirs(config, hparams)
global_config = config
synthesizer.load(config.load_path, config.num_speakers, config.checkpoint_step)
else:
print(" [!] load_path not found: {}".format(config.load_path))
app.run(host='0.0.0.0', port=config.port, debug=config.debug)
default=None,
help='experiment name (default: None)')
p.add_argument('--rootdir',
type=str,
default='./',
help='root directory for saving results (default: ./)')
p.add_argument('--pasta-ip',
type=str,
default=None,
help='ip address for pastalog (default: None)')
if __name__ == '__main__':
args = p.parse_args()
print('... Prepare directories')
dirs = prepare_dirs(args.rootdir, args.name)
if args.model_path:
from keras.models import model_from_json
from net import load_model
print('... Load network from: {}'.format(args.model_path))
model = load_model(args.model_path)
else:
from net import get_model
model = get_model(args.img_size, args.beta, args.kernel_size,
args.nb_filters)
model_definition_file = dirs.modelsdir / 'model.json'
print(
'... Save model architecture to: {}'.format(model_definition_file))
import json
with model_definition_file.open('w') as f:
# Seeds
np.random.seed(params.SEED)
tf.set_random_seed(params.SEED)
params.BATCH_SIZE = args.batch_size
batches = max(covr_ds.get_train_size(),
hide_ds.get_train_size()) // params.BATCH_SIZE
# Paths
params.SCRIPT_PATH = utils.fpath(__file__)
params.CKPT_PATH, params.VISUAL_PATH, params.SUMMARY_PATH, params.LOGGING_PATH = \
utils.prepare_dirs(
params.SCRIPT_PATH, params.GMODE,
{
'model': M.name(),
'batch_size': params.BATCH_SIZE,
'covr_ds': covr_ds.get_name(),
'hide_ds': hide_ds.get_name(),
})
if not (params.CKPT_PATH / params.CKPT_FILE).exists() or not (
params.LOGGING_PATH / params.RT_META_FILE).exists():
params.RESTART = True
print(' model: %s' % M.name())
print('cover dataset: %s' % covr_ds.get_name())
print(' hide dataset: %s' % hide_ds.get_name())
print(' batch size: %s' % params.BATCH_SIZE)
print('batches/epoch: %s' % batches)
print(' max epoch: %s' % params.TRAIN_MAX_EPOCH)
print(' restart: %s' % str(params.RESTART))
def main(config):
# ensure directories are setup
prepare_dirs(config)
# ensure reproducibility
torch.manual_seed(config.random_seed)
kwargs = {}
if config.use_gpu:
torch.cuda.manual_seed(config.random_seed)
kwargs = {'num_workers': 1, 'pin_memory': True}
# instantiate data loaders
if config.dataset == 'mnist':
if config.is_train:
data_loader = get_train_valid_loader(config.data_dir,
config.batch_size,
config.random_seed,
config.valid_size,
config.shuffle,
config.show_sample, **kwargs)
else:
data_loader = get_test_loader(config.data_dir, config.batch_size,
**kwargs)
elif config.dataset == 'celeba':
if config.is_train:
trainer, validator, _ = get_train_celeba_loader(
config.celeba_image_dir, config.attr_path,
config.selected_attrs, config.celeba_crop_size,
config.image_size, config.batch_size, config.mode,
config.num_workers, 0.1, config.show_sample)
data_loader = (trainer, validator)
else:
_, _, data_loader = get_train_celeba_loader(
config.celeba_image_dir, config.attr_path,
config.selected_attrs, config.celeba_crop_size,
config.image_size, config.batch_size, config.mode,
config.num_workers, 0.1, config.show_sample)
elif config.dataset == 'celebhq':
if config.is_train:
trainer, validator, _ = get_train_celebhq_loader(
config.celebhq_image_dir, config.hq_attr_path,
config.selected_attrs, config.celeba_crop_size,
config.image_size, config.batch_size, config.mode,
config.num_workers, 0.1, config.show_sample)
data_loader = (trainer, validator)
else:
_, _, data_loader = get_train_celebhq_loader(
config.celebhq_image_dir, config.hq_attr_path,
config.selected_attrs, config.celeba_crop_size,
config.image_size, config.batch_size, config.mode,
config.num_workers, 0.1, config.show_sample)
# instantiate trainer
trainer = Trainer(config, data_loader)
# either train
if config.is_train:
save_config(config)
trainer.train()
# or load a pretrained model and test
else:
trainer.test()
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--log_dir', default='logdir-tacotron2')
parser.add_argument(
'--data_paths',
default=
'/content/drive/My Drive/stt플젝/data/kss,/content/drive/My Drive/stt플젝/data/inna'
)
#parser.add_argument('--data_paths', default='D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\moon,D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\son')
#parser.add_argument('--data_paths', default='D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\small1,D:\\hccho\\Tacotron-Wavenet-Vocoder-hccho\\data\\small2')
#parser.add_argument('--load_path', default=None) # 아래의 'initialize_path'보다 우선 적용
parser.add_argument(
'--load_path',
default=
'/content/drive/My Drive/stt플젝/logdir-tacotron2/kss+inna_2020-10-20_08-04-45'
)
#parser.add_argument('--load_path', default='logdir-tacotron2/moon+son_2019-03-01_10-35-44')
parser.add_argument(
'--initialize_path',
default=None) # ckpt로 부터 model을 restore하지만, global step은 0에서 시작
#parser.add_argument('--batch_size', type=int, default=32)
parser.add_argument('--batch_size', type=int, default=16)
#parser.add_argument('--batch_size', type=int, default=8)
parser.add_argument('--num_test_per_speaker', type=int, default=2)
parser.add_argument('--random_seed', type=int, default=123)
parser.add_argument('--summary_interval', type=int, default=100)
#parser.add_argument('--test_interval', type=int, default=500) # 500
parser.add_argument('--test_interval', type=int,
default=5000) # 테스트 파일 생성 빈도 5000으로 낮춰서 트레이닝 속도 높이기
#parser.add_argument('--checkpoint_interval', type=int, default=2000) # 2000
parser.add_argument('--checkpoint_interval', type=int,
default=1000) # 1000 # 체크포인트 빈도수 높여서 자주 체크가능하게
parser.add_argument('--skip_path_filter',
type=str2bool,
default=False,
help='Use only for debugging')
parser.add_argument('--slack_url',
help='Slack webhook URL to get periodic reports.')
parser.add_argument(
'--git',
action='store_true',
help='If set, verify that the client is clean.'
) # The store_true option automatically creates a default value of False.
config = parser.parse_args()
config.data_paths = config.data_paths.split(",")
setattr(hparams, "num_speakers", len(config.data_paths))
prepare_dirs(config, hparams)
log_path = os.path.join(config.model_dir, 'train.log')
infolog.init(log_path, config.model_dir, config.slack_url)
tf.set_random_seed(config.random_seed)
print(config.data_paths)
if config.load_path is not None and config.initialize_path is not None:
raise Exception(
" [!] Only one of load_path and initialize_path should be set")
train(config.model_dir, config)
images_batch, label_batch = \
sample_batched['image'], sample_batched['label']
batch_size = len(images_batch)
print('images_batch.shape ', images_batch.shape)
grid = utils.make_grid(torch.from_numpy(np.array(images_batch)))
plt.imshow(grid.numpy().transpose((1, 2, 0)))
#plt.imshow(grid.numpy().transpose((1, 0, 2)))
if __name__ == '__main__':
config, unparsed = get_config()
np.random.seed(config.random_seed)
prepare_dirs(config)
header_file = config.data_dir + '/header.tfl.txt'
log_file = os.path.join(config.model_dir, 'out.txt')
filename = 'image_set.dat'
print(config.data_dir, config.model_dir, header_file, log_file, filename)
resize = Resize(64)
crop = RandomCrop(64)
trotate = RandomRotation()
composed = transforms.Compose([Resize(64), RandomRotation(), Resize(64),
ToTensor(), Normalization()])
dataset = PlanktonDataSet(data_dir=config.data_dir, header_file = header_file,
csv_file=filename, transform=composed) # ,transform=Resize(64)
print('dataset.get_classes_from_file(): ', len(dataset.get_classes_from_file()))
"char accuracy": accuracy[1],
"seq_accuracy": seq_accuracy[1],
"elapsed": tf.timestamp() - start
},
every_n_iter=1000)
return tf.estimator.EstimatorSpec(mode=mode,
train_op=train_op,
loss=loss,
training_hooks=[logging_hook])
#load_path = None # 새로운 training
load_path = 'hccho-ckpt\\DCT-2019-08-03_08-59-35'
#####
load_path, restore_path, checkpoint_path = prepare_dirs(hp, load_path)
#### log 파일 작성
log_path = os.path.join(load_path, 'train.log')
infolog.init(log_path, hp.model_name)
infolog.set_tf_log(load_path) # Estimator --> log 저장
tf.logging.set_verbosity(tf.logging.INFO) # 이게 있어야 train log가 출력된다.
# load data
inputs, targets, word_to_index, index_to_word, VOCAB_SIZE, INPUT_LENGTH, OUTPUT_LENGTH = load_data(
hp) # (50000, 29), (50000, 12)
hp.add_hparam('VOCAB_SIZE', VOCAB_SIZE)
hp.add_hparam('INPUT_LENGTH', INPUT_LENGTH) # 29
hp.add_hparam('OUTPUT_LENGTH', OUTPUT_LENGTH) # 11
def main():
conf = get_config()[0]
prepare_dirs(conf)
conf.is_train = False
kwargs = {}
if conf.use_gpu:
kwargs = {'num_workers': 1, 'pin_memory': True}
batch_size = 1
dataloader = get_test_loader(conf.data_dir, batch_size, **kwargs)
trainer = Trainer(conf, dataloader)
setattr(trainer, 'batch_size', batch_size)
trainer.load_checkpoint(True)
viz_label = []
for i, (x, y) in enumerate(dataloader):
y = y.numpy()[0]
if y in viz_label:
continue
viz_label.append(y)
loc = get_locations_from_model(trainer, x)
imgs = [x]
for j in range(1, trainer.num_stacks):
imgs.append(F.avg_pool2d(Variable(x), 2**j).data)
if x.size(-1) != trainer.num_channels:
for j in range(0, trainer.num_stacks):
imgs[j] = imgs[j].transpose(1, 3)
imgs[j] = denormalize_image(imgs[j].numpy())
num_glimpses = len(loc)
n_row = 2**trainer.num_stacks - 1
n_col = 2**(trainer.num_stacks - 1) * num_glimpses
fig = plt.figure(1, (n_col, n_row))
gridspec.GridSpec(n_row, n_col)
row_start_idx = [0]
for j in range(1, trainer.num_stacks):
idx = 2**(trainer.num_stacks - j) + row_start_idx[j - 1]
row_start_idx.append(idx)
for j in range(num_glimpses):
for k in range(trainer.num_stacks):
r = row_start_idx[k]
c = 2**(trainer.num_stacks - 1) * j
sz = 2**(trainer.num_stacks - k - 1)
ax = plt.subplot2grid((n_row, n_col), (r, c),
colspan=sz,
rowspan=sz)
ax.imshow(imgs[k][0])
ax.get_xaxis().set_visible(False)
ax.get_yaxis().set_visible(False)
x_coord, y_coord = int(loc[j][k][0]), int(loc[j][k][1])
for s in range(trainer.num_patches):
size = trainer.patch_size * 2**s
rect = bounding_box(x_coord, y_coord, size, 'r')
ax.add_patch(rect)
fig.tight_layout()
plt.savefig(os.path.join(conf.viz_dir, 'viz_%d.jpg' % len(viz_label)),
bbox_inches='tight')
if len(viz_label) == 3:
break
