def dump_single_feature(img_path, extractor):
paths = [
img_path,
os.path.join(DATASET_BASE, img_path),
os.path.join(DATASET_BASE, 'in_shop', img_path)
]
print(img_path, paths)
for i in paths:
print(i)
if not os.path.isfile(i):
print("Continue")
continue
single_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="single", img_path=i, transform=data_transform_test),
batch_size=1,
num_workers=NUM_WORKERS,
pin_memory=True)
print("SL done", list(single_loader))
data = list(single_loader)[0]
print("Data is ", data)
data = Variable(data).cuda(GPU_ID)
print("GPU ID done")
deep_feat, color_feat = extractor(data)
deep_feat = deep_feat[0].squeeze()
print("Deep feat done")
color_feat = color_feat[0]
print("Returned something")
return deep_feat, color_feat
return None
def dump():
all_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="all", transform=data_transform_test),
batch_size=cfg.EXTRACT_BATCH_SIZE,
num_workers=cfg.NUM_WORKERS,
pin_memory=True)
deep_feats = []
color_feats = []
labels = []
dump_dataset(all_loader, deep_feats, color_feats, labels)
if cfg.ENABLE_INSHOP_DATASET:
inshop_loader = torch.utils.data.DataLoader(
Fashion_inshop(type="all", transform=data_transform_test),
batch_size=cfg.EXTRACT_BATCH_SIZE,
num_workers=cfg.NUM_WORKERS,
pin_memory=True)
dump_dataset(inshop_loader, deep_feats, color_feats, labels)
feat_all = os.path.join(cfg.DATASET_BASE, 'all_feat.npy')
color_feat_all = os.path.join(cfg.DATASET_BASE, 'all_color_feat.npy')
feat_list = os.path.join(cfg.DATASET_BASE, 'all_feat.list')
with open(feat_list, "w") as fw:
fw.write("\n".join(labels))
np.save(feat_all, np.vstack(deep_feats))
np.save(color_feat_all, np.vstack(color_feats))
print("Dumped to all_feat.npy, all_color_feat.npy and all_feat.list.")
def dump_single_feature(img_path, extractor, custom=False, with_clsf=False):
paths = [
img_path,
os.path.join(DATASET_BASE, img_path),
os.path.join(DATASET_BASE, 'in_shop', img_path)
]
# print(f'paths: {paths}')
for i in paths:
if not os.path.isfile(i):
continue
# print(f'img_path: {i}')
# print(f'Custom: {custom}')
if custom:
single_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="single",
img_path=i,
crop=True,
transform=data_transform_test,
custom=True),
batch_size=1,
num_workers=NUM_WORKERS,
pin_memory=True)
else:
single_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="single",
img_path=i,
transform=data_transform_test),
batch_size=1,
num_workers=NUM_WORKERS,
pin_memory=True)
data = list(single_loader)[0] # Get loaded image as tensor
data = Variable(data).cuda(GPU_ID)
if not with_clsf:
deep_feat, color_feat = extractor(data)
deep_feat = deep_feat[0].squeeze()
color_feat = color_feat[0]
return deep_feat, color_feat
else:
cls, deep_feat, color_feat = extractor(data)
class_n = cls.argmax() + 1
deep_feat = deep_feat[0].squeeze()
color_feat = color_feat[0]
return class_n, deep_feat, color_feat
return None
def dump_single_feature(img_path, extractor):
paths = [img_path, os.path.join(DATASET_BASE, img_path), os.path.join(DATASET_BASE, 'in_shop', img_path)]
for i in paths:
if not os.path.isfile(i):
continue
single_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="single", img_path=i, transform=data_transform_test),
batch_size=1, num_workers=NUM_WORKERS, pin_memory=True
)
data = list(single_loader)[0]
data = Variable(data).cuda(GPU_ID)
deep_feat, color_feat = extractor(data)
deep_feat = deep_feat[0].squeeze()
color_feat = color_feat[0]
return deep_feat, color_feat
return None
def _get_base_dataloader(sample=False):
if sample:
_type = "sample"
else:
_type = "test"
return torch.utils.data.DataLoader(
Fashion_attr_prediction(
categories=CATEGORIES,
type=_type,
transform=TEST_TRANSFORM_FN,
crop=True,
),
batch_size=128,
num_workers=NUM_WORKERS,
shuffle=True,
)
transforms.RandomSizedCrop(CROP_SIZE),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data_transform_test = transforms.Compose([
transforms.Scale(CROP_SIZE),
transforms.CenterCrop(CROP_SIZE),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
train_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="train", transform=data_transform_train),
batch_size=TRAIN_BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=True
)
test_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="test", transform=data_transform_test),
batch_size=TEST_BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=True
)
triplet_loader = torch.utils.data.DataLoader(
Fashion_attr_prediction(type="triplet", transform=data_transform_train),
batch_size=TRIPLET_BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=True
)
model = f_model(freeze_param=FREEZE_PARAM, model_path=DUMPED_MODEL).cuda(GPU_ID)
data_transform_train = transforms.Compose([
transforms.Scale(IMG_SIZE),
transforms.RandomSizedCrop(CROP_SIZE),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
data_transform_test = transforms.Compose([
transforms.Scale(CROP_SIZE),
transforms.CenterCrop(CROP_SIZE),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
train_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="train", transform=data_transform_train),
batch_size=TRAIN_BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory=True,
drop_last=True)
print(f"len(train_loader): {len(train_loader)}")
test_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="test", transform=data_transform_test),
batch_size=TEST_BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory=True)
triplet_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="triplet", transform=data_transform_train),
batch_size=TRIPLET_BATCH_SIZE,
def dump(custom=False):
print(f'dump function called with custom: {custom}')
if not custom:
all_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="all", transform=data_transform_test),
batch_size=EXTRACT_BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory=True)
classes = []
deep_feats = []
color_feats = []
labels = []
# dump_dataset(all_loader, deep_feats, color_feats, labels)
dump_dataset(all_loader, classes, deep_feats, color_feats, labels)
if ENABLE_INSHOP_DATASET:
inshop_loader = torch.utils.data.DataLoader(
Fashion_inshop(type="all", transform=data_transform_test),
batch_size=EXTRACT_BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory=True)
dump_dataset(inshop_loader, classes, deep_feats, color_feats,
labels)
feat_all = os.path.join(DATASET_BASE, 'all_feat.npy')
color_feat_all = os.path.join(DATASET_BASE, 'all_color_feat.npy')
feat_list = os.path.join(DATASET_BASE, 'all_feat.list')
with open(feat_list, "w") as fw:
fw.write("\n".join(labels))
np.save(feat_all, np.vstack(deep_feats))
np.save(color_feat_all, np.vstack(color_feats))
print("Dumped to all_feat.npy, all_color_feat.npy and all_feat.list.")
else:
all_loader = torch.utils.data.DataLoader(Fashion_attr_prediction(
type="all", transform=data_transform_test, custom=True, crop=True),
batch_size=EXTRACT_BATCH_SIZE,
num_workers=NUM_WORKERS,
pin_memory=True)
classes = []
deep_feats = []
color_feats = []
labels = []
# Classes with items in the dataset
allowed_inds = np.array(
[4, 9, 10, 15, 16, 17, 18, 21, 25, 28, 31, 33, 37])
dump_dataset(all_loader, classes, deep_feats, color_feats, labels,
allowed_inds)
class_all = os.path.join(DATASET_BASE, 'custom_all_class.npy')
feat_all = os.path.join(DATASET_BASE, 'custom_all_feat.npy')
color_feat_all = os.path.join(DATASET_BASE,
'custom_all_color_feat.npy')
feat_list = os.path.join(DATASET_BASE, 'custom_all_feat.list')
with open(feat_list, "w") as fw:
fw.write("\n".join(labels))
np.save(class_all, np.vstack(classes))
np.save(feat_all, np.vstack(deep_feats))
np.save(color_feat_all, np.vstack(color_feats))
print(
"Dumped to custom_all_class.npy, custom_all_feat.npy, custom_all_color_feat.npy and custom_all_feat.list."
)
def train(b1, b2):
# Use binary cross-entropy loss
adversarial_loss = torch.nn.BCELoss()
pixelwise_loss = torch.nn.L1Loss()
device = torch.device("cuda" if cuda else "cpu")
# Initialize generator and discriminator
encoder = Encoder().to(device)
decoder = Decoder().to(device)
discriminator = Discriminator().to(device)
if cuda:
encoder.cuda()
decoder.cuda()
discriminator.cuda()
adversarial_loss.cuda()
pixelwise_loss.cuda()
# Configure data loader
# os.makedirs("../../data/deepfashion", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
Fashion_attr_prediction(
categories=CATEGORIES,
type="train",
transform=TRANSFORM_FN,
crop=True
),
batch_size=TRAIN_BATCH_SIZE,
num_workers=NUM_WORKERS,
shuffle=True,
)
#for testing input images
#dataiter = iter(dataloader)
#images, labels = dataiter.next()
#save_image(images, "test.png", normalize=True)
#img = torchvision.utils.make_grid(images, normalize=True)
#npimg = img.numpy()
#plt.imshow(np.transpose(npimg, (1, 2, 0)))
#plt.show()
#return
# Optimizers
optimizer_G = torch.optim.Adam(
itertools.chain(encoder.parameters(), decoder.parameters()), lr=LR, betas=(b1, b2)
)
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=LR, betas=(b1, b2))
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
# generate fixed noise vector
n_row = 10
fixed_noise = Variable(Tensor(np.random.normal(0, 1, (n_row ** 2, LATENT_DIM))))
# make directory for saving images
path = "/".join([str(c) for c in [GENERATED_BASE, "aae", CONFIG_AS_STR, "train"]])
os.makedirs(path, exist_ok=True)
# save losses across all
G_losses = []
D_losses = []
# training loop
for epoch in range(N_EPOCHS):
for i, (imgs, paths) in enumerate(dataloader):
# Configure input
real_imgs = Variable(imgs.type(Tensor))
# Adversarial ground truths
valid = Variable(Tensor(imgs.shape[0], 1).fill_(1.0), requires_grad=False)
fake = Variable(Tensor(imgs.shape[0], 1).fill_(0.0), requires_grad=False)
# ---------------------
# Train Discriminator
# ---------------------
optimizer_D.zero_grad()
# Sample noise as discriminator ground truth
z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], LATENT_DIM))))
encoded_imgs = encoder(real_imgs)
# Measure discriminator's ability to classify real from generated samples
real_loss = adversarial_loss(discriminator(z), valid)
fake_loss = adversarial_loss(discriminator(encoded_imgs.detach()), fake)
d_loss = 0.5 * (real_loss + fake_loss)
d_loss.backward()
optimizer_D.step()
if i % N_CRITIC == 0:
# -----------------
# Train Generator
# -----------------
optimizer_G.zero_grad()
encoded_imgs = encoder(real_imgs)
decoded_imgs = decoder(encoded_imgs)
# Loss measures generator's ability to fool the discriminator
g_loss = 0.001 * adversarial_loss(discriminator(encoded_imgs), valid) + 0.999 * pixelwise_loss(
decoded_imgs, real_imgs
)
g_loss.backward()
optimizer_G.step()
batches_done = epoch * len(dataloader) + i
if batches_done % 50 == 0:
print(
"[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]"
% (epoch, N_EPOCHS, i, len(dataloader), d_loss.item(), g_loss.item())
)
if batches_done % SAMPLE_INTERVAL == 0:
name = gen_name(today, batches_done)
if FIXED_NOISE:
sample_image(decoder=decoder, n_row=n_row, path=path, name=name, fixed_noise=fixed_noise)
else:
sample_image(decoder=decoder, n_row=n_row, path=path, name=name)
# save losses
G_losses.append(g_loss.item())
D_losses.append(d_loss.item())
#save_model(encoder, epoch, "encoder")
#save_model(decoder, epoch, "decoder")
#save_model(discriminator, epoch, "discriminator")
plot_losses("aae", G_losses, D_losses, CONFIG_AS_STR, today)
return encoder, decoder, discriminator
def train(b1, b2):
# Use binary cross-entropy loss
adversarial_loss = torch.nn.BCELoss()
pixelwise_loss = torch.nn.L1Loss()
device = torch.device("cuda" if cuda else "cpu")
# Initialize generator and discriminator
encoder = Encoder().to(device)
decoder = Decoder().to(device)
discriminator = Discriminator().to(device)
if cuda:
encoder.cuda()
decoder.cuda()
discriminator.cuda()
adversarial_loss.cuda()
pixelwise_loss.cuda()
# Configure data loader
# os.makedirs("../../data/deepfashion", exist_ok=True)
dataloader = torch.utils.data.DataLoader(
Fashion_attr_prediction(categories=CATEGORIES,
type="train",
transform=TRANSFORM_FN,
crop=True),
batch_size=TRAIN_BATCH_SIZE,
num_workers=NUM_WORKERS,
shuffle=True,
)
print("dont loading data")
# Optimizers
optimizer_G = torch.optim.Adam(itertools.chain(encoder.parameters(),
decoder.parameters()),
lr=LR,
betas=(b1, b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(),
lr=LR,
betas=(b1, b2))
Tensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
# generate fixed noise vector
n_row = 10
#fixed_noise = Variable(Tensor(np.random.normal(0, 1, (n_row ** 2, LATENT_DIM))))
#noise_vector = np.zeros((n_row**2, LATENT_DIM))
#noise_vector[:50,:] = class_noise(CATEGORIES[0], LATENT_DIM, 50)
#noise_vector[50:,:] = class_noise(CATEGORIES[1], LATENT_DIM, 50)
fixed_noise = Variable(Tensor(sample_noise(n_row**2)))
# make directory for saving images
path = "/".join(
[str(c) for c in [GENERATED_BASE, "caae", CONFIG_AS_STR, "train"]])
os.makedirs(path, exist_ok=True)
# save losses across all
G_losses = []
D_losses = []
#one_hot_label = one_hot_encode(range(int(TRAIN_BATCH_SIZE/2)), range(int(TRAIN_BATCH_SIZE/2), TRAIN_BATCH_SIZE))
one_hot_label = make_one_hot_real(TRAIN_BATCH_SIZE)
print("done getting hot labels")
# training loop
for epoch in range(N_EPOCHS):
for i, (imgs, labels) in enumerate(dataloader):
# Configure input
real_imgs = Variable(imgs.type(Tensor))
# Adversarial ground truths
valid = Variable(Tensor(imgs.shape[0], 1).fill_(1.0),
requires_grad=False)
fake = Variable(Tensor(imgs.shape[0], 1).fill_(0.0),
requires_grad=False)
# ---------------------
# Train Discriminator
# ---------------------
optimizer_D.zero_grad()
# Sample noise as discriminator ground truth
#z = Variable(Tensor(np.random.normal(0, 1, (imgs.shape[0], LATENT_DIM))))
z = Variable(Tensor(sample_noise(imgs.shape[0])))
if imgs.shape[0] == TRAIN_BATCH_SIZE:
real_labels = Variable(Tensor(one_hot_label))
else:
real_labels = Variable(Tensor(make_one_hot_real(
imgs.shape[0])))
#print("made one hot labels again")
encoded_imgs = encoder(real_imgs)
indices = []
for j in range(N_CLASSES):
indices.append(np.where(labels == CATEGORIES[j])[0])
fake_labels = Variable(
Tensor(one_hot_encode(indices, imgs.shape[0])))
#print("made fake labels")
# Measure discriminator's ability to classify real from generated samples
real_loss = adversarial_loss(discriminator(z, real_labels), valid)
fake_loss = adversarial_loss(
discriminator(encoded_imgs.detach(), fake_labels), fake)
d_loss = 0.5 * (real_loss + fake_loss)
d_loss.backward()
optimizer_D.step()
if i % N_CRITIC == 0:
# -----------------
# Train Generator
# -----------------
optimizer_G.zero_grad()
encoded_imgs = encoder(real_imgs)
decoded_imgs = decoder(encoded_imgs)
# Loss measures generator's ability to fool the discriminator
g_loss = 0.5 * adversarial_loss(
discriminator(encoded_imgs, fake_labels),
valid) + 0.5 * pixelwise_loss(decoded_imgs, real_imgs)
g_loss.backward()
optimizer_G.step()
batches_done = epoch * len(dataloader) + i
if batches_done % 50 == 0:
print("[Epoch %d/%d] [Batch %d/%d] [D loss: %f] [G loss: %f]" %
(epoch, N_EPOCHS, i, len(dataloader), d_loss.item(),
g_loss.item()))
if batches_done % SAMPLE_INTERVAL == 0:
name = gen_name(today, batches_done)
if FIXED_NOISE:
sample_image(decoder=decoder,
n_row=n_row,
path=path,
name=name,
fixed_noise=fixed_noise)
else:
sample_image(decoder=decoder,
n_row=n_row,
path=path,
name=name)
# save losses
G_losses.append(g_loss.item())
D_losses.append(d_loss.item())
if epoch % 10 == 0:
config_mid = gen_name(CATEGORIES_AS_STR, LATENT_DIM, IMG_SIZE,
epoch, LR, TRAIN_BATCH_SIZE, N_CRITIC)
print("Saved Encoder to {}".format(
save_model(encoder, "caae_encoder", config_mid, today)))
print("Saved Decoder to {}".format(
save_model(decoder, "caae_decoder", config_mid, today)))
print("Saved Discriminator to {}".format(
save_model(discriminator, "caae_discriminator", config_mid,
today)))
plot_losses("caae", G_losses, D_losses, config_mid, today)
plot_losses("caae", G_losses, D_losses, CONFIG_AS_STR, today)
return encoder, decoder, discriminator
adversarial_loss = torch.nn.MSELoss()
# Initialize generator and discriminator
generator = Generator()
discriminator = Discriminator()
if cuda:
generator.cuda()
discriminator.cuda()
adversarial_loss.cuda()
# Configure data loader
dataloader = torch.utils.data.DataLoader(
Fashion_attr_prediction(
categories=CATEGORIES,
type="train",
transform=TRANSFORM_FN,
crop=True
),
batch_size=TRAIN_BATCH_SIZE,
num_workers=NUM_WORKERS,
shuffle=True,
)
# Optimizers
optimizer_G = torch.optim.Adam(generator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=opt.lr, betas=(opt.b1, opt.b2))
FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor
LongTensor = torch.cuda.LongTensor if cuda else torch.LongTensor
