def main(args):
print("Loading data")
dataset = args.data.rstrip('/').split('/')[-1]
torch.cuda.set_device(args.cuda)
device = args.device
if dataset == 'mnist':
train_loader, test_loader = get_mnist(args.batch_size, 'data/mnist')
num = 10
elif dataset == 'fashion':
train_loader, test_loader = get_fashion_mnist(args.batch_size,
'data/fashion')
num = 10
elif dataset == 'svhn':
train_loader, test_loader, _ = get_svhn(args.batch_size, 'data/svhn')
num = 10
elif dataset == 'stl':
train_loader, test_loader, _ = get_stl10(args.batch_size, 'data/stl10')
elif dataset == 'cifar':
train_loader, test_loader = get_cifar(args.batch_size, 'data/cifar')
num = 10
elif dataset == 'chair':
train_loader, test_loader = get_chair(args.batch_size,
'~/data/rendered_chairs')
num = 1393
elif dataset == 'yale':
train_loader, test_loader = get_yale(args.batch_size, 'data/yale')
num = 38
model = VAE(28 * 28, args.code_dim, args.batch_size, 10,
dataset).to(device)
phi = nn.Sequential(
nn.Linear(args.code_dim, args.phi_dim),
nn.LeakyReLU(0.2, True),
).to(device)
model.load_state_dict(torch.load(args.fname))
if args.tsne:
datas, targets = [], []
for i, (data, target) in enumerate(test_loader):
datas.append(data), targets.append(target)
if i >= 5:
break
data, target = torch.cat(datas, dim=0), torch.cat(targets, dim=0)
c = F.one_hot(target.long(), num_classes=num).float()
_, _, _, z = model(data.to(args.device), c.to(args.device))
z, target = z.detach().cpu().numpy(), target.cpu().numpy()
tsne = TSNE(n_components=2, init='pca', random_state=0)
z_2d = tsne.fit_transform(z)
plt.figure(figsize=(6, 5))
for a in range(8):
for b in range(a + 1, 10):
plot_embedding(
z_2d,
target,
a,
b,
)
plt.savefig('tsne_c{}_{}_{}{}.png'.format(
int(args.c), dataset, a, b))
def main(args):
print("Loading data")
dataset = args.data.rstrip('/').split('/')[-1]
torch.cuda.set_device(args.cuda)
device = args.device
if dataset == 'mnist':
train_loader, test_loader = get_mnist(args.batch_size, 'data/mnist')
num = 10
elif dataset == 'fashion':
train_loader, test_loader = get_fashion_mnist(args.batch_size,
'data/fashion')
num = 10
elif dataset == 'svhn':
train_loader, test_loader, _ = get_svhn(args.batch_size, 'data/svhn')
num = 10
elif dataset == 'stl':
train_loader, test_loader, _ = get_stl10(args.batch_size, 'data/stl10')
elif dataset == 'cifar':
train_loader, test_loader = get_cifar(args.batch_size, 'data/cifar')
num = 10
elif dataset == 'chair':
train_loader, test_loader = get_chair(args.batch_size,
'~/data/rendered_chairs')
num = 1393
elif dataset == 'yale':
train_loader, test_loader = get_yale(args.batch_size, 'data/yale')
num = 38
model = VAE(28 * 28, args.code_dim, args.batch_size, num,
dataset).to(device)
phi = nn.Sequential(
nn.Linear(args.code_dim, args.phi_dim),
nn.LeakyReLU(0.2, True),
).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr)
optimizer_phi = torch.optim.Adam(phi.parameters(), lr=args.lr)
criterion = nn.MSELoss(reduction='sum')
for epoch in range(args.epochs):
re_loss = 0
kl_div = 0
size = len(train_loader.dataset)
for data, target in train_loader:
data, target = data.squeeze(1).to(device), target.to(device)
c = F.one_hot(target.long(), num_classes=num).float()
output, q_z, p_z, z = model(data, c)
hsic = HSIC(phi(z), target.long(), num)
if dataset == 'mnist' or dataset == 'fashion':
reloss = recon_loss(output, data.view(-1, 28 * 28))
else:
reloss = criterion(output, data)
kld = total_kld(q_z, p_z)
loss = reloss + kld + args.c * hsic
optimizer.zero_grad()
loss.backward()
optimizer.step()
optimizer_phi.zero_grad()
neg = -HSIC(phi(z.detach()), target.long(), num)
neg.backward()
optimizer_phi.step()
re_loss += reloss.item() / size
kl_div += kld.item() / size
print('-' * 50)
print(
" Epoch {} |re loss {:5.2f} | kl div {:5.2f} | hs {:5.2f}".format(
epoch, re_loss, kl_div, hsic))
for data, target in test_loader:
data, target = data.squeeze(1).to(device), target.to(device)
c = F.one_hot(target.long(), num_classes=num).float()
output, _, _, z = model(data, c)
break
if dataset == 'mnist' or dataset == 'fashion':
img_size = [data.size(0), 1, 28, 28]
else:
img_size = [data.size(0), 3, 32, 32]
images = [data.view(img_size)[:30].cpu()]
for i in range(10):
c = F.one_hot(torch.ones(z.size(0)).long() * i,
num_classes=num).float().to(device)
output = model.decoder(torch.cat((z, c), dim=-1))
images.append(output.view(img_size)[:30].cpu())
images = torch.cat(images, dim=0)
save_image(images,
'imgs/recon_c{}_{}.png'.format(int(args.c), dataset),
nrow=30)
torch.save(model.state_dict(),
'vae_c{}_{}.pt'.format(int(args.c), dataset))
# z = p_z.sample()
# for i in range(10):
# c = F.one_hot(torch.ones(z.size(0)).long()*i, num_classes=10).float().to(device)
# output = model.decoder(torch.cat((z, c), dim=-1))
# n = min(z.size(0), 8)
# save_image(output.view(z.size(0), 1, 28, 28)[:n].cpu(), 'imgs/recon_{}.png'.format(i), nrow=n)
if args.tsne:
datas, targets = [], []
for i, (data, target) in enumerate(test_loader):
datas.append(data), targets.append(target)
if i >= 5:
break
data, target = torch.cat(datas, dim=0), torch.cat(targets, dim=0)
c = F.one_hot(target.long(), num_classes=num).float()
_, _, _, z = model(data.to(args.device), c.to(args.device))
z, target = z.detach().cpu().numpy(), target.cpu().numpy()
tsne = TSNE(n_components=2, init='pca', random_state=0)
z_2d = tsne.fit_transform(z)
plt.figure(figsize=(6, 5))
plot_embedding(z_2d, target)
plt.savefig('tsnes/tsne_c{}_{}.png'.format(int(args.c), dataset))
def main(args):
print("Loading data")
dataset = args.data.rstrip('/').split('/')[-1]
if dataset in ['mnist']:
train_loader, test_loader = get_mnist(args.batch_size, args.data)
elif dataset in ['cifar']:
train_loader, test_loader, classes = get_cifar(args.batch_size,
args.data)
elif dataset in ['svhn']:
train_loader, test_loader, extra_loader = get_svhn(
args.batch_size, args.data)
elif dataset in ['fashion']:
train_loader, test_loader = get_fashion_mnist(args.batch_size,
args.data)
elif dataset in ['stl10']:
train_loader, test_loader, unlabeled_loader = get_stl10(
args.batch_size, args.data)
else:
raise NotImplementedError
torch.cuda.set_device(args.device_id)
for _, (batch, _) in enumerate(train_loader):
size = batch.size()
break
model = Classifier(batch.size(-1) * batch.size(-1),
len(rotations)).to(args.device)
optimizer = torch.optim.Adam(model.parameters(), args.lr)
start_epoch = 1
print('\nStarting Training')
try:
for epoch in range(start_epoch, args.epochs):
nll, re_loss, kl_divergence, d_loss = run(args,
train_loader,
model,
optimizer,
epoch,
train=True)
print('-' * 90)
meta = "| epoch {:2d} ".format(epoch)
print(
meta +
"| Train NLL: {:5.2f} | Train loss: {:5.2f} ({:5.2f}) | D loss {:5.2f} |"
.format(nll, re_loss, kl_divergence, d_loss))
nll, re_loss, kl_divergence, d_loss = run(args,
test_loader,
model,
optimizer,
1,
train=False)
print(
len(meta) * " " +
"| Test NLL: {:5.2f} | Test loss: {:5.2f} ({:5.2f}) | D loss {:5.2f} |"
.format(nll, re_loss, kl_divergence, d_loss))
except KeyboardInterrupt:
print('-' * 50)
print('Quit Training')
nll, re_loss, kl_divergence, d_loss = run(args,
test_loader,
model,
optimizer,
epoch,
train=False)
print('=' * 90)
print(
"| Train NLL: {:5.2f} | Train loss: {:5.2f} ({:5.2f}) | D loss {:5.2f} |"
.format(nll, re_loss, kl_divergence, d_loss))
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from data import get_mnist, get_cifar
from lassonet import LassoNetClassifier
train_loader, val_loader, test_loader = get_cifar(train=True, batch_size=64, val_size=.1, flatten=True)
print("Data Loaded.")
model = LassoNetClassifier(M=30, verbose=True, hidden_dims=(100,), n_iters=(1000, 100), patience=(10, 5),
lambda_start=5e2, path_multiplier=1.03)
path = model.path((train_loader, val_loader), stochastic=True, verboseEpochs=True, iterationsPerEpoch=100)
img = model.feature_importances_.reshape(3, 32, 32).mean(0)
img = (img * 1.0 / (img.max()))
plt.title("Feature importance.")
plt.imshow(img)
plt.colorbar()
plt.savefig("cifar-classification-importance.png")
n_selected = []
accuracy = []
lambda_ = []
for save in path:
model.load(save.state_dict)
y_pred, y_true = model.predict(test_loader, stochastic=True)
n_selected.append(save.selected.sum())
accuracy.append(accuracy_score(y_true, y_pred))
lambda_.append(save.lambda_)