def prepare_data(self):
MNIST(self.hparams.data_dir, train=True, download=True, transform=transforms.ToTensor())
def main():
torch.manual_seed(1)
if args.cuda:
torch.cuda.manual_seed(1)
exp_dir = os.path.join("data", args.exp_name)
make_dir_if_not_exist(exp_dir)
if args.pkl is not None:
input_file = open(args.pkl, 'rb')
final_data = pickle.load(input_file)
input_file.close()
embeddings = final_data['embeddings']
labels = final_data['labels']
vis_tSNE(embeddings, labels)
else:
embeddingNet = None
if (args.dataset == 's2s') or (args.dataset == 'vggface2'):
embeddingNet = embedding.EmbeddingResnet()
elif (args.dataset == 'mnist') or (args.dataset == 'fmnist'):
embeddingNet = embedding.EmbeddingLeNet()
else:
print("Dataset {} not supported ".format(args.dataset))
return
model_dict = None
if args.ckp is not None:
if os.path.isfile(args.ckp):
print("=> Loading checkpoint '{}'".format(args.ckp))
try:
model_dict = torch.load(args.ckp)['state_dict']
except Exception:
model_dict = torch.load(args.ckp,
map_location='cpu')['state_dict']
print("=> Loaded checkpoint '{}'".format(args.ckp))
else:
print("=> No checkpoint found at '{}'".format(args.ckp))
return
else:
print("Please specify a model")
return
model_dict_mod = {}
for key, value in model_dict.items():
new_key = '.'.join(key.split('.')[2:])
model_dict_mod[new_key] = value
model = embeddingNet.to(device)
model.load_state_dict(model_dict_mod)
data_loader = None
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
if (args.dataset == 'mnist') or (args.dataset == 'fmnist'):
transform = transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
train_dataset = None
if args.dataset == 'mnist':
train_dataset = MNIST('data/MNIST',
train=True,
download=True,
transform=transform)
if args.dataset == 'fmnist':
train_dataset = FashionMNIST('data/FashionMNIST',
train=True,
download=True,
transform=transform)
data_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=64,
shuffle=True,
**kwargs)
else:
print("Dataset {} not supported ".format(args.dataset))
return
embeddings, labels = generate_embeddings(data_loader, model)
final_data = {'embeddings': embeddings, 'labels': labels}
dst_dir = os.path.join('data', args.exp_name, 'tSNE')
make_dir_if_not_exist(dst_dir)
output_file = open(os.path.join(dst_dir, 'tSNE.pkl'), 'wb')
pickle.dump(final_data, output_file)
output_file.close()
vis_tSNE(embeddings, labels)
def train(num_epochs=30, batch_size=128):
#set up MINIST
train_set = MNIST(root='.',
train=True,
transform=transforms.Compose([
transforms.ToTensor(),
]),
download=True)
test_set = MNIST(root='.', train=False, download=True)
#dataloader
sampler = DistributedSampler(train_set)
train_dataloader = DataLoader(train_set,
batch_size=batch_size,
sampler=sampler)
#instantiate model from class
model = SmithNet(num_classes=10)
model = DistributedDataParallel(model)
#set up optimizer
optimizer = optim.SGD(model.parameters(), lr=0.1)
#set up loss
criterion = nn.CrossEntropyLoss()
rank = dist.get_rank()
#loop for epochs
iter_losses = []
epoch_losses = []
elapsed_times = []
epbar = range(num_epochs)
start = perf_counter()
for ep in epbar:
#loop over data (minibatch)
ep_loss = 0.0
num_iters = 0
for X, Y in train_dataloader:
#zero gradients
optimizer.zero_grad()
#eval model
pred = model(X)
#compare w labels
loss = criterion(pred, Y)
#print loss
iter_losses.append(loss.item())
ep_loss += loss.item()
#compute gradients
loss.backward()
#step optimizer
optimizer.step()
num_iters += 1
ep_loss /= num_iters
#print epoch loss
if rank == 0:
print("epoch", ep, "num_iters", num_iters, "loss", ep_loss,
"elapsed time (s)",
perf_counter() - start)
elapsed_times.append(perf_counter() - start)
epoch_losses.append(ep_loss)
metrics = pd.DataFrame({
'epoch_losses': epoch_losses,
'elapsed_time': elapsed_times
})
metrics.to_csv('metrics8.csv')
return iter_losses, epoch_losses
def forward(self, x):
x1 = F.relu(self.input_layer(x)) # 16x28x28
x2 = F.relu(self.layer_1(x1)) # 32x14x14
x3 = F.relu(self.layer_2(x2)) # 64x7x7
x4 = self.layer_3(x3) # Bx64x1x1
x5 = x4.view(
x4.shape[0],
64) # x4.shape : Bx64x1x1 >> Bx64 *squeeze 1x64x1x1 >> 64
output = self.layer_4(x5) # Bx10
return output
if __name__ == '__main__': # 이 파일을 직접 실행할때만 True값 리턴
dataset = MNIST(root='./datasets',
train=True,
transform=ToTensor(),
download=True) # MNIST 데이터셋 다운로드
data_loader = DataLoader(
dataset, batch_size=32,
shuffle=True) #pytorch DataLoader 모듈 이용하여 데이터셋을 for 구문에서 돌림.
model = CNN() #모델 정의
criterion = nn.CrossEntropyLoss() #Loss 설정 (크로스엔트로피)
optim = torch.optim.Adam(
model.parameters(),
lr=0.001) # weight_new = weight_old - weight_gradient * lr
if os.path.isfile("./weight_dict.pt"): # weight_dict.pt 파일이 있으면 True 리턴
model_dict = torch.load('./weight_dict.pt')[
import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision.datasets import MNIST
from torchvision.transforms import ToTensor
from torchvision import transforms, datasets
train_data = MNIST('mnist', download=True, train=True)
test_data = MNIST('mnist', download=True, train=False)
# https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d
# * size_out = 1/stride * (size_in + 2 * padding - dilatation * (kernel_size - 1) - 1) + 1 * #
# in_channels (int) – Number of channels in the input image
# out_channels (int) – Number of channels produced by the convolution
# kernel_size (int or tuple) – Size of the convolving kernel
# stride (int or tuple, optional) – Stride of the convolution. Default: 1
# padding (int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0
# dilation (int or tuple, optional) – Spacing between kernel elements. Default: 1
# groups (int, optional) – Number of blocked connections from input channels to output channels. Default: 1
# bias (bool, optional) – If True, adds a learnable bias to the output. Default: True
)
model = {"generator": generator, "discriminator": discriminator}
optimizer = {
"generator":
torch.optim.Adam(generator.parameters(), lr=0.0003, betas=(0.5, 0.999)),
"discriminator":
torch.optim.Adam(discriminator.parameters(), lr=0.0003,
betas=(0.5, 0.999)),
}
loaders = {
"train":
DataLoader(
MNIST(
os.getcwd(),
train=True,
download=True,
transform=transforms.ToTensor(),
),
batch_size=32,
),
}
class CustomRunner(dl.Runner):
def _handle_batch(self, batch):
real_images, _ = batch
batch_metrics = {}
# Sample random points in the latent space
batch_size = real_images.shape[0]
random_latent_vectors = torch.randn(batch_size,
def main(args):
torch.manual_seed(args.seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(args.seed)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
ts = time.time()
index_n_labels, index_n_labels_v = data_lab_MNIST(split='train')
labels_conf = add_conf(index_n_labels, p=0.5, qyu=0.90, N=50000)
dataset = MNIST(labels=labels_conf,
conf=0,
conf_type='colour',
transform=trans_col_MNIST,
data_ty='training',
per_digit=False)
data_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
def KL(mu1, logvar1, mu2, logvar2, weights):
std1 = torch.exp(0.5 * logvar1)
std2 = torch.exp(0.5 * logvar2)
KL_div = torch.sum(weights *
(torch.log(std2) - torch.log(std1) +
(0.5 *
(torch.exp(logvar1) +
(mu1 - mu2).pow(2)) / torch.exp(logvar2)) - 0.5))
return KL_div
encoder_z = Encoder_Z(args.encoder_lsizes_z,
args.latent_size_z,
conditional=False,
num_labels=10).to(device)
encoder_w = Encoder_W(args.encoder_lsizes_w,
args.latent_size_w,
conditional=True,
num_labels=10).to(device)
## decoders
decoder_x = Decoder_X(args.decoder_lsizes_x, args.latent_size_z, False,
True, args.latent_size_w).to(device)
decoder_y_z = Decoder_Y(args.decoder_lsizes_y,
args.latent_size_z,
num_labels=10).to(device)
## trying this out to see if I can use the weights p(y/w) to learn unbiased model
decoder_y_w = Decoder_Y(args.decoder_lsizes_y,
args.latent_size_w,
num_labels=10).to(device)
optimizer1 = torch.optim.Adam(list(decoder_x.parameters()) +
list(encoder_w.parameters()) +
list(encoder_z.parameters()),
lr=1e-3)
optimizer2 = torch.optim.Adam(decoder_y_z.parameters(), lr=1e-3)
optimizer3 = torch.optim.Adam(decoder_y_w.parameters(), lr=1e-3)
logs = defaultdict(list)
for epoch in range(args.epochs):
tracker_epoch = defaultdict(lambda: defaultdict(dict))
for iteration, (x, y) in enumerate(data_loader):
x, y = x.to(device), y.to(device)
mu_z, logvar_z, z = encoder_z(
x
) ## so this is finding p(z/x) and not p(z/x,y) like in the paper ... ?
mu_w, logvar_w, w = encoder_w(x, y)
pred_x = decoder_x(z, w)
pred_y = decoder_y_z(z)
pred_y_w = decoder_y_w(w)
y_onehot = idx2onehot(y, n=10)
if args.interventional:
w_bk = ((y_onehot * pred_y_w).sum(dim=1)).pow(-1).unsqueeze(
-1) ## p(y = c/w)^(-1) weights for the bkdoor case
else:
w_bk = torch.ones(pred_y_w.shape[0], 1)
# pdb.set_trace()
kl_y = KL(mu_w,
logvar_w,
y.unsqueeze(-1) * torch.ones_like(mu_w),
torch.zeros_like(logvar_w),
weights=w_bk)
optimizer1.zero_grad()
mse = torch.nn.functional.mse_loss(pred_x, x, reduction='none')
loss1 = (
20. *
(w_bk * torch.sum(mse.view(mse.shape[0], -1), dim=-1)).sum() +
kl_y + 0.2 * KL(mu_z,
logvar_z,
torch.zeros_like(mu_z),
torch.zeros_like(logvar_z),
weights=w_bk) + 1000. * torch.sum(
(w_bk *
(pred_y * torch.log(pred_y))), -1).sum()
) # maximize entropy, enforce uniform distribution in predicting y from z
loss1.backward(retain_graph=True)
optimizer1.step()
optimizer2.zero_grad()
loss2 = 100 * (y_onehot * -torch.log(pred_y)).sum()
# loss2 = (100. * torch.where(y == 1, -torch.log(pred_y[:, 1]), -torch.log(pred_y[:, 0]))).sum()
loss2.backward()
optimizer2.step()
loss3 = F.nll_loss(pred_y_w, y)
optimizer3.zero_grad()
loss3.backward()
optimizer3.step()
loss = loss1 + loss2
logs['loss'].append(loss.item())
logs['counts'].append(epoch *
int(len(data_loader) / args.batch_size) +
iteration)
print("Epoch {:02d}/{:02d} Batch {:04d}/{:d}, Loss {:9.4f}".format(
epoch, args.epochs, iteration,
len(data_loader) - 1, loss.item()))
if iteration % args.print_every == 0 or iteration == len(
data_loader) - 1:
plt.figure()
plt.figure(figsize=(10, 10))
for p in range(10):
ax = plt.subplot2grid((10, 2), (p, 0))
if args.conditional or args.interventional:
ax.text(0,
0,
"c={:d}".format(y[p].item()),
color='black',
backgroundcolor='white',
fontsize=8)
ax.imshow(x[p].permute(1, 2, 0).cpu().data.numpy())
ax.axis('off')
ax_1 = plt.subplot2grid((10, 2), (p, 1))
if args.conditional or args.interventional:
ax_1.text(0,
0,
"c={:d}".format(y[p].item()),
color='black',
backgroundcolor='white',
fontsize=8)
ax_1.imshow(pred_x[p].permute(1, 2, 0).cpu().data.numpy())
ax_1.axis('off')
os.makedirs(os.path.join(args.fig_root, str(ts)),
exist_ok=True)
plt.savefig(os.path.join(
args.fig_root, str(ts),
"org{:d}I{:d}.png".format(epoch, iteration)),
dpi=300)
plt.clf()
plt.close('all')
with torch.no_grad():
c = torch.arange(0, 10).long().unsqueeze(1).to(device)
sam_z = torch.randn([c.size(0),
args.latent_size_z]).to(device)
sam_w = (c * torch.ones([c.size(0), args.latent_size_w]) +
torch.randn([c.size(0), args.latent_size_w
])).to(device)
## checking if my w really is learning some bias -- does sampling it from the same mean for different classes give the same results?
# sam_w = torch.zeros([c.size(0), args.latent_size_w]).to(device)
pred_x_sam = decoder_x(z, w)
plt.figure()
plt.figure(figsize=(5, 10))
for p in range(10):
plt.subplot(5, 2, p + 1)
plt.text(0,
0,
"c={:d}".format(c[p].item()),
color='black',
backgroundcolor='white',
fontsize=8)
plt.imshow(pred_x_sam[p].permute(1, 2,
0).cpu().data.numpy())
plt.axis('off')
plt.savefig(os.path.join(
args.fig_root, str(ts),
"E{:d}I{:d}.png".format(epoch, iteration)),
dpi=300)
plt.clf()
plt.close('all')
plt.figure()
plt.plot(logs['counts'], logs['loss'])
plt.savefig(os.path.join(args.fig_root, str(ts), "loss"))
plt.clf()
os.makedirs(os.path.join('/scratch/gobi2/sindhu/gen/vae/',
args.model_path),
exist_ok=True)
torch.save(
{
'state_dict_decoder_x': decoder_x.state_dict(),
'state_dict_decoder_y': decoder_y_z.state_dict(),
'state_dict_encoder_w': encoder_w.state_dict(),
'state_dict_encoder_z': encoder_z.state_dict(),
}, f'{args.model_path}')
import torch
from torch.autograd import Variable
from torch import nn
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision import transforms as tfs
from torchvision.utils import save_image
im_tfs = tfs.Compose([
tfs.ToTensor(),
tfs.Normalize([0.5], [0.5]) # 标准化
])
train_set = MNIST('./mnist', transform=im_tfs,download=True)
train_data = DataLoader(train_set, batch_size=2048, shuffle=True)
# 定义网络
class autoencoder(nn.Module):
def __init__(self):
super(autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU(True),
nn.Linear(128, 64),
nn.ReLU(True),
nn.Linear(64, 12),
nn.ReLU(True),
nn.Linear(12, 3) # 输出的 code 是 3 维，便于可视化
def main():
# specify data transforms
train_tfms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
test_tfms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
# load data
path = Path.cwd()
print(path)
train_ds = MNIST(path, train=True, download=True, transform=train_tfms)
test_ds = MNIST(path, train=False, download=True, transform=test_tfms)
# specify training/validation split
val_pct = 0.2
val_size = int(val_pct * len(train_ds))
train_ds, val_ds = random_split(train_ds,
[len(train_ds) - val_size, val_size])
val_ds.transform = test_tfms
print(f"Training set size: {len(train_ds)}")
print(f"Validation set size: {len(val_ds)}")
print(f"Test set size: {len(test_ds)}")
# set up data loaders
batch_size = 64
print(f"Batch size: {batch_size}")
train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
val_dl = DataLoader(val_ds, batch_size=batch_size, shuffle=False)
test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False)
for label, dl in zip(['Training', 'Validation', 'Test'],
[train_dl, val_dl, test_dl]):
x_b, y_b = next(iter(dl))
print(
f"{label} set: Input shape: {list(x_b.shape)}, Output shape: {list(y_b.shape)}"
)
# specify model
model = conv_net(ni=1, no=10, nf=[16, 32, 64], nh=[128, 64])
print(model)
# specify loss function
def loss_fn(logits, labels):
return F.cross_entropy(logits, labels)
# specify optimizer
optimizer = optim.Adam([{
'params': model[0:3].parameters()
}, {
'params': model[3:8].parameters()
}])
# execute training loop
n_epochs = 3
max_lr = (1e-3, 1e-2)
total_steps = n_epochs * (len(train_dl.dataset) // train_dl.batch_size)
run = Runner(model,
train_dl=train_dl,
val_dl=val_dl,
loss_fn=loss_fn,
metric_fns=[accuracy],
optimizer=optimizer,
callbacks=[
Logger(print_every=1),
WeightDecay(wd=1e-2),
OptimLRScheduler(OneCycleLR,
max_lr=max_lr,
total_steps=total_steps,
pct_start=0.3,
div_factor=1e1,
final_div_factor=1e4)
])
run.train(n_epochs=n_epochs, device='cuda')
# plot learning rates
lr = run.callbacks['OptimLRScheduler'].history['lr']
lr = list(zip(*lr))
plt.figure()
plt.plot(lr[0])
plt.figure()
plt.plot(lr[1])
plt.show()
plt.show()
if __name__ == '__main__':
PATH = 'models/latent2_ep100_lr0.001_capacity64_batch128_beta1e-05_1614553086_894832.pt'
vae = torch.load(PATH, map_location='cpu')
vae.eval()
batch_size = 128
beta = 1e-5
latent_dims = 2
TRANSFORMS = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
])
test_dataset = MNIST(root='./data/MNIST',
download=True,
train=False,
transform=TRANSFORMS,
target_transform=None)
test_dataloader = DataLoader(test_dataset,
batch_size=batch_size,
shuffle=True)
reconstruction_error(test_dataloader, vae, beta)
reconstruction(test_dataloader, vae)
interpolation_plot(vae, sort_digit(test_dataloader))
generate(vae)
generation_map(vae)
import torch
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
mnist_data = MNIST('./mnist', train=True, download=False, transform = transforms.ToTensor())
data_loader = DataLoader(mnist_data, batch_size=4, shuffle=True)
for num_batch, images in enumerate(data_loader):
print(num_batch, images)
if num_batch == 4:
print("finished")
break
def main():
utils.writer = SummaryWriter()
parser = argparse.ArgumentParser()
parser.add_argument('--no-cuda',
action='store_true',
default=False,
help='Disables CUDA training.')
parser.add_argument('--epochs',
type=int,
default=700,
help='Number of epochs to train.')
parser.add_argument('--link-pred',
action='store_true',
default=False,
help='Enable Link Prediction Loss')
parser.add_argument('--dataset',
default='ENZYMES',
help="Choose dataset: ENZYMES, DD")
parser.add_argument('--batch-size',
default=256,
type=int,
help="Choose dataset: ENZYMES, DD")
parser.add_argument('--train-ratio',
default=0.9,
type=float,
help="Train/Val split ratio")
parser.add_argument('--pool-ratio',
default=0.25,
type=float,
help="Train/Val split ratio")
args = parser.parse_args()
utils.writer.add_text("args", str(args))
device = "cuda" if not args.no_cuda and torch.cuda.is_available(
) else "cpu"
# dataset = TUDataset(args.dataset)
dataset = MNIST(root="~/.torch/data/",
transform=GraphTransform(device),
download=True)
dataset_size = len(dataset)
train_size = int(dataset_size * args.train_ratio)
test_size = dataset_size - train_size
max_num_nodes = max([item[0][0].shape[0] for item in dataset])
n_classes = int(max([item[1] for item in dataset])) + 1
train_data, test_data = random_split(dataset, (train_size, test_size))
input_shape = int(dataset[0][0][1].shape[-1])
train_loader = DataLoader(train_data,
batch_size=args.batch_size,
shuffle=True,
collate_fn=CollateFn(device))
test_loader = DataLoader(test_data,
batch_size=args.batch_size,
shuffle=True,
collate_fn=CollateFn(device))
model = BatchedModel(pool_size=int(max_num_nodes * args.pool_ratio),
device=device,
link_pred=args.link_pred,
input_shape=input_shape,
n_classes=n_classes).to(device)
model.train()
optimizer = optim.Adam(model.parameters())
for e in tqdm(range(args.epochs)):
utils.e = e
epoch_losses_list = []
true_sample = 0
model.train()
for i, (adj, features, masks, batch_labels) in enumerate(train_loader):
utils.train_iter += 1
graph_feat = model(features, adj, masks)
output = model.classifier(graph_feat)
loss = model.loss(output, batch_labels)
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 2.0)
optimizer.step()
optimizer.zero_grad()
epoch_losses_list.append(loss.item())
iter_true_sample = (output.argmax(dim=1).long() == batch_labels.long()). \
float().sum().item()
iter_acc = float(iter_true_sample) / output.shape[0]
utils.writer.add_scalar("iter train acc", iter_acc,
utils.train_iter)
print(f"{utils.train_iter} iter train acc: {iter_acc}")
true_sample += iter_true_sample
acc = true_sample / train_size
utils.writer.add_scalar("Epoch Acc", acc, e)
tqdm.write(f"Epoch:{e} \t train_acc:{acc:.2f}")
test_loss_list = []
true_sample = 0
model.eval()
with torch.no_grad():
for i, (adj, features, masks,
batch_labels) in enumerate(test_loader):
utils.test_iter += 1
graph_feat = model(features, adj, masks)
output = model.classifier(graph_feat)
loss = model.loss(output, batch_labels)
test_loss_list.append(loss.item())
iter_true_sample = (output.argmax(dim=1).long() == batch_labels.long()). \
float().sum().item()
iter_acc = float(iter_true_sample) / output.shape[0]
utils.writer.add_scalar("iter test acc", iter_acc,
utils.test_iter)
print(f"{utils.test_iter} iter test acc: {iter_acc}")
true_sample += iter_true_sample
acc = true_sample / test_size
utils.writer.add_scalar("Epoch Acc", acc, e)
tqdm.write(f"Epoch:{e} \t val_acc:{acc:.2f}")
def test_dataloader(self):
test_dataset = MNIST(os.getcwd(), train=False, download=True, transform=transforms.ToTensor())
loader = DataLoader(test_dataset, batch_size=self.hparams.batch_size, num_workers=self.hparams.num_workers)
return loader
def val_dataloader(self):
dataset = MNIST(self.hparams.data_dir, train=True, download=False, transform=transforms.ToTensor())
_, mnist_val = random_split(dataset, [55000, 5000])
loader = DataLoader(mnist_val, batch_size=self.hparams.batch_size, num_workers=self.hparams.num_workers)
return loader
def main():
# Training settings
parser = argparse.ArgumentParser(description='Amortized approximation on MNIST')
parser.add_argument('--batch-size', type=int, default=512, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=64, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--approx-epochs', type=int, default=200, metavar='N',
help='number of epochs to approx (default: 10)')
parser.add_argument('--lr', type=float, default=1e-2, metavar='LR',
help='learning rate (default: 0.0005)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--S', type=int, default=500, metavar='N',
help='number of posterior samples from the Bayesian model')
parser.add_argument('--model-path', type=str, default='../saved_models/mnist_mcdp/', metavar='N',
help='number of posterior samples from the Bayesian model')
parser.add_argument('--save-approx-model', type=int, default=0, metavar='N',
help='save approx model or not? default not')
parser.add_argument('--from-model', type=int, default=0, metavar='N',
help='if our model is loaded or trained')
parser.add_argument('--from-approx-model', type=int, default=1, metavar='N',
help='if our model is loaded or trained')
parser.add_argument('--test-ood-from-disk', type=int, default=1,
help='generate test samples or load from disk')
parser.add_argument('--ood-name', type=str, default='omniglot',
help='name of the used ood dataset')
args = parser.parse_args()
use_cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
device = torch.device("cuda" if use_cuda else "cpu")
kwargs = {'num_workers': 8, 'pin_memory': True} if use_cuda else {}
tr_data = MNIST('../data', train=True, transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))]), download=True)
te_data = MNIST('../data', train=False, transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))]), download=True)
if args.ood_name == 'omniglot':
ood_data = datasets.Omniglot('../data', download=True, transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,)),
]))
elif args.ood_name == 'SEMEION':
ood_data = datasets.SEMEION('../data', download=True, transform=transforms.Compose([
transforms.Resize((28, 28)),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,)),
]))
train_loader = torch.utils.data.DataLoader(
tr_data,
batch_size=args.batch_size, shuffle=False, **kwargs)
test_loader = torch.utils.data.DataLoader(
te_data,
batch_size=args.batch_size, shuffle=False, **kwargs)
ood_loader = torch.utils.data.DataLoader(
ood_data,
batch_size=args.batch_size, shuffle=False, **kwargs)
model = mnist_mlp().to(device)
model.load_state_dict(torch.load(args.model_path + 'mcdp-mnist.pt'))
test(args, model, device, test_loader)
if args.from_approx_model == 0:
output_samples = torch.load(args.model_path + 'mnist-mcdp-samples.pt')
# --------------- training approx ---------
fmodel = mnist_mlp_h().to(device)
gmodel = mnist_mlp_g().to(device)
if args.from_approx_model == 0:
g_optimizer = optim.SGD(gmodel.parameters(), lr=args.lr)
f_optimizer = optim.SGD(fmodel.parameters(), lr=args.lr)
g_scheduler = optim.lr_scheduler.StepLR(g_optimizer, step_size=30, gamma=0.1)
f_scheduler = optim.lr_scheduler.StepLR(f_optimizer, step_size=30, gamma=0.1)
best_acc = 0
for epoch in range(1, args.approx_epochs + 1):
train_approx(args, fmodel, gmodel, device, train_loader, f_optimizer, g_optimizer, output_samples, epoch)
acc = test(args, fmodel, device, test_loader)
# if (args.save_approx_model == 1):
if acc > best_acc:
torch.save(fmodel.state_dict(), args.model_path + 'mcdp-mnist-mmd-mean.pt')
torch.save(gmodel.state_dict(), args.model_path + 'mcdp-mnist-mmd-conc.pt')
best_acc = acc
g_scheduler.step(epoch)
f_scheduler.step(epoch)
else:
fmodel.load_state_dict(torch.load(args.model_path + 'mcdp-mnist-mmd-mean.pt'))
gmodel.load_state_dict(torch.load(args.model_path + 'mcdp-mnist-mmd-conc.pt'))
print('generating teacher particles for testing&ood data ...')
# generate particles for test and ood dataset
model.train()
if args.test_ood_from_disk == 1:
teacher_test_samples = torch.load(args.model_path + 'mnist-mcdp-test-samples.pt')
else:
with torch.no_grad():
# obtain ensemble outputs
all_samples = []
for i in range(500):
samples_a_round = []
for data, target in test_loader:
data = data.to(device)
data = data.view(data.shape[0], -1)
output = F.softmax(model(data))
samples_a_round.append(output)
samples_a_round = torch.cat(samples_a_round).cpu()
all_samples.append(samples_a_round)
all_samples = torch.stack(all_samples).permute(1,0,2)
torch.save(all_samples, args.model_path + 'mnist-mcdp-test-samples.pt')
teacher_test_samples = all_samples
if args.test_ood_from_disk == 1:
teacher_ood_samples = torch.load(args.model_path + args.ood_name + '-mcdp-ood-samples-trd-mnist.pt')
else:
with torch.no_grad():
# obtain ensemble outputs
all_samples = []
for i in range(500):
samples_a_round = []
for data, target in ood_loader:
data = data.to(device)
data = data.view(data.shape[0], -1)
output = F.softmax(model(data))
samples_a_round.append(output)
samples_a_round = torch.cat(samples_a_round).cpu()
all_samples.append(samples_a_round)
all_samples = torch.stack(all_samples).permute(1,0,2)
torch.save(all_samples, args.model_path + args.ood_name + '-mcdp-ood-samples-trd-mnist.pt')
teacher_ood_samples = all_samples
# fitting individual Dirichlet is not in the sample code as it's time-consuming
eval_approx(args, fmodel, gmodel, device, test_loader, ood_loader, teacher_test_samples, teacher_ood_samples)
return gen_loss
# Set your parameters
criterion = nn.BCEWithLogitsLoss()
n_epochs = 200
z_dim = 64
display_step = 2000
batch_size = 128
lr = 1e-5
device = 'cuda:0'
# Load MNIST dataset as tensors
dataset_root = "/home/liuzhian/hdd/datasets/MNIST"
dataloader = DataLoader(MNIST(root=dataset_root,
download=True,
transform=transforms.ToTensor()),
batch_size=batch_size,
shuffle=True)
gen = Generator(z_dim).to(device)
gen_opt = torch.optim.Adam(gen.parameters(), lr=lr)
disc = Discriminator().to(device)
disc_opt = torch.optim.Adam(disc.parameters(), lr=lr)
cur_step = 0
mean_generator_loss = 0
mean_discriminator_loss = 0
test_generator = True # Whether the generator should be tested
gen_loss = False
for epoch in range(n_epochs):
from tensorboardX import SummaryWriter
from tqdm import tqdm
#%%
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("device:", device)
# %%
transform = transforms.Compose([
#transforms.Grayscale(),
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, ), std=(0.5, ))
])
# %%
batch_size = 32
data_loader = torch.utils.data.DataLoader(MNIST('data',
train=True,
download=True,
transform=transform),
batch_size=batch_size,
shuffle=True)
# %%
class Discriminator(nn.Module):
def __init__(self):
super().__init__()
self.label_emb = nn.Embedding(10, 10)
self._model = nn.Sequential(nn.Linear(1034, 128), nn.Linear(128, 1),
nn.Sigmoid())
def to_img(x):
x = 0.5 * (x + 1)
x = x.clamp(0, 1)
x = x.view(x.size(0), 1, 28, 28)
return x
num_epochs = 20
batch_size = 128
learning_rate = 1e-3
img_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5), (0.5))])
dataset = MNIST('./data', transform=img_transform, download=True)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
class autoencoder(nn.Module):
def __init__(self):
super(autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(1, 16, 3, stride=3, padding=1), # b, 16, 10, 10
nn.ReLU(True),
nn.MaxPool2d(2, stride=2), # b, 16, 5, 5
nn.Conv2d(16, 8, 3, stride=2, padding=1), # b, 8, 3, 3
nn.ReLU(True),
nn.MaxPool2d(2, stride=1) # b, 8, 2, 2
)
self.decoder = nn.Sequential(
def main():
# specify data transforms
train_tfms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
test_tfms = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))])
# load data
path = Path.cwd()
print(path)
train_ds = MNIST(path, train=True, download=True, transform=train_tfms)
test_ds = MNIST(path, train=False, download=True, transform=test_tfms)
# specify training/validation split
val_pct = 0.2
val_size = int(val_pct * len(train_ds))
train_ds, val_ds = random_split(train_ds,
[len(train_ds) - val_size, val_size])
val_ds.transform = test_tfms
print(f"Training set size: {len(train_ds)}")
print(f"Validation set size: {len(val_ds)}")
print(f"Test set size: {len(test_ds)}")
# set up data loaders
batch_size = 64
print(f"Batch size: {batch_size}")
train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)
val_dl = DataLoader(val_ds, batch_size=batch_size, shuffle=False)
test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False)
for label, dl in zip(['Training', 'Validation', 'Test'],
[train_dl, val_dl, test_dl]):
x_b, y_b = next(iter(dl))
print(
f"{label} set: Input shape: {list(x_b.shape)}, Output shape: {list(y_b.shape)}"
)
# specify model
model = conv_net(ni=1, no=10, nf=[16, 32, 64], nh=[128, 64])
print(model)
# specify loss function
def loss_fn(logits, labels):
return F.cross_entropy(logits, labels)
# specify optimizer
optimizer = optim.Adam([{
'params': model[0:3].parameters()
}, {
'params': model[3:8].parameters()
}])
# plot schedules
torch.Tensor.ndim = property(
lambda x: len(x.shape)) # monkey patch for plotting tensors
a = torch.arange(0, 100)
p = torch.linspace(0.01, 1, 100)
sched_1 = combine_schedules(
[0.3, 0.7], [cos_schedule(1e-4, 1e-3),
cos_schedule(1e-3, 1e-5)])
plt.plot(a, [sched_1(o) for o in p])
sched_2 = combine_schedules(
[0.3, 0.7], [cos_schedule(1e-3, 1e-2),
cos_schedule(1e-2, 1e-4)])
plt.figure()
plt.plot(a, [sched_2(o) for o in p])
sched_3 = combine_schedules(
[0.3, 0.7], [cos_schedule(0.95, 0.85),
cos_schedule(0.85, 0.95)])
plt.figure()
plt.plot(a, [sched_3(o) for o in p])
sched_4 = combine_schedules(
[0.3, 0.7], [cos_schedule(0.95, 0.85),
cos_schedule(0.85, 0.95)])
plt.figure()
plt.plot(a, [sched_4(o) for o in p])
plt.show()
run = Runner(model,
train_dl=train_dl,
val_dl=val_dl,
loss_fn=loss_fn,
metric_fns=[accuracy],
optimizer=optimizer,
callbacks=[
Logger(print_every=1),
WeightDecay(wd=1e-2),
OneCycleScheduler()
])
run.train(n_epochs=3, lr=(1e-3, 1e-2))
# plot results
lr = run.callbacks['OneCycleScheduler'].history['lr']
lr = np.array(list(zip(*lr)))
print(f"LR shape: {lr.shape}")
plt.plot(lr[0])
plt.figure()
plt.plot(lr[1])
betas = run.callbacks['OneCycleScheduler'].history['betas']
betas = list(zip(*betas))
betas = np.array(betas)
print(f"Betas shape: {betas.shape}")
plt.figure()
plt.plot(betas[0, :, 0])
plt.figure()
plt.plot(betas[0, :, 1])
plt.figure()
plt.plot(betas[1, :, 0])
plt.figure()
plt.plot(betas[1, :, 1])
plt.show()
def main(args):
# --- CONFIG
device = torch.device(f"cuda:{args.cuda}" if torch.cuda.is_available()
and args.cuda >= 0 else "cpu")
# ---------
# --- TRANSFORMATIONS
train_transform = transforms.Compose([
RandomCrop(28, padding=4),
ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
test_transform = transforms.Compose(
[ToTensor(), transforms.Normalize((0.1307, ), (0.3081, ))])
# ---------
# --- SCENARIO CREATION
mnist_train = MNIST('./data/mnist',
train=True,
download=True,
transform=train_transform)
mnist_test = MNIST('./data/mnist',
train=False,
download=True,
transform=test_transform)
scenario = nc_scenario(mnist_train,
mnist_test,
5,
task_labels=False,
seed=1234)
# ---------
# MODEL CREATION
model = SimpleMLP(num_classes=scenario.n_classes)
eval_plugin = EvaluationPlugin(
accuracy_metrics(epoch=True, experience=True, stream=True),
loss_metrics(epoch=True, experience=True, stream=True),
# save image should be False to appropriately view
# results in Interactive Logger.
# a tensor will be printed
StreamConfusionMatrix(save_image=False, normalize='all'),
loggers=InteractiveLogger())
# CREATE THE STRATEGY INSTANCE (NAIVE)
cl_strategy = Naive(model,
SGD(model.parameters(), lr=0.001, momentum=0.9),
CrossEntropyLoss(),
train_mb_size=100,
train_epochs=4,
eval_mb_size=100,
device=device,
evaluator=eval_plugin,
plugins=[ReplayPlugin(5000)])
# TRAINING LOOP
print('Starting experiment...')
results = []
for experience in scenario.train_stream:
print("Start of experience: ", experience.current_experience)
print("Current Classes: ", experience.classes_in_this_experience)
cl_strategy.train(experience)
print('Training completed')
print('Computing accuracy on the whole test set')
results.append(cl_strategy.eval(scenario.test_stream))
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
from torchvision import transforms
if __name__=='__main__':
path = 'F:\\Dropbox\\DataScience\\FacialVarificationProject\\data\\MNIST_PYTORCH'
trans = transforms.Compose(
[
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
])
dataset_tr = MNIST(root=path, train=True, download=False, transform=trans)
dataset_te = MNIST(root=path, train=False, download=False, transform=trans)
train_loader = DataLoader(dataset_tr)
test_loader = DataLoader(dataset_te)
for img, label in train_loader:
print(img.shape)
print(label.shape)
break
learning_rate = 1e-3
variational_beta = 1
use_gpu = True
device = "cuda:0"
#device = torch.device("cuda:0" if use_gpu and torch.cuda.is_available() else "cpu")
# 10 epochs on GPU: 20 seconds
# 10 epochs on CPU: 244 seconds
# Load MNIST # digits 0-9 in 28 x 28 grayscale images (1 channel, not 3 channel RGB)
import torchvision.transforms as transforms
from torch.utils.data import DataLoader # combines dataset and sampler
from torchvision.datasets import MNIST
img_transform = transforms.Compose([transforms.ToTensor()])
train_dataset = MNIST(root='/data/MNIST',
download=True,
train=True,
transform=img_transform)
train_dataloader = DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True)
test_dataset = MNIST(root='/data/MNIST',
download=True,
train=False,
transform=img_transform)
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True)
#VAE Model, convolutional layers instead of fully connected layers
class Encoder(nn.Module):
def __init__(self):
def train(self):
if self.config.data.random_flip is False:
tran_transform = test_transform = transforms.Compose([
transforms.Resize(self.config.data.image_size),
transforms.ToTensor()
])
else:
tran_transform = transforms.Compose([
transforms.Resize(self.config.data.image_size),
transforms.RandomHorizontalFlip(p=0.5),
transforms.ToTensor()
])
test_transform = transforms.Compose([
transforms.Resize(self.config.data.image_size),
transforms.ToTensor()
])
if self.config.data.dataset == 'CIFAR10':
dataset = CIFAR10(os.path.join(self.args.run, 'datasets',
'cifar10'),
train=True,
download=True,
transform=tran_transform)
test_dataset = CIFAR10(os.path.join(self.args.run, 'datasets',
'cifar10_test'),
train=False,
download=True,
transform=test_transform)
elif self.config.data.dataset == 'MNIST':
dataset = MNIST(os.path.join(self.args.run, 'datasets', 'mnist'),
train=True,
download=True,
transform=tran_transform)
test_dataset = MNIST(os.path.join(self.args.run, 'datasets',
'mnist_test'),
train=False,
download=True,
transform=test_transform)
elif self.config.data.dataset == 'CELEBA':
if self.config.data.random_flip:
dataset = CelebA(
root=os.path.join(self.args.run, 'datasets', 'celeba'),
split='train',
transform=transforms.Compose([
transforms.CenterCrop(140),
transforms.Resize(self.config.data.image_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
]),
download=True)
else:
dataset = CelebA(
root=os.path.join(self.args.run, 'datasets', 'celeba'),
split='train',
transform=transforms.Compose([
transforms.CenterCrop(140),
transforms.Resize(self.config.data.image_size),
transforms.ToTensor(),
]),
download=True)
test_dataset = CelebA(
root=os.path.join(self.args.run, 'datasets', 'celeba_test'),
split='test',
transform=transforms.Compose([
transforms.CenterCrop(140),
transforms.Resize(self.config.data.image_size),
transforms.ToTensor(),
]),
download=True)
elif self.config.data.dataset == 'SVHN':
dataset = SVHN(os.path.join(self.args.run, 'datasets', 'svhn'),
split='train',
download=True,
transform=tran_transform)
test_dataset = SVHN(os.path.join(self.args.run, 'datasets',
'svhn_test'),
split='test',
download=True,
transform=test_transform)
dataloader = DataLoader(dataset,
batch_size=self.config.training.batch_size,
shuffle=True,
num_workers=4)
test_loader = DataLoader(test_dataset,
batch_size=self.config.training.batch_size,
shuffle=True,
num_workers=4,
drop_last=True)
test_iter = iter(test_loader)
self.config.input_dim = self.config.data.image_size**2 * self.config.data.channels
tb_path = os.path.join(self.args.run, 'tensorboard', self.args.doc)
if os.path.exists(tb_path):
shutil.rmtree(tb_path)
tb_logger = tensorboardX.SummaryWriter(log_dir=tb_path)
score = CondRefineNetDilated(self.config).to(self.config.device)
score = torch.nn.DataParallel(score)
optimizer = self.get_optimizer(score.parameters())
if self.args.resume_training:
states = torch.load(os.path.join(self.args.log, 'checkpoint.pth'))
score.load_state_dict(states[0])
optimizer.load_state_dict(states[1])
step = 0
sigmas = torch.tensor(
np.exp(
np.linspace(np.log(self.config.model.sigma_begin),
np.log(self.config.model.sigma_end),
self.config.model.num_classes))).float().to(
self.config.device)
for epoch in range(self.config.training.n_epochs):
for i, (X, y) in enumerate(dataloader):
step += 1
score.train()
X = X.to(self.config.device)
X = X / 256. * 255. + torch.rand_like(X) / 256.
if self.config.data.logit_transform:
X = self.logit_transform(X)
labels = torch.randint(0,
len(sigmas), (X.shape[0], ),
device=X.device)
if self.config.training.algo == 'dsm':
loss = anneal_dsm_score_estimation(
score, X, labels, sigmas,
self.config.training.anneal_power)
elif self.config.training.algo == 'ssm':
loss = anneal_sliced_score_estimation_vr(
score,
X,
labels,
sigmas,
n_particles=self.config.training.n_particles)
optimizer.zero_grad()
loss.backward()
optimizer.step()
tb_logger.add_scalar('loss', loss, global_step=step)
logging.info("step: {}, loss: {}".format(step, loss.item()))
if step >= self.config.training.n_iters:
return 0
if step % 100 == 0:
score.eval()
try:
test_X, test_y = next(test_iter)
except StopIteration:
test_iter = iter(test_loader)
test_X, test_y = next(test_iter)
test_X = test_X.to(self.config.device)
test_X = test_X / 256. * 255. + torch.rand_like(
test_X) / 256.
if self.config.data.logit_transform:
test_X = self.logit_transform(test_X)
test_labels = torch.randint(0,
len(sigmas),
(test_X.shape[0], ),
device=test_X.device)
with torch.no_grad():
test_dsm_loss = anneal_dsm_score_estimation(
score, test_X, test_labels, sigmas,
self.config.training.anneal_power)
tb_logger.add_scalar('test_dsm_loss',
test_dsm_loss,
global_step=step)
if step % self.config.training.snapshot_freq == 0:
states = [
score.state_dict(),
optimizer.state_dict(),
]
torch.save(
states,
os.path.join(self.args.log,
'checkpoint_{}.pth'.format(step)))
torch.save(states,
os.path.join(self.args.log, 'checkpoint.pth'))
x = 0.5 * (x + 1)
x = x.clamp(0, 1)
x = x.view(x.size(0), 1, 28, 28)
return x
num_epochs = 100
batch_size = 128
learning_rate = 1e-3
img_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
dataset = MNIST('/home/lrh/dataset/mnist', transform=img_transform)
dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=True)
class autoencoder(nn.Module):
def __init__(self):
super(autoencoder, self).__init__()
self.encoder = nn.Sequential(
nn.Conv2d(1, 16, 3, stride=3, padding=1), # b, 16, 10, 10
nn.ReLU(True),
nn.MaxPool2d(2, stride=2), # b, 16, 5, 5
nn.Conv2d(16, 8, 3, stride=2, padding=1), # b, 8, 3, 3
nn.ReLU(True),
nn.MaxPool2d(2, stride=1) # b, 8, 2, 2
)
self.decoder = nn.Sequential(
import re
import os
import pickle
import sys
from tqdm import tqdm
from torchvision.datasets import MNIST
import matplotlib.image
import numpy as np
work_dir = os.path.abspath(sys.argv[1])
train_dir = os.path.abspath(os.path.join(sys.argv[2], 'train'))
test_dir = os.path.abspath(os.path.join(sys.argv[2], 'test'))
mnist_train = MNIST(work_dir, train=True, download=True)
mnist_test = MNIST(work_dir, train=False, download=True)
def unpack(source_data, target_dir, start_idx):
for idx, (image_data, label_idx) in tqdm(enumerate(source_data), total=len(source_data)):
subdir = os.path.join(target_dir, str(label_idx))
name = '{}_{}.png'.format(start_idx + idx, str(label_idx))
os.makedirs(subdir, exist_ok=True)
matplotlib.image.imsave(os.path.join(subdir, name), image_data)
return len(source_data)
start_idx = 0
start_idx += unpack(mnist_train, train_dir, start_idx)
# ]), download=True) #从internet上下载MNIST训练数据集，并Resize成32x32大小，转为Tensor
parser = argparse.ArgumentParser(
description='PyTorch LeNet Inference') #使用argparse库实现 超参数的命令行 输入
parser.add_argument('--batch_size',
'-b',
default=1024,
type=int,
help='BatchSize')
args = parser.parse_args() #若想调用parser的中的参数，直接调用args.参数
data_test = MNIST(
'D:/数据结构学习/LeNet_master/data/test',
train=False,
transform=transforms.Compose(
[transforms.Resize((32, 32)),
transforms.ToTensor()]),
download=True) #从internet上下载MNIST测试数据集，并Resize成32x32大小，转为Tensor
# data_train_loader = DataLoader(data_train, batch_size=256, shuffle=True, num_workers=8) #8个线程处理，随机抽取，batch=256
data_test_loader = DataLoader(data_test,
batch_size=args.batch_size,
num_workers=0)
### LeNet工程推理代码部分
save_info_path = 'D:/数据结构学习/LeNet_master/model_save/model.pth'
save_info = torch.load(save_info_path)
model = LeNet()
criterion = nn.CrossEntropyLoss()
imgs_r = []
labels_r = []
for key in indices.keys():
for idx in indices[key]:
imgs_r.append(imgs[idx])
labels_r.append(labels[idx])
filename = './RMNIST/dataset/trainImg_' + str(
n) + '.npy' if test is False else './RMNIST/dataset/testImg_' + str(n) + '.npy'
filename_label = './RMNIST/dataset/trainlabel_' + str(
n) + '.npy' if test is False else './RMNIST/dataset/testlabel_' + str(n) + '.npy'
np.save(filename, np.asarray(imgs_r))
np.save(filename_label, np.asarray(labels_r))
# Load MNIST train and test sets.
ds_trainX = MNIST(root='./', train=True, download=True)
ds_trainY = ds_trainX.targets.numpy()
ds_trainX = ds_trainX.data.numpy().astype('float32')
ds_testX = MNIST(root='./', train=False, download=True)
ds_testY = ds_testX.targets.numpy()
ds_testX = ds_testX.data.numpy().astype('float32')
print(ds_trainX[0].shape)
n = 40
indices = get_rmnist_idx(n, ds_trainY, test=False)
with open("./RMNIST/indexes/rmnist" + str(n) + "_train", "rb") as f:
data = pkl.load(f)
get_rmnist(n, data, ds_trainX, ds_trainY, test=False)
n = 25
indices_test = get_rmnist_idx(n, ds_testY, test=True)
sample_idx = list(itertools.chain(*cls_idxs))
return sample_idx
def __len__(self):
return self.total
if __name__ == "__main__":
from torchvision.datasets import MNIST
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
trans = transforms.Compose([transforms.ToTensor()])
minist = MNIST(
root="./DATASET/MNIST", train=True, download=True, transform=trans
)
a = minist.targets.numpy()
pa = PartialSampler(a, [1, 2, 3, 4, 5, 6, 7])
balanced = BalancedSampler(pa)
data = DataLoader(
minist, batch_size=120, shuffle=False, sampler=balanced, drop_last=True
)
for batch_idx, samples in enumerate(data):
d, t = samples
for batch_idx, samples in enumerate(data):
d, t = samples
print(t)
def run(args):
if not os.path.exists(args.logdir):
os.makedirs(args.logdir)
logger = get_logger(os.path.join(args.logdir, 'main.log'))
logger.info(args)
# data
source_transform = transforms.Compose([
# transforms.Grayscale(),
transforms.ToTensor()
])
target_transform = transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Lambda(lambda x: x.repeat(3, 1, 1))
])
source_dataset_train = SVHN('./input',
'train',
transform=source_transform,
download=True)
target_dataset_train = MNIST('./input',
'train',
transform=target_transform,
download=True)
target_dataset_test = MNIST('./input',
'test',
transform=target_transform,
download=True)
source_train_loader = DataLoader(source_dataset_train,
args.batch_size,
shuffle=True,
drop_last=True,
num_workers=args.n_workers)
target_train_loader = DataLoader(target_dataset_train,
args.batch_size,
shuffle=True,
drop_last=True,
num_workers=args.n_workers)
target_test_loader = DataLoader(target_dataset_test,
args.batch_size,
shuffle=False,
num_workers=args.n_workers)
# train source CNN
source_cnn = CNN(in_channels=args.in_channels).to(args.device)
if os.path.isfile(args.trained):
c = torch.load(args.trained)
source_cnn.load_state_dict(c['model'])
logger.info('Loaded `{}`'.format(args.trained))
# train target CNN
target_cnn = CNN(in_channels=args.in_channels, target=True).to(args.device)
target_cnn.load_state_dict(source_cnn.state_dict())
discriminator = Discriminator(args=args).to(args.device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(target_cnn.encoder.parameters(),
lr=args.lr,
betas=args.betas,
weight_decay=args.weight_decay)
d_optimizer = optim.Adam(discriminator.parameters(),
lr=args.lr,
betas=args.betas,
weight_decay=args.weight_decay)
train_target_cnn(source_cnn,
target_cnn,
discriminator,
criterion,
optimizer,
d_optimizer,
source_train_loader,
target_train_loader,
target_test_loader,
args=args)
def load_data(opt):
""" Load Data
Args:
opt ([type]): Argument Parser
Raises:
IOError: Cannot Load Dataset
Returns:
[type]: dataloader
"""
##
# LOAD DATA SET
if opt.dataroot == '':
opt.dataroot = './data/{}'.format(opt.dataset)
## CIFAR
if opt.dataset in ['cifar10']:
transform = transforms.Compose([
transforms.Resize(opt.isize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_ds = CIFAR10(root='./data',
train=True,
download=True,
transform=transform)
valid_ds = CIFAR10(root='./data',
train=False,
download=True,
transform=transform)
train_ds, valid_ds = get_cifar_anomaly_dataset(
train_ds, valid_ds, train_ds.class_to_idx[opt.abnormal_class])
## MNIST
elif opt.dataset in ['mnist']:
transform = transforms.Compose([
transforms.Resize(opt.isize),
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])
train_ds = MNIST(root='./data',
train=True,
download=True,
transform=transform)
valid_ds = MNIST(root='./data',
train=False,
download=True,
transform=transform)
train_ds, valid_ds = get_mnist_anomaly_dataset(train_ds, valid_ds,
int(opt.abnormal_class))
# FOLDER
else:
transform = transforms.Compose([
transforms.Resize(opt.isize),
transforms.CenterCrop(opt.isize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
])
train_ds = ImageFolder(os.path.join(opt.dataroot, 'train'), transform)
valid_ds = ImageFolder(os.path.join(opt.dataroot, 'test'), transform)
## DATALOADER
train_dl = DataLoader(dataset=train_ds,
batch_size=opt.batchsize,
shuffle=True,
drop_last=True)
valid_dl = DataLoader(dataset=valid_ds,
batch_size=opt.batchsize,
shuffle=False,
drop_last=False)
return Data(train_dl, valid_dl)
