def main():
data_dir = in_arg.data_dir
train_dir = data_dir + '/train'
valid_dir = data_dir + '/valid'
test_dir = data_dir + '/test'
#device=torch.device("cuda" if torch.cuda.is_available() and in_arg.gpu else "cpu")
with open(in_arg.category_names, 'r') as f:
cat_to_name = json.load(f)
model = load_checkpoint(in_arg.save_dir + 'checkpoint.pth')
if in_arg.file_path is None:
randclass = random.randint(1, 102)
randir = test_dir + "/" + str(randclass) + "/"
image = random.choice(os.listdir(randir))
image_path = randir + image
prob, classes = predict(image_path, model, in_arg.top_k, in_arg.gpu)
print(prob)
print(classes)
print([cat_to_name[item] for item in classes])
# Batch that records trajectories
batch_log_prob = []
batch_rewards = []
while True:
finished_rendering_this_epoch = False
epoch_durations = []
epoch_rewards = []
for i_episode in range(batch_size):
# Every save_ckpt_interval, Check if there is any checkpoint.
# If there is, load checkpoint and continue training
# Need to specify the i_episode of the checkpoint intended to load
if i_epoch % save_ckpt_interval == 0 and os.path.isfile(os.path.join(ckpt_dir, "ckpt_eps%d.pt" % i_epoch)):
policy_net, optimizer, training_info = load_checkpoint(ckpt_dir, i_epoch, layer_sizes, device=device)
# Initialize the environment and state
observation = env.reset()
current_state = torch.tensor([observation], device=device, dtype=torch.float32)
traj_log_prob = None
traj_reward = None
running_reward = 0
episode_durations = []
episode_rewards = []
for t in count():
# Make sure that policy net is in training mode
policy_net.train()
"episode reward": [],
"training loss": [],
"episode loss": [],
"max reward achieved": 0,
"past 100 episodes mean reward": 0,
"max TD loss recorded": 0,
"max episode loss recorded": 0
}
while True:
# Every save_ckpt_interval, Check if there is any checkpoint.
# If there is, load checkpoint and continue training
# Need to specify the i_episode of the checkpoint intended to load
if i_episode % save_ckpt_interval == 0 and os.path.isfile(
os.path.join(ckpt_dir, "ckpt_eps%d.pt" % i_episode)):
policy_net, target_net, optimizer, training_info = load_checkpoint(
ckpt_dir, i_episode, input_size, output_size, device=device)
# Initialize the environment and state
observation = env.reset()
current_state = torch.tensor([observation],
device=device,
dtype=torch.float32)
running_reward = 0
running_minibatch_loss = 0
running_episode_loss = 0
for t in count():
# Select and perform an action
# Turn policy_net into evaluation mode to select an action given a single state
policy_net.eval()
def train_(args, model, opt, latent_loss_weight, criterion, loader, epochs,
inf_iterator_test, logger, iteration, inf_iterator_enc):
dis = NetD(80).cuda()
opt_dis = optim.Adam(dis.parameters())
'''
gamma = 1.0
lambda_k = 0.01
init_k = 0.0
recorder = BEGANRecorder(lambda_k, init_k, gamma)
k = recorder.k.item()
'''
opt_dec = optim.Adam(model.dec.parameters())
lj_mean = torch.tensor(
np.load("/home/ericwudayi/nas189/homes/ericwudayi/LJSpeech/mean.npy")
).unsqueeze(0).unsqueeze(2).cuda()
lj_std = torch.tensor(
np.load("/home/ericwudayi/nas189/homes/ericwudayi/LJSpeech/std.npy")
).unsqueeze(0).unsqueeze(2).cuda()
vctk_mean = torch.tensor(
np.load(
"/home/ericwudayi/nas189/homes/ericwudayi/VCTK-Corpus/mel3/mean.npy"
)).unsqueeze(0).unsqueeze(2).cuda()
vctk_std = torch.tensor(
np.load(
"/home/ericwudayi/nas189/homes/ericwudayi/VCTK-Corpus/mel3/std.npy"
)).unsqueeze(0).unsqueeze(2).cuda()
lj_mean = vctk_mean
lj_std = vctk_std
if args.load_checkpoint == True:
dis, opt_dis, iteration = load_checkpoint(
f'checkpoint/{args.model}_n{args.n_embed}_ch{args.channel}_{args.trainer}/dis',
dis, opt_dis)
for epoch in range(80000):
for i, audio in enumerate(loader):
audio = audio.cuda()
audio = (audio - lj_mean) / lj_std
#audio = (audio*25 + 50) / 50
factor = 32
time_step = audio.size(2)
audio_shuffle = [[] for i in range(time_step // factor)]
nums = [x for x in range(time_step // factor)]
random.shuffle(nums)
for i_n, n in enumerate(nums):
sf = random.uniform(0.5, 2)
audio_shuffle[n] = F.interpolate(audio[..., factor * n:factor *
(n + 1)],
scale_factor=sf,
mode='nearest')
audio_shuffle = torch.cat(audio_shuffle, dim=2)
audio = audio_shuffle #F.interpolate(audio, scale_factor= audio_shuffle.size(2)/time_step)
audio = audio[..., :audio.size(2) // 32 * 32]
audio_middile = F.interpolate(audio, scale_factor=1 / 2)
audio_middile = audio_middile[:, :audio_middile.size(1) // 2, :]
audio_low = F.interpolate(audio_middile, scale_factor=1 / 2)
audio_low = audio_low[:, :audio_low.size(1) // 2, :]
audio_list = [audio_low, audio_middile, audio]
out, latent_loss, index_list = model(audio)
recon_loss = 0
for num in range(3):
recon_loss += criterion(out[num], audio_list[num])
latent_loss = latent_loss.mean()
if iteration % 1 == 0:
model.zero_grad()
audio_enc = next(inf_iterator_enc)
audio_enc = audio_enc.cuda()
audio_enc = (audio_enc - vctk_mean) / vctk_std
if audio_enc.size(0) > audio.size(0):
audio_enc = audio_enc[:audio.size(0)]
else:
audio = audio[:audio_enc.size(0)]
audio_enc = F.interpolate(audio_enc,
scale_factor=audio.size(2) /
audio_enc.size(2))
out_code, latent_loss_enc, index_list = model(audio_enc)
#latent_loss += latent_loss_enc.mean()
#latent_loss *= 0
#loss_dis, loss_gan = GANLOSS(dis, audio, out_code[-1])
#if iteration%4==0:
# OptimStep([(dis, opt_dis, loss_dis, False)],3)
#else:
# OptimStep([(model, opt, recon_loss + latent_loss_weight*latent_loss + 0.1*loss_gan , False)],3)
OptimStep([(model, opt, recon_loss +
latent_loss_weight * latent_loss, False)], 3)
#else:
#latent_loss *= 0
#OptimStep([(model, opt, recon_loss + latent_loss_weight*latent_loss , True)], 3)# True),
#################################
# BEGAN TRAINING PHASE #
#################################
model.zero_grad()
if iteration % 5 == 0:
logger.log_training(iteration=iteration,
loss_recon=recon_loss,
latent_loss=latent_loss)
if iteration % 200 == 0:
model.eval()
a = torch.stack(
[audio[0], out[-1][0], out_code[-1][0], audio_enc[0]],
dim=0)
a = a * lj_std + lj_mean
a[3] = (a[3] - lj_mean) / lj_std * vctk_std + vctk_mean
image = a
a = vocoder.inverse(a)
a = a.detach().cpu().numpy()
logger.log_validation(
iteration=iteration,
mel_ori=("image", plot_spectrogram_to_numpy(), image[0]),
mel_recon=("image", plot_spectrogram_to_numpy(), image[1]),
mel_code=("image", plot_spectrogram_to_numpy(), image[2]),
mel_target=("image", plot_spectrogram_to_numpy(),
image[3]),
audio_ori=("audio", 22050, a[0]),
audio_recon=("audio", 22050, a[1]),
audio_code=("audio", 22050, a[2]),
audio_enc=("audio", 22050, a[3]),
)
save_checkpoint(
model, opt, iteration,
f'checkpoint/{args.model}_n{args.n_embed}_ch{args.channel}_{args.trainer}/gen'
)
save_checkpoint(
dis, opt_dis, iteration,
f'checkpoint/{args.model}_n{args.n_embed}_ch{args.channel}_{args.trainer}/dis'
)
model.train()
logger.close()
iteration += 1
"mean": [64, 32, output_size],
"std": [64, 32, output_size]
} # The MLP network architecture
action_lim = 1.
# Make environment
env = gym.make(env_name)
# Get device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Read checkpoint
policy_net, _, _ = load_checkpoint(ckpt_dir,
i_epoch,
layer_sizes,
action_lim,
device=device)
# Record evaluation info
evaluation_info = {
"episode rewards": [],
"episode durations": [],
"max reward acieved": 0,
}
# Turn the policy network into evaluation mode
policy_net.eval()
for i_episode in range(num_eval_episodes):
filelist = sorted(filelist, key = lambda x : int(x[0]))
for f in filelist:
netG += [ymp.construct_model(f"model_config/{hp.config_gen}/{f}")]
print (netG)
m = nn.ModuleList(netG)
m = m.cuda()
opt = optim.Adam(m.parameters(),lr=1e-4)
dis_high = ymp.construct_model(f"model_config/{hp.config_dis}/1.yaml")
dis_high = dis_high.cuda()
opt_dis = optim.Adam(dis_high.parameters(),lr=1e-4)
iteration = 0
if args.load_checkpoint==True:
m, opt, iteration = load_checkpoint(f'checkpoint/{args.checkpoint_path}/gen', m, opt)
dis_high, opt_dis, iteration = load_checkpoint(f'checkpoint/{args.checkpoint_path}/dis', dis_high, opt_dis)
'''
###########################################################
In general, we preprocess data to npy, and put them in
specific folder. Dataloader load npy file.
But in this example, I show that how to transfrom audio
into stft, melspectrogram by torch.nn.module (MelSpectrogram).
###########################################################
'''
#melblock = MelSpectrogram(hp).cuda()
melblock = MelVocoder(path = "vocoder/melgan-neurips/scripts/logs/NUS")
vocoder_speech = torch.hub.load('descriptinc/melgan-neurips', 'load_melgan')
from save_and_load import load_checkpoint
from utils import plot_durations
import matplotlib.pyplot as plt
import torch
# IMPORTANT: Set value for i_episode to indicate which checkpoint you want to use
# for evaluation.
i_episode = 7300
start_idx = 6500
end_idx = 7200
ckpt_dir = "DDDQN_SGD_CartPoleV1_obs_checkpoints/"
input_size = 4
output_size = 2
# Get device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Read checkpoint
_, _, _, training_info = \
load_checkpoint(ckpt_dir, i_episode, input_size, output_size, device=device)
# Plot figure
plot_durations(training_info["episode reward"], training_info["training loss"],
training_info["episode loss"], (start_idx, end_idx))
audio_dir_test = args.test_dir #"/home/ericwudayi/nas189/homes/ericwudayi/VCTK-Corpus/mel3/mel.test"
else:
audio_dir_test = audio_dir
print("None test dir, use train dir instead")
dataset_test = AudioNpyLoader(audio_dir_test)
test_loader = DataLoader(dataset_test,
batch_size=8,
shuffle=True,
num_workers=4,
collate_fn=VCTK_collate)
inf_iterator_test = make_inf_iterator(test_loader)
'''
Model Initilization
'''
model = model(in_channel=80,
channel=int(args.channel),
n_embed=int(args.n_embed)).cuda()
opt = optim.Adam(model.parameters())
'''
Training
'''
criterion = nn.L1Loss()
latent_loss_weight = 0.1
iteration = 0
if args.load_checkpoint == True:
model, opt, iteration = load_checkpoint(
f'checkpoint/{args.model}_n{args.n_embed}_ch{args.channel}_{args.trainer}/gen',
model, opt)
train_(args, model, opt, latent_loss_weight, criterion, loader, 800,
inf_iterator_test, logger, iteration)
# To record epoch stats
epoch_durations = []
epoch_rewards = []
while True:
finished_rendering_this_epoch = False
# Every save_ckpt_interval, Check if there is any checkpoint.
# If there is, load checkpoint and continue training
# Need to specify the i_episode of the checkpoint intended to load
if i_epoch % save_ckpt_interval == 0 and os.path.isfile(
os.path.join(ckpt_dir, "ckpt_eps%d.pt" % i_epoch)):
policy_net, value_net, policynet_optimizer, valuenet_optimizer, training_info = \
load_checkpoint(ckpt_dir, i_epoch, layer_sizes, input_size, action_lim, device=device)
# To record episode stats
episode_durations = []
episode_rewards = []
for i_episode in range(batch_size):
# Keep track of the running reward
running_reward = 0
# Initialize the environment and state
current_state = env.reset()
# Estimate the value of the initial state
ex_val = value_net(torch.tensor(
from save_and_load import load_checkpoint
from utils import plot_durations
import matplotlib.pyplot as plt
import torch
# IMPORTANT: Set value for i_episode to indicate which checkpoint you want to use
# for evaluation.
i_epoch = 650
start_idx = 0
end_idx = i_epoch
input_size = 8
output_size = 4
layer_sizes = [input_size, 128, 128, 128,
output_size] # The MLP network architecture
env_name = "LunarLander-v2"
ckpt_dir = "simplePG_Adam_%s_obs_checkpoints/" % (env_name)
# Get device
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Read checkpoint
_, _, training_info = \
load_checkpoint(ckpt_dir, i_epoch, layer_sizes, device=device)
# Plot figure
plot_durations(training_info["epoch mean rewards"], (start_idx, end_idx))