def _default_printprogress(self): # This just formats all of them nicely together and prints it. s_tr = _report_train(self.trcosts[-1], self.trnlls[-1], self.trts[-1]) s_va = _report_score( self.vanlls[-1], self.vaerrs[-1], self.vats[-1], self.last_yva_len) if self.vaepochs[-1] == self.e else None printnow(self.progressout, "{}\n", _report_epoch(self.e, s_tr, s_va, self.e == self.ebest))
def compute_precrecs(scans, pred_conf, pred_offs, gt_wcs, gt_was, ts=(1e-5, 1e-3, 0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99, 1 - 1e-3, 1 - 1e-5), rs=(0.1, 0.3, 0.5, 0.7, 0.9)): gt_all = [wcs + was for wcs, was in zip(gt_wcs, gt_was)] if isinstance(rs, (float, int)): rs = (rs, ) mkgt = lambda: np.full((len(ts), len(rs)), np.nan) precs, recs = mkgt(), mkgt() precs_wc, recs_wc = mkgt(), mkgt() precs_wa, recs_wa = mkgt(), mkgt() for i, t in enumerate(ts): alldets, (wcdets, wadets) = pred2det_comb(scans, pred_conf, pred_offs, thresh=t, out_rphi=False) for j, r in enumerate(rs): precs[i, j], recs[i, j] = u.precrec(alldets, gt_all, r, pred_rphi=False, gt_rphi=True) precs_wc[i, j], recs_wc[i, j] = u.precrec(wcdets, gt_wcs, r, pred_rphi=False, gt_rphi=True) precs_wa[i, j], recs_wa[i, j] = u.precrec(wadets, gt_was, r, pred_rphi=False, gt_rphi=True) lbu.printnow(".") return (precs, recs), (precs_wc, recs_wc), (precs_wa, recs_wa)
def fit(self, Xtr, ytr, Xva, yva, epochs, lr0, lr_decay=None, aug=None, min_nll_diff=1e-3, valid_freq=1, full_valid_freq=1, savename='/tmp/model', shuf=None): # This is quite a small hack for percents in the default post-epoch reporting. self.last_yva_len = len(yva) lr = lr0 tstart = time.clock() try: for e in range(epochs): # This arrangement is a bit weird. # We first validate (and potentially test), then train. # This is because `train` computes the nll+cost on the trainset # for free as a side-product of training. But it computes the # value of it before the weight update. do_valid = False if self.e % valid_freq == 0: do_valid = True fast = True if self.e % full_valid_freq == 0: do_valid = True fast = False if do_valid: t0 = time.clock() nll, err = self.valid_epoch(Xva, yva, aug=aug, fast=fast) t1 = time.clock() # Store for posteriority. self.vanlls.append(nll) self.vaerrs.append(err) self.vaepochs.append(self.e) self.vats.append(t1 - t0) # Save the model that performs best on the validation set. # Best is: "significantly" lower nll. if self.vanlls[-1] < self.bestvanll - min_nll_diff: self.ebest = self.e self.bestva = self.vaerrs[-1] self.bestvanll = self.vanlls[-1] save_model(self.optim.model, savename) t0 = time.clock() kw = dict(aug=aug, shuf=shuf) if lr is not None: kw['lrate'] = lr cost, nll = self.fit_epoch(Xtr, ytr, **kw) t1 = time.clock() # Store for posteriority. self.trnlls.append(nll) self.trcosts.append(cost) self.trepochs.append(self.e) self.trts.append(t1 - t0) # Call whatever is registered as post-epoch callback. self.postepoch(self) # And only now did we advance an epoch. # That is because the cost and nll computed by the training step # are those *before* updating the gradient. self.e += 1 if lr is not None and lr_decay is not None: lr *= lr_decay except KeyboardInterrupt: # Just stop the loop on keyboard interrupt. # But also reload the best model we had. printnow(self.progressout, "Interrupted.") if True: #input("Reload best model? [y/n]") == 'y': load_model(self.optim.model, savename) printnow(self.progressout, "Reloaded!") tend = time.clock() self.t += tend - tstart printnow( self.progressout, 'Best in validation@{ebest}e ({t:.1f}s in total, i.e. {spe:.1f}s/e)\n', ebest=self.ebest, t=tend - tstart, spe=(tend - tstart) / e)
args = parser.parse_args() print(args.criterion + " criterion will be used") if args.criterion == 'cosine': crit = BiternionCriterion() elif args.criterion == 'von-mises': crit = BiternionCriterion(kappa=1) else: print("ERROR: You specified wrong criterion. Sorry =(") sys.exit(1) for d in args.modeldir.split(':'): sys.path.append(d) netlib = import_module(args.net) printnow("Loading data from {}\n", args.datadir) Xtr, ytr, Xte, yte, nte = prepare_data(args.datadir, netlib) ytr = ytr.astype(df.floatX) yte = yte.astype(df.floatX) printnow("Got {:.2f}k training images after flipping\n", len(Xtr) / 1000.0) aug = netlib.mkaug(Xtr, ytr) net = netlib.mknet() printnow('Network has {:.3f}M params in {} layers\n', df.utils.count_params(net) / 1000.0 / 1000.0, len(net.modules)) print(net[:21].forward(aug.augbatch_train(Xtr[:100])[0]).shape) costs = dotrain(net, crit, aug, Xtr, ytr, nepochs=args.epochs) print("Costs: {}".format(' ; '.join(map(str, costs))))
def fit(self, Xtr, ytr, Xva, yva, epochs, lr0, lr_decay=None, aug=None, min_nll_diff=1e-3, valid_freq=1, full_valid_freq=1, savename='/tmp/model', shuf=None): # This is quite a small hack for percents in the default post-epoch reporting. self.last_yva_len = len(yva) lr = lr0 tstart = time.clock() try: for e in range(epochs): # This arrangement is a bit weird. # We first validate (and potentially test), then train. # This is because `train` computes the nll+cost on the trainset # for free as a side-product of training. But it computes the # value of it before the weight update. do_valid = False if self.e % valid_freq == 0: do_valid = True fast = True if self.e % full_valid_freq == 0: do_valid = True fast = False if do_valid: t0 = time.clock() nll, err = self.valid_epoch(Xva, yva, aug=aug, fast=fast) t1 = time.clock() # Store for posteriority. self.vanlls.append(nll) self.vaerrs.append(err) self.vaepochs.append(self.e) self.vats.append(t1-t0) # Save the model that performs best on the validation set. # Best is: "significantly" lower nll. if self.vanlls[-1] < self.bestvanll - min_nll_diff: self.ebest = self.e self.bestva = self.vaerrs[-1] self.bestvanll = self.vanlls[-1] save_model(self.optim.model, savename) t0 = time.clock() kw = dict(aug=aug, shuf=shuf) if lr is not None: kw['lrate'] = lr cost, nll = self.fit_epoch(Xtr, ytr, **kw) t1 = time.clock() # Store for posteriority. self.trnlls.append(nll) self.trcosts.append(cost) self.trepochs.append(self.e) self.trts.append(t1-t0) # Call whatever is registered as post-epoch callback. self.postepoch(self) # And only now did we advance an epoch. # That is because the cost and nll computed by the training step # are those *before* updating the gradient. self.e += 1 if lr is not None and lr_decay is not None: lr *= lr_decay except KeyboardInterrupt: # Just stop the loop on keyboard interrupt. # But also reload the best model we had. printnow(self.progressout, "Interrupted.") if True: #input("Reload best model? [y/n]") == 'y': load_model(self.optim.model, savename) printnow(self.progressout, "Reloaded!") tend = time.clock() self.t += tend-tstart printnow(self.progressout, 'Best in validation@{ebest}e ({t:.1f}s in total, i.e. {spe:.1f}s/e)\n', ebest = self.ebest, t = tend - tstart, spe = (tend - tstart)/e )
def _default_printprogress(self): # This just formats all of them nicely together and prints it. s_tr = _report_train(self.trcosts[-1], self.trnlls[-1], self.trts[-1]) s_va = _report_score(self.vanlls[-1], self.vaerrs[-1], self.vats[-1], self.last_yva_len) if self.vaepochs[-1] == self.e else None printnow(self.progressout, "{}\n", _report_epoch(self.e, s_tr, s_va, self.e == self.ebest))
args = parser.parse_args() print(args.criterion + " criterion will be used") if args.criterion == 'cosine': crit = BiternionCriterion() elif args.criterion == 'von-mises': crit = BiternionCriterion(kappa=1) else: print("ERROR: You specified wrong criterion. Sorry =(") sys.exit(1) for d in args.modeldir.split(':'): sys.path.append(d) netlib = import_module(args.net) printnow("Loading data from {}\n", args.datadir) Xtr, ytr, Xte, yte, nte = prepare_data(args.datadir, netlib) ytr = ytr.astype(df.floatX) yte = yte.astype(df.floatX) printnow("Got {:.2f}k training images after flipping\n", len(Xtr)/1000.0) aug = netlib.mkaug(Xtr, ytr) net = netlib.mknet() printnow('Network has {:.3f}M params in {} layers\n', df.utils.count_params(net)/1000.0/1000.0, len(net.modules)) print(net[:21].forward(aug.augbatch_train(Xtr[:100])[0]).shape) costs = dotrain(net, crit, aug, Xtr, ytr, nepochs=args.epochs) print("Costs: {}".format(' ; '.join(map(str, costs)))) dostats(net, aug, Xtr, batchsize=64)