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