def modelCombine(models, f, conf=basicConf, arg=None): bank = bankManage.Bank() curve = loss.Loss(conf.StartValue) sizes = [] for model, weit in models: sizes.extend(model.conf.getSizes()) phase = wave.Phase(sizes) tt = 0 vs = [] N = 5000 restBank = 0 #余量窗口 bw1 = 0.6 bw2 = 0.4 lastLen = 0 for line in f: vs.append(line) if len(vs) >= N: phase1 = copy.deepcopy(phase) curve1 = loss.Loss(curve.now) bank1 = copy.deepcopy(bank) tt1 = tt (phase, curve, bank, tt, restBank) = modelCombinePhase(models, vs[lastLen:], phase, curve, bank, tt, False, restBank, conf, arg) #models=selectModelCombine(models,vs,phase1,curve1,bank1,tt1,restBank,conf,arg,N) #print "model",models[0][1],models[1][1] #del vs[0:30000] vs = [] lastLen = len(vs) if len(vs) > 0: (phase, curve, bank, tt, restBank) = modelCombinePhase(models, vs[lastLen:], phase, curve, bank, tt, True, restBank, conf, arg) print curve
def main(): global model if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = [] if not args.test_only: ## only for optical flow if int(args.model_label) == 0: _loss.append( loss.Loss(args, checkpoint, ls=args.loss_flow, task='optical-flow')) # if args.loss_freg is not None: # _loss.append(loss.Loss(args, checkpoint, ls = args.loss_freg)) t = FlowTrainer(args, loader, _model, _loss, checkpoint) ## only for frame-recurrent elif int(args.model_label) == 1: _loss.append( loss.Loss(args, checkpoint, ls=args.loss_denoise, task='denoise')) t = FRTrainer(args, loader, _model, _loss, checkpoint) ## for frame-recurrent with optical-flow elif int(args.model_label) == 2: _loss.append( loss.Loss(args, checkpoint, ls=args.loss_denoise, task='denoise')) _loss.append( loss.Loss(args, checkpoint, ls=args.loss_flow, task='optical-flow')) t = Trainer(args, loader, _model, _loss, checkpoint) else: raise ValueError("args model_label can only equal to 0,1,2") else: _loss = None #exit(0) if not args.test_only: while not t.terminate(): t.train() t.test() else: if int(args.model_label) == 0: t = FlowTester(args, loader, _model, checkpoint) t.test() else: t = Tester(args, loader, _model, checkpoint) t.test() checkpoint.done()
def main(): # args.model = 'EDSR' # args.n_resblocks = 32 # args.n_feats = 256 # args.res_scale = 0.1 # args.save = 'EDSR_poster global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: #args.model_init='kcsres' #args.test_only = True #args.resume = -2 #args.batch_size = 16 #args.is_fcSim = False loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model global loss if args.data_test == 'video': from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) share_model = model.Model(args, checkpoint) controller_model = model.Controller_Model(share_model, args) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, share_model, loss, checkpoint) controller_t = Controller_Trainer(args, loader, controller_model, loss, checkpoint) cur_epoch = 0 while not t.terminate(): epoch_time = time.time() t.train() if cur_epoch >= args.controller_start_training: controller_t.controller_train() t.test() cur_epoch += 1 epoch_time = time.time() - epoch_time print( 'epochs time: {} h {} min '.format(int(epoch_time / 3600), epoch_time / 60), ' total time: {} h {} min'.format( int(epoch_time * args.epochs / 3600), epoch_time * args.epochs / 60 % 60)) checkpoint.done()
def build(self): # MODEL model_name = self.cfg.model_name if model_name not in dir(model): model_name = "PDANet" self.model = getattr(model, model_name)(cfg=self.cfg).to(self.device) self.model = nn.DataParallel(self.model) if self.cfg.net_verbose: summary(self.model, (4, 224, 224)) print('-' * 40) print(f"[*] Model: {self.cfg.model_name}") print(f"[*] Device: {self.device}") print(f"[*] Path: {self.cfg.data_dir}") # OPTIMIZER self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.cfg.lr_init) # LOSS self.criterion = loss.Loss(self.cfg, self.device) # SCHEDULER if self.cfg.scheduler == "step": self.lr_sch = lr_scheduler.StepLR(self.optimizer, **self.steplr) else: self.lr_sch = lr_scheduler.ReduceLROnPlateau( self.optimizer, **self.plateau) # INITIALIZE: dirs, ckpts, data loaders self._make_dir() self._load_ckpt() self._load_data() self.writer = SummaryWriter(log_dir=self.cfg.logs_path)
def predict(images="", root_path="", ai_directory_path="", model_type="EDSR"): """ :param images: image의 이름 (특화 프로젝트 때, 복수의 이미지 파일을 받아서 images로 명명됨) :param root_path: image가 저장된 디렉토리 :param AI_directory_path: 모델이 저장된 디렉토리 :param model_type: :return: 생성된 이미지 파일 경로+이름 (list) """ if model_type == "EDSR": png_alpha_channel_remove(images, root_path) set_setting_value_edsr(images, root_path, ai_directory_path, use_cpu=False) torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) result = t.test() # return value is saved image path(and image name). list type. checkpoint.done() # for file_name in result 형태의 for문 형태는 result의 str원소를 변경할 수 없다. for i in range(len(result)): result[i] = result[i][result[i].rfind("\\") + 1:] return result # `media` 디렉토리 내부에 존재하는 결과물 파일 이름을 반환
def main(): global model global loss if args.data_test == 'video': from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) share_model = model.Model(args, checkpoint) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, share_model, loss, checkpoint) while not t.terminate(): epoch_time = time.time() t.train() t.final_test() epoch_time = time.time() - epoch_time print( 'epochs time: {} h {} min '.format(int(epoch_time / 3600), epoch_time / 60), ' total time: {} h {} min'.format( int(epoch_time * args.epochs / 3600), epoch_time * args.epochs / 60 % 60)) checkpoint.done()
def t8(tag="超出值", Rate=0.0): import loss import random print tag curve = loss.Loss(1.0) conf = Conf() conf.HandSize = 1.0 for line in sys.stdin: p = line.find(tag) if p >= 0: p1 = line.rfind("\t") try: v = float(line[p1 + 1:-1]) except: continue #if random.random() < Rate: # continue if abs(v) < 1e-6: continue print v #if v > 0.3: # print "line:",line #v=0.01*v #if curve.now < 0: # continue curve.addTime() e = curve.now * v curve.addE(e) curve.addWin(v, conf) conf.YearFold = 1.0 print curve.confStr(conf)
def __init__(self, sess, summaries_dir, batch_size, input_z_size, emb_size, class_num, code_dim, img_size): self.sess = sess # Function net = nets.Nets(input_z_size, emb_size, class_num, code_dim, img_size) self.generator = net.generator self.discriminator = net.discriminator los = loss.Loss(batch_size) self.class_loss = los.class_loss self.class_loss2 = los.class_loss2 self.vae_loss = los.vae_loss self.percept_loss = los.percept_loss self.tv_loss = los.tv_loss self.opers = ops.Ops() self.batch_size = batch_size self.input_z_size = input_z_size self.class_num = class_num self.code_dim = code_dim self.img_size = img_size self.emb_size = emb_size self.gen_gan_weight = 1 self.gen_dis_weight = 1 self.dis_gan_weight = 1 self.dis_dis_weight = 1 self.summaries_dir = summaries_dir self.build_model()
def selectModelCombine(models, vs, phase, curve, bank, tt, restBank, conf, arg, N): if len(models) == 2: MR = N / (100000.0 + N) bw1 = models[0][1] bw2 = models[1][1] m2[-1][0] = bw1 m2[-1][1] = bw2 bmax = -1000000 #(curve.now-baseRate)/(curve.maxTrack+baseRate*0.1) for w1, w2, wphase in m2: models[0][1] = w1 models[1][1] = w2 phase1 = copy.deepcopy(phase) curve1 = loss.Loss(curve.now) bank1 = copy.deepcopy(bank) tt1 = tt restBank1 = restBank modelCombinePhase(models, vs, phase1, curve1, bank1, tt1, False, restBank1, conf, arg) wphase.add(curve1.now / curve1.start - 1.0) bnow = wphase.avg(WK) - wphase.dev(WK) print "w1", w1, "w2", w2, "avg", wphase.avg(WK), "dev", wphase.dev( WK ), "bnow", bnow, "bmax", bmax, "rate", curve1.now / curve1.start - 1.0, "track", curve1.maxTrack if bnow > bmax: print "w1", w1, "w2", w2, "bnow", bnow, "bmax", bmax bw1 = w1 bw2 = w2 bmax = bnow models[0][1] = bw1 * MR + m2[-1][0] * (1.0 - MR) models[1][1] = bw2 * MR + m2[-1][1] * (1.0 - MR) print "bw12", bw1, bw2 print "best models:", models[0][1], models[1][1] return models
def t4(): v = 1.0 curve = loss.Loss(1.0) for line in sys.stdin: curve.addTime(5500) curve.addE(float(line.strip()) * curve.now) print curve.now print curve
def set_up_experiment(params, experiment, resume=None): # Create experiment directory if resume: params["experiment_dir"] = os.path.split(resume)[ 0] # Use existing folder else: params["experiment_dir"] = utils.make_dir_with_date( params["experiment_dir"], "fastdepth") # New folder ## --------------- Model --------------- ## model, optimizer_state_dict = utils.load_model(params, resume) # Configure GPU params["gpus"] = params["device"] if isinstance(params["device"], int) and torch.cuda.is_available(): params["device"] = torch.device("cuda:{}".format(params["device"])) elif isinstance(params["device"], list) and torch.cuda.is_available(): model = nn.DataParallel(model, device_ids=params["device"]) params["device"] = torch.device("cuda:{}".format(params["device"][0])) else: params["device"] = "cpu" # Send model to GPU(s) # This must be done before optimizer is created # if a model state_dict is being loaded model.to(params["device"]) ## --------------- Loss --------------- ## criterion = loss.Loss(params["loss"]) ## --------------- Optimizer --------------- ## optimizer = optimize.get_optimizer(model, params) if optimizer_state_dict: optimizer.load_state_dict(optimizer_state_dict) # Load optimizer tensors onto GPU if necessary utils.optimizer_to_gpu(optimizer) ## --------------- LR Scheduler --------------- ## if resume: scheduler = optim.lr_scheduler.StepLR( optimizer, step_size=params["lr_epoch_step_size"], gamma=0.1, last_epoch=params["start_epoch"]) else: scheduler = optim.lr_scheduler.StepLR( optimizer, step_size=params["lr_epoch_step_size"], gamma=0.1) print_params(params) log_comet_parameters(experiment, params) ## --------------- Dataset --------------- ## train_loader, val_loader, test_loader = load_dataset(params) return params, train_loader, val_loader, test_loader, model, criterion, optimizer, scheduler
def main(): global model if checkpoint.ok: loader = data.Data(args) model = model.Model(args, checkpoint) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, model, loss, checkpoint) t.test() checkpoint.done()
def inference(*targs, **kwargs): dev = kwargs['device'] if dev == 'cpu': print("device = ",dev ) args.cpu = True net = model.Model(args, checkpoint) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, net, loss, checkpoint) psnr = t.test() print("psnr = ",psnr) elif dev == 'cuda': print("device = ",dev ) args.cpu = False net = model.Model(args, checkpoint) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, net, loss, checkpoint) psnr = t.test() print("psnr = ",psnr) return psnr
def main(): global model if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): timer_HvdInit = utility.timer() # initialize horovod.torch hvd.init() # cuda device flag args.cuda = args.hvd and torch.cuda.is_available() print("args.cuda: " + str(args.cuda)) print("args.hvd: " + str(args.hvd)) print("cuda available: " + str(torch.cuda.is_available())) # pinging local GPU to process if args.cuda: torch.cuda.set_device(hvd.local_rank()) print("hvd local rank:" + str(hvd.local_rank())) torch.cuda.manual_seed(args.seed) print("Horovod init time elapsed: " + str(timer_HvdInit.toc())) cudnn.benchmark = True global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: # added support for distributed training dataset loading # param added: hvd loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None # wrapping optimizer with horovod distributed support # param added: hvd t = Trainer(args, loader, _model, _loss, checkpoint) timer_HvdBcast1 = utility.timer() hvd.broadcast_parameters(_model.state_dict(), root_rank=0) print("Hvd Bcast params time elapsed: " + str(timer_HvdBcast1.toc())) timer_HvdBcast2 = utility.timer() hvd.broadcast_optimizer_state(t.optimizer, root_rank=0) print("Hvd Bcast optimizer state time elapsed: " + str(timer_HvdBcast2.toc())) # Broadcast the initial variable states from rank 0 to all other processes while not t.terminate(): timer_TrainLoop = utility.timer() t.train() print("Single loop time elapsed: " + str(timer_TrainLoop.toc())) checkpoint.done()
def create_model(opt): if opt.model == 'LRCN': model = models.LRCNModel(opt) # elif opt.model == 'Simple': # model = models.SimpleModel(opt) elif opt.model == 'ConvLSTM': model = models.ConvLSTM(opt) else: raise ValueError('Unrecognized opt.mode={}'.format(opt.model)) criterion = loss.Loss(opt) if opt.gpu_ids: model.cuda() torch.backends.cudnn.benchmark = True return model, criterion
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) # print(len(loader.loader_train)) # for d in loader.loader_train: # print(d[0].shape) # print(d[1].shape) # print(d[2]) # print(d[3]) # # break; #exit(0) _model = model.Model(args, checkpoint) if args.model == "SSL": if not args.test_only: _loss = [loss.Loss(args, checkpoint), loss.Loss(args, checkpoint, ls=args.loss_ssl)] ## Relative Loss if args.loss_rel is not None: _loss.append(loss.Loss(args, checkpoint, ls=args.loss_rel)) else: _loss = None t = SSL_Trainer(args, loader, _model, _loss, checkpoint) else: _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model global loss if args.data_test == 'video': from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) share_model = model.Model(args, checkpoint) loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, share_model, loss, checkpoint) t.derive() checkpoint.done()
def main(checkpoint): if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) if args.feature_map: t.get_feature_maps() return while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: # Load Data --> Go to data.Data # Class Data defined in /src/loader --> how do we know it is calling that? # It calls using import data --> data is a package now due to __init__.py # Any .py file can be imported # Why is Data class defined in .py file? # Defining a lot of attributes of loader class, including where to load test images # But we have not actually loaded data --> only in t.test() loader = data.Data(args) # model defined in src/model/__init__.py # important uses from args: precision, scale, cpu, m_GPUs, # define method that creates forward model # Don't need detail for now _model = model.Model(args, checkpoint) # model defined in src/loss/__init__.py # define loss function - default set to L1 at args (option.py) # _loss = loss.Loss(args, checkpoint) if not args.test_only else None # import class directly from trainer.py defined in src (same directory) # checkpoint - defined as cpk inside # Creating test, and train class on t -- but have not called the t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): device = torch.device('cpu' if args.cpu else f'cuda:{args.gpu_id}') if checkpoint.ok: loader = data.Data(args) t_model = SplitSR(args, is_teacher=True).to(device) args.is_student = True s_model = model.Model(args, checkpoint) # raise ValueError('not expected model = {}'.format(args.model)) if args.teach_pretrain is not None: t_checkpoint = torch.load(args.teach_pretrain) t_model.load_state_dict(t_checkpoint) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, t_model, s_model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model torch.cuda.device_count() torch.cuda.get_device_name(0) if args.data_test == 'video': from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) model = model.Model(args, checkpoint) loss = l.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, model, loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) print(' Total params: %.2fM' % (sum(p.numel() for p in _model.parameters()) / 1000000.0)) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): # Test dataset args.model = 'fccnn1mw' args.data_test = 'Set5' args.data_test = args.data_test.split('+') args.resume = -1 args.n_resblocks = 3 args.test_only = True args.save_results = True args.save_gt = True args.save = args.model + '_b' + str(args.n_resblocks) + 'f' + str(args.n_feats) + \ 's' + str(args.batch_size) +'sig' + str(args.sigma) # Load model args.pretrain = '../experiment/' + args.save + '/model/model_best.pt' _model = model.Model(args, checkpoint) loader = data.Data(args) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) t.test()
def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) number_parameters = sum( map(lambda x: x.numel(), _model.parameters())) print(number_parameters) _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(): global model string = 'dir_data' print(getattr(args, string)) if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) model_t = model.Model(args, checkpoint) model_s = model.Model(args, checkpoint, student=True) model = [model_t, model_s] loss_ = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, model, loss_, checkpoint) while not t.terminate(): t.train() t.test() checkpoint.done()
def main(args): ckpt_ = checkpoint.Checkpoint(args) # data loader dataloader_ = data.Data(args) # model build up model_ = model.Model(args, ckpt_) # loss setting loss_ = loss.Loss(args, ckpt_) # check module for visualization and gradient check check_ = check.check(model_) # class for training and testing trainer_ = trainer.Trainer(args, model_, loss_, dataloader_, ckpt_, check_) if args.test: trainer_.test() return # train # train with freeze first if args.freeze > 0: print('freeze base_params for {} epochs'.format(args.freeze)) for par in ckpt_.base_params: par.requires_grad = False if hasattr(model_.get_model(), 'base_params'): for par in model_.get_model().base_params: par.requires_grad = False optim_tmp = optimizer.make_optimizer(args, model_) for i in range(args.freeze): trainer_.train(optim_tmp) # start training for par in model_.parameters(): par.requires_grad = True for i in range(trainer_.epoch, args.epochs): trainer_.train(trainer_.optimizer) if args.test_every != 0 and (i + 1) % args.test_every == 0: trainer_.test()