def train(config):
lera.log_hyperparams({
"title": "hw1",
"epoch": config.epochs,
"lr": config.lr
})
dataset = img_dataset("./dataset/train", "train")
dataloader = torch.utils.data.DataLoader(dataset=dataset,
batch_size=config.bs,
shuffle=True,
drop_last=True)
net = Classifier(num_classes=13).cuda()
net.load_state_dict(
torch.load(
join(f"{config.weight_path}",
f"{config.pre_epochs}_classifier.pth")))
criterion = nn.CrossEntropyLoss().cuda()
optimizer = optim.Adam(net.parameters(), lr=config.lr)
for epoch in range(config.epochs):
for _, data in enumerate(dataloader, 0):
optimizer.zero_grad()
net.train()
inputs, labels = data
inputs = inputs.cuda()
labels = labels.cuda()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
_, predicted = torch.max(outputs.data, 1)
correct_counts = predicted.eq(labels.data.view_as(predicted))
train_acc = torch.sum(correct_counts).item() / predicted.size(0)
lera.log({"loss": loss.item(), "acc": train_acc})
print("epoch:{}/{}, loss:{}, acc:{:02f}".format(
epoch + 1 + config.pre_epochs,
config.epochs + config.pre_epochs,
loss.item(),
train_acc,
))
if (epoch + 1 + config.pre_epochs) % 10 == 0:
torch.save(
net.state_dict(),
join(
f"{config.weight_path}",
f"{epoch + 1 + config.pre_epochs}_classifier.pth",
),
)
global_par_dict = {
'title': str('TDAAv4 Transformer PIT Tasnet.'),
'updates': updates,
'batch_size': config.batch_size,
'WFM': config.WFM,
'global_emb': config.global_emb,
'schmidt': config.schmidt,
'log path': str(log_path),
'selfTune': config.is_SelfTune,
'cnn': config.speech_cnn_net, # 是否采用CNN的结构来抽取
'relitu': config.relitu,
'ct_recu': config.ct_recu, # 控制是否采用att递减的ct构成
'loss': str(config.loss),
'score fnc': str(config.infer_classifier),
}
lera.log_hyperparams(global_par_dict)
for item in list(global_par_dict.keys()):
writer.add_text(item, str(global_par_dict[item]))
def train(epoch):
global e, updates, total_loss, start_time, report_total, report_correct, total_loss_sgm, total_loss_ss
e = epoch
model.train()
SDR_SUM = np.array([])
SDRi_SUM = np.array([])
if updates <= config.warmup: #如果不在warm阶段就正常规划
pass
elif config.schedule and scheduler.get_lr()[0] > 5e-7:
scheduler.step()
if device.type == 'cuda':
os.environ["CUDA_VISIBLE_DEVICES"] = str(
np.argmax([
int(x.split()[2]) for x in subprocess.Popen(
"nvidia-smi -q -d Memory | grep -A4 GPU | grep Free",
shell=True,
stdout=subprocess.PIPE).stdout.readlines()
]))
##
lera.log_hyperparams({
'title': 'Image Evaluator',
'batch_size': BATCH_SIZE,
'epochs': epoch_count,
'optimizer': 'Adam',
'lr': learning_rate,
})
##
best_acc = 0 # best test accuracy
start_epoch = 0 # start from epoch 0 or last checkpoint epoch
# Data
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(224, padding=4),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
def train(args):
try:
os.makedirs(args.save_img_path)
except OSError:
pass
try:
os.makedirs(args.weight_path)
except OSError:
pass
lera.log_hyperparams(
{
"title": "hw2",
"batch_size": args.bs,
"epochs": args.epochs,
"g_lr": args.g_lr,
"d_lr": args.d_lr,
"z_size": args.z_size,
}
)
# dataset
dataloader = data_loader(
args.data_path, args.imgsize, args.bs, shuffle=True
)
# model
generator = Generator(args.bs, args.imgsize, z_dim=args.z_size).cuda()
discriminator = Discriminator(args.bs, args.imgsize).cuda()
if args.pre_epochs != 0:
generator.load_state_dict(
torch.load(
join(f"{args.weight_path}", f"generator_{args.pre_epochs}.pth")
)
)
discriminator.load_state_dict(
torch.load(
join(
f"{args.weight_path}",
f"discriminator_{args.pre_epochs}.pth",
)
)
)
# optimizer
g_optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, generator.parameters()), lr=args.g_lr
)
d_optimizer = torch.optim.SGD(
filter(lambda p: p.requires_grad, discriminator.parameters()),
lr=args.d_lr,
)
# validate noise
fixed_noise = torch.randn(9, args.z_size)
fixed_noise = torch.tensor(fixed_noise).cuda()
# train
for epoch in range(args.pre_epochs, args.epochs):
for i, data in enumerate(dataloader):
discriminator.train()
generator.train()
# train discriminator
if i % 5 == 0:
d_optimizer.zero_grad()
real_img = torch.tensor(data[0]).cuda() * 2 - 1 # (-1, 1)
d__real, _, _ = discriminator(real_img)
z = torch.randn(args.bs, args.z_size)
z = torch.tensor(z).cuda()
fake_img, _, _ = generator(z)
d_fake, _, _ = discriminator(fake_img)
# hinge loss
d_loss_real = torch.nn.ReLU()(1.0 - d__real).mean()
d_loss_fake = torch.nn.ReLU()(1.0 + d_fake).mean()
d_loss = d_loss_real + d_loss_fake
d_loss.backward()
d_optimizer.step()
# train generator
g_optimizer.zero_grad()
z = torch.randn(args.bs, args.z_size)
z = torch.tensor(z).cuda()
fake_img, _, _ = generator(z)
g_fake, _, _ = discriminator(fake_img)
# hinge loss
g_loss = -g_fake.mean()
g_loss.backward()
g_optimizer.step()
if i % 100 == 0:
lera.log({"d_loss": d_loss.item(), "g_loss": g_loss.item()})
print(
"[epoch:%4d/%4d %3d/%3d] \t d_loss: %0.6f \t g_loss: %0.6f"
% (
epoch + 1,
args.epochs,
i,
len(dataloader),
d_loss.item(),
g_loss.item(),
)
)
if i % 300 == 0:
validate(
generator, i, epoch, args.save_img_path, fixed_noise
)
torch.save(
discriminator.state_dict(),
f"./{args.weight_path}/discriminator_{epoch+1}.pth",
)
torch.save(
generator.state_dict(),
f"./{args.weight_path}/generator_{epoch+1}.pth",
)
scores = collections.OrderedDict(zip(config.metric, scores))
best_SDR = 0.0
with open(opt.label_dict_file, 'r') as f:
label_dict = json.load(f)
# train
lera.log_hyperparams({
'title': unicode('SS CN v0.2a'),
'updates': updates,
'batch_size': config.batch_size,
'WFM': config.WFM,
'MLMSE': config.MLMSE,
'top1': config.top1, #控制是否用top-1的方法来生产第二个通道
'global_emb': config.global_emb,
# 'spk_emb_size':config.SPK_EMB_SIZE, #注意这个东西需要和上面的spk_emb（如果是global_emb的话）,否认则就跟decoder的hidden_size对应
# 'hidden_mix':config.hidden_mix,#这个模式是不采用global emb的时候，把hidden和下一步的embeding一起cat起来作为ss的输入进去。
'schmidt': config.schmidt,
'log path': unicode(log_path),
'selfTune': config.is_SelfTune,
'is_dis': config.is_dis,
'cnn': config.speech_cnn_net, #是否采用CNN的结构来抽取
'relitu': config.relitu,
'ct_recu': config.ct_recu, #控制是否采用att递减的ct构成
})
def train(epoch):
e = epoch
model.train()
SDR_SUM = np.array([])
def train(config):
print('Random seed: %d' % int(config.seed))
torch.manual_seed(config.seed)
torch.backends.cudnn.benchmark = True
dset = config.dataset
if dset == 'modelnet10' or dset == 'modelnet40':
dataset = ClsDataset(root=config.root, npoints=config.npoints, train=True)
test_dataset = ClsDataset(root=config.root, npoints=config.npoints, train=False)
else:
raise NotImplementedError('Dataset not supported.')
print('Selected %s' % dset)
dataloader = torch.utils.data.DataLoader(dataset, batch_size=config.batchsize, shuffle=True,
num_workers=config.workers)
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=config.batchsize, shuffle=True,
num_workers=config.workers)
num_classes = dataset.num_classes
print('number of classes: %d' % num_classes)
print('train set size: %d | test set size: %d' % (len(dataset), len(test_dataset)))
try:
os.makedirs(config.outf)
except:
pass
blue = lambda x: '\033[94m' + x + '\033[0m'
yellow = lambda x: '\033[93m' + x + '\033[0m'
red = lambda x: '\033[91m' + x + '\033[0m'
classifier = PointNetCls(k=num_classes)
if config.model != '':
classifier.load_state_dict(torch.load(config.model))
optimizer = optim.SGD(classifier.parameters(), lr=config.lr, momentum=config.momentum)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
classifier.to(device)
if config.mgpu:
classifier = torch.nn.DataParallel(classifier, device_ids=config.gpuids)
num_batch = len(dataset) / config.batchsize
lera.log_hyperparams({
'title': dset,
'batchsize': config.batchsize,
'epochs': config.nepochs,
'npoints': config.npoints,
'optimizer': 'SGD',
'lr': config.lr,
})
for epoch in range(config.nepochs):
train_acc_epoch, test_acc_epoch = [], []
for i, data in enumerate(dataloader):
points, labels = data
points = points.transpose(2, 1)
labels = labels[:, 0]
points, labels = points.to(device), labels.to(device)
optimizer.zero_grad()
classifier = classifier.train()
pred, _ = classifier(points)
pred = pred.view(-1, num_classes)
# print(pred.size(), labels.size())
loss = F.nll_loss(pred, labels)
loss.backward()
optimizer.step()
pred_choice = pred.data.max(1)[1]
correct = pred_choice.eq(labels.data).cpu().sum()
train_acc = correct.item() / float(config.batchsize)
print('epoch %d: %d/%d | train loss: %f | train acc: %f' % (epoch+1, i+1, num_batch+1, loss.item(), train_acc))
train_acc_epoch.append(train_acc)
lera.log({
'train loss': loss.item(),
'train acc': train_acc
})
if (i+1) % 10 == 0:
j, data = next(enumerate(test_dataloader, 0))
points, labels = data
points = points.transpose(2, 1)
labels = labels[:, 0]
points, labels = points.to(device), labels.to(device)
classifier = classifier.eval()
with torch.no_grad():
pred, _ = classifier(points)
pred = pred.view(-1, num_classes)
loss = F.nll_loss(pred, labels)
pred_choice = pred.data.max(1)[1]
correct = pred_choice.eq(labels.data).cpu().sum()
test_acc = correct.item() / float(config.batchsize)
print(blue('epoch %d: %d/%d | test loss: %f | test acc: %f') % (epoch+1, i+1, num_batch+1, loss.item(), test_acc))
test_acc_epoch.append(test_acc)
lera.log({
'test loss': loss.item(),
'test acc': test_acc
})
print(yellow('epoch %d | mean train acc: %f') % (epoch+1, np.mean(train_acc_epoch)))
print(red('epoch %d | mean test acc: %f') % (epoch+1, np.mean(test_acc_epoch)))
lera.log({
'train acc epoch': np.mean(train_acc_epoch),
'test acc epoch': np.mean(test_acc_epoch)})
torch.save(classifier.state_dict(), '%s/%s_model_%d.pth' % (config.outf, config.dataset, epoch))
.permute(0, 3, 1, 4, 2).contiguous() # [4, w, 4, w, 3]
.view(w * 4, w * 4, 3)) # [w * 4, w * 4, 3]
lera.log_image('reconstruction', result.numpy(), clip=(0, 1))
# continue training
if step < total_steps:
train(epoch, step)
## Train
lera.enabled(args.lera)
lera.log_hyperparams({
'title' : "VQ-VAE",
'dataset': dataset,
'batch_size': batch_size,
'K': K,
'lr': lr,
'D': D,
'beta': beta,
'total_steps' : total_steps
})
lera.log_file(__file__)
enc = encoder(D)
dec = decoder(D)
embeddings = torch.randn(K, D).div(D)
sensitivity = torch.zeros(K)
# calculate number of embedding vectors used
emb_count = torch.zeros(K)
if use_cuda:
