# SSD的损失函数 criterion = ssd_loss.MultiBoxLoss(CONFIG, CONFIG['num_classes'], 0.5, True, 0, True, 3, 0.5, False, CONFIG["USE_GPU"]) train_loader = t.utils.data.DataLoader(dataset, CONFIG["BATCH_SIZE"], shuffle=True, collate_fn=ssd_utils.detection_collate) if FROM_TRAIN_ITER > 1: net.load_state_dict(t.load("outputs/SSD_%03d.pth" % (FROM_TRAIN_ITER - 1))) index = 0 step_index = 0 # predict = j_m_ssd.SSDPredict(CONFIG["CLASSES"]) bar = j_bar.ProgressBar(CONFIG["EPOCH"], len(train_loader), "Loss : %.3f; Total Loss : %.3f") predict = ssd_predict.SSDPredict(CONFIG["CLASSES"]) net.train() log = logger.Logger(CONFIG["LOG_DIR"]) for epoch in range(FROM_TRAIN_ITER, CONFIG["EPOCH"] + 1): total_loss = 0. t.cuda.empty_cache() for i, (images, targets) in enumerate(train_loader): index += i if epoch >= 30: LEARNING_RATE = 0.0005 if epoch >= 50: LEARNING_RATE = 0.00025 if epoch >= 80: LEARNING_RATE = 0.00001
break else: break for param_group in optimizer.param_groups: param_group['lr'] = lr / batch_size return lr processed_batches = 0 if FROM_TRAIN_ITER > 1: model.load_state_dict( torch.load("outputs/YOLOV3_%03d.pth" % (FROM_TRAIN_ITER - 1))) log = logger.Logger("logs/") predict = yolo_predict.YoloV3Predict(CONFIG["CLASSES"]) LEARNING_RATE = learning_rate bar = j_bar.ProgressBar(max_epochs, len(train_loader), "Loss:%.3f;Total Loss:%.3f") for epoch in range(FROM_TRAIN_ITER, max_epochs + 1): model.train() total_loss = 0 torch.cuda.empty_cache() # if epoch >= 1: # LEARNING_RATE = 0.01 # if epoch >= 30: # LEARNING_RATE = 0.005 # if epoch >= 60: # LEARNING_RATE = 0.001 # if epoch >= 90: # LEARNING_RATE = 0.0005 # if epoch >= 120: # LEARNING_RATE = 0.00025 # for param_group in optimizer.param_groups:
NetG = NetG.cuda() NetD = NetD.cuda() x = x.cuda() z = z.cuda() z_test = z_test.cuda() one, one_neg = one.cuda(), one_neg.cuda() x = t.autograd.Variable(x) z = t.autograd.Variable(z) z_test = t.autograd.Variable(z_test) optimizerD = t.optim.RMSprop(NetD.parameters(), lr=CONFIG["LEARNING_RATE"]) optimizerG = t.optim.RMSprop(NetG.parameters(), lr=CONFIG["LEARNING_RATE"]) gen_iterations = 0 bar = j_bar.ProgressBar(CONFIG["EPOCH"], len(dataset), "D Loss:%.3f;G Loss:%.3f") for epoch in range(1, CONFIG["EPOCH"] + 1): i = 0 data_iter = iter(dataset) while i < len(dataset): for p in NetD.parameters(): p.requires_grad = True if gen_iterations < 25 or gen_iterations % 500 == 0: N_critic = 100 else: N_critic = 5 t1 = 0
dataset = j_data.MNISTDataSetForPytorch( radio=0.9, transform=torchvision.transforms.ToTensor()) train_loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=CONFIG["BATCH_SIZE"], shuffle=True) conv1 = cnn_layer.Conv2D([CONFIG["BATCH_SIZE"], 28, 28, 1], 12, 5, 1) relu1 = cnn_layer.Relu(conv1.output_shape) pool1 = cnn_layer.MaxPooling(relu1.output_shape) conv2 = cnn_layer.Conv2D(pool1.output_shape, 24, 3, 1) relu2 = cnn_layer.Relu(conv2.output_shape) pool2 = cnn_layer.MaxPooling(relu2.output_shape) fc = cnn_layer.FullyConnect(pool2.output_shape, 10) sf = cnn_layer.Softmax(fc.output_shape) bar = j_bar.ProgressBar(CONFIG["EPOCHS"], len(train_loader), "train:%.3f,%.3f") for epoch in range(1, CONFIG["EPOCHS"] + 1): batch_loss = 0 batch_acc = 0 val_acc = 0 val_loss = 0 # train train_acc = 0 train_loss = 0 for i, (train_image, train_label) in enumerate(train_loader): img = train_image.data.numpy().transpose((0, 2, 3, 1)) label = train_label.data.numpy().squeeze() conv1_out = relu1.forward(conv1.forward(img))
shuffle=True, transform=tv.transforms.Compose( [tv.transforms.ToTensor(), lambda x: 2 * (x - 0.5)]), train=True, seen=cur_model.seen, batch_size=BATCH_SIZE), batch_size=BATCH_SIZE, shuffle=False) predict = yolo_predict.YoloV2Predict(CONFIG["CLASSES"]) if FROM_TRAIN_ITER > 1: model.load_state_dict( t.load("outputs/YOLOV2_%03d.pth" % (FROM_TRAIN_ITER - 1))) LEARNING_RATE = learning_rate / BATCH_SIZE bar = j_bar.ProgressBar(CONFIG["EPOCHS"], len(train_loader), "Loss:%.3f;Avg Loss:%.3f") log = logger.Logger(CONFIG["LOG_DIR"]) for epoch in range(FROM_TRAIN_ITER, CONFIG["EPOCHS"] + 1): t.cuda.empty_cache() lr = adjust_learning_rate(optimizer, processed_batches) model.train() total_loss = 0 if epoch >= 30: LEARNING_RATE = 0.001 / BATCH_SIZE if epoch >= 60: LEARNING_RATE = 0.0008 / BATCH_SIZE if epoch >= 90: LEARNING_RATE = 0.001 / BATCH_SIZE if epoch >= 120: LEARNING_RATE = 0.00007 / BATCH_SIZE
########### LOSS & OPTIMIZER ########## optimizerD = t_optim.Adam(Net_D.parameters(),lr=0.0001, betas=(0.5, 0.999)) optimizerG = t_optim.Adam(Net_G.parameters(),lr=0.0001, betas=(0.5, 0.999)) dataset = j_data.Cifar10DataSetForPytorch(train=True, transform=tv.transforms.Compose( [ tv.transforms.ToTensor(), # Normalize((0.5,0.5,0.5), (0.5,0.5,0.5)) ])) train_loader = t.utils.data.DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True) noise = t.randn(100, NOISE_DIM) noise_var = t_auto.Variable(noise.cuda() if GPU_NUMS > 0 else noise) k = 0 proBar = j_bar.ProgressBar(EPOCHS, len(train_loader), "D Loss:%.3f;G Loss:%.3f") for epoch in range(1, EPOCHS + 1): for index, (images,_) in enumerate(train_loader): mini_batch = images.shape[0] noise = t_auto.Variable(t.FloatTensor(mini_batch, NOISE_DIM, 1, 1).cuda() if GPU_NUMS > 0 else t.FloatTensor(mini_batch, NOISE_DIM, 1, 1)) real = t_auto.Variable(t.FloatTensor(mini_batch, IMAGE_CHANNEL, IMAGE_SIZE, IMAGE_SIZE).cuda() if GPU_NUMS > 0 else t.FloatTensor(mini_batch, IMAGE_CHANNEL, IMAGE_SIZE, IMAGE_SIZE)) label = t_auto.Variable(t.FloatTensor(1).cuda() if GPU_NUMS > 0 else t.FloatTensor(1)) Net_D.zero_grad() real.data.resize_(images.size()).copy_(images) # generate fake data noise.data.resize_(images.size(0), NOISE_DIM) noise.data.uniform_(-1,1) fake = Net_G(noise)
state_dict = torch.load(FCNConfig["VGG16_MODEL_PATH"]) vgg.load_state_dict(state_dict) model.init_vgg16_params(vgg) else: model.load_state_dict( torch.load("outputs/FCN8s_%03d.pth" % (FROM_TRAIN_ITER - 1))) if FCNConfig["USE_GPU"]: model = model.cuda() LEARNING_RATE = FCNConfig["LEARNING_RATE"] optim = torch.optim.SGD(model.parameters(), lr=FCNConfig["LEARNING_RATE"], momentum=FCNConfig["MOMENTUM"], weight_decay=FCNConfig["WEIGHT_DECAY"]) bar = j_bar.ProgressBar(FCNConfig["EPOCH"], len(train_loader), "Loss : %.3f; Total Loss : %.3f") for epoch in (FROM_TRAIN_ITER, FCNConfig["EPOCHS"] + 1): model.train() total_loss = 0 for param_group in optim.param_groups: param_group['lr'] = LEARNING_RATE for batch_idx, (images, targets) in enumerate(train_loader): images = torch.autograd.Variable( images.cuda() if FCNConfig["USE_GPU"] else images) targets = torch.autograd.Variable( targets.cuda() if FCNConfig["USE_GPU"] else targets) optim.zero_grad()
D_optimizer = t_optim.Adam(Net_D.parameters(), lr=0.0002, betas=(0.5, 0.999)) train_set = j_data.DataSetFromFolderForPix2Pix( os.path.join("/input/facades_fixed", "train")) test_set = j_data.DataSetFromFolderForPix2Pix( os.path.join("/input/facades_fixed", "test")) train_data_loader = t.utils.data.DataLoader(dataset=train_set, batch_size=CONFIG["BATCH_SIZE"], shuffle=True) test_data_loader = t.utils.data.DataLoader(dataset=test_set, batch_size=CONFIG["BATCH_SIZE"], shuffle=True) test_input, test_target = test_data_loader.__iter__().__next__() bar = j_bar.ProgressBar(CONFIG["EPOCH"], len(train_data_loader), "D loss:%.3f;G loss:%.3f") for epoch in range(1, CONFIG["EPOCH"] + 1): for i, (input, target) in enumerate(train_data_loader): x_ = t_auto.Variable(input.cuda() if CONFIG["GPU_NUM"] > 0 else input) y_ = t_auto.Variable( target.cuda() if CONFIG["GPU_NUM"] > 0 else target) # Train discriminator with real data D_real_decision = Net_D(x_, y_).squeeze() real_ = t_auto.Variable( t.ones(D_real_decision.size()).cuda( ) if CONFIG["GPU_NUM"] > 0 else t.ones(D_real_decision.size())) D_real_loss = BCE_loss(D_real_decision, real_) # Train discriminator with fake data gen_image = Net_G(x_)
z = t.autograd.Variable(z) z_test = t.autograd.Variable(z_test) # Optimizer optimizerD = t.optim.Adam(NetD.parameters(), lr=CONFIG["LEARNING_RATE"], betas=(0, .9)) optimizerG = t.optim.Adam(NetG.parameters(), lr=CONFIG["LEARNING_RATE"], betas=(0, .9)) def generate_random_sample(): while True: random_indexes = numpy.random.choice(dataset.__len__(), size=CONFIG["BATCH_SIZE"], replace=False) batch = [dataset[i][0] for i in random_indexes] yield t.stack(batch, 0) random_sample = generate_random_sample() ## Fitting model bar = j_bar.ProgressBar(1, 5000, "D Loss%.3f;G Loss%.3f") for i in range(1, 5000 + 1): for p in NetD.parameters(): p.requires_grad = True for j in range(5): ######################## # (1) Update D network # ######################## NetD.zero_grad() # Sample real data real_images = random_sample.__next__() real_images = real_images.cuda() if CONFIG["GPU_NUMS"] > 0 else real_images
def train(self): self.model.train() self.optim.zero_grad() iteration = 0 for epoch in range(cfg.SOLVER.MAX_EPOCH): if epoch == cfg.TRAIN.REINFORCEMENT.START: self.rl_stage = True self.setup_loader(epoch) start = time.time() data_time = AverageMeter() batch_time = AverageMeter() losses = AverageMeter() if not self.distributed or self.args.local_rank == 0: pbar = ProgressBar(n_total=len(self.training_loader), desc='Training') val = self.eval(epoch) for step, (indices, input_seq, target_seq, gv_feat, att_feats, att_mask, image_ids, dataset_name) in enumerate(self.training_loader): data_time.update(time.time() - start) input_seq = input_seq.cuda() target_seq = target_seq.cuda() gv_feat = gv_feat.cuda() att_feats = att_feats.cuda() att_mask = att_mask.cuda() kwargs = self.make_kwargs(indices, input_seq, target_seq, gv_feat, att_feats, att_mask) loss, loss_info = self.forward(kwargs) loss.backward() utils.clip_gradient(self.optim.optimizer, self.model, cfg.SOLVER.GRAD_CLIP_TYPE, cfg.SOLVER.GRAD_CLIP) self.optim.step() self.optim.zero_grad() self.optim.scheduler_step('Iter') batch_time.update(time.time() - start) start = time.time() losses.update(loss.item()) self.summary(iteration, loss, image_ids, dataset_name) self.display(iteration, data_time, batch_time, losses, loss_info) iteration += 1 if self.distributed: dist.barrier() if not self.distributed or self.args.local_rank == 0: pbar(step) self.save_model(epoch) val = self.eval(epoch) self.optim.scheduler_step('Epoch', val) self.scheduled_sampling(epoch) if self.distributed: dist.barrier()