def test_23(self): t = util.Timer() t.start() with util.ContextTimer(t, action='StopStart'): t0 = t.elapsed() t.stop() assert t.elapsed() >= 0.0
def __new__(cls, *args, **kwargs): """Create a DictLearn object and start its initialisation timer.""" instance = super(DictLearn, cls).__new__(cls) instance.timer = util.Timer(['init', 'solve', 'solve_wo_eval']) instance.timer.start('init') return instance
def test_21(self): t = util.Timer('a') t.start(['a', 'b']) t.reset('a') assert t.elapsed('a') == 0.0 t.reset('all') assert t.elapsed('b') == 0.0
def __new__(cls, *args, **kwargs): """Create a FISTA object and start its initialisation timer.""" instance = super(FISTA, cls).__new__(cls) instance.timer = util.Timer(['init', 'solve', 'solve_wo_func', 'solve_wo_rsdl', 'solve_wo_btrack']) instance.timer.start('init') return instance
def test_19(self): t = util.Timer() t.start() t0 = t.elapsed() t.stop() t1 = t.elapsed() assert t0 >= 0.0 assert t1 >= t0 assert len(t.__str__()) > 0 assert len(t.labels()) > 0
def test_17(self): t = util.Timer() t.start() t0 = t.elapsed() t.stop() t1 = t.elapsed() assert (t0 >= 0.0) assert (t1 >= t0) assert (len(t.__str__()) > 0) assert (len(t.labels()) > 0)
def test_20(self): t = util.Timer('a') t.start(['a', 'b']) t0 = t.elapsed('a') t.stop('a') t.stop('b') t.stop(['a', 'b']) assert t.elapsed('a') >= 0.0 assert t.elapsed('b') >= 0.0 assert t.elapsed('a', total=False) == 0.0
def __init__(self, xstep, dstep, opt=None, isc=None): """ Initialise a DictLearn object with problem size and options. Parameters ---------- xstep : bpdn (or similar interface) object Object handling X update step dstep : cmod (or similar interface) object Object handling D update step opt : :class:`DictLearn.Options` object Algorithm options isc : :class:`DictLearn.IterStatsConfig` object Iteration statistics and header display configuration """ self.runtime = 0.0 self.timer = util.Timer() if opt is None: opt = DictLearn.Options() self.opt = opt if isc is None: isc = IterStatsConfig( isfld = ['Iter', 'ObjFunX', 'XPrRsdl', 'XDlRsdl', 'XRho', 'ObjFunD', 'DPrRsdl', 'DDlRsdl', 'DRho', 'Time'], isxmap = {'ObjFunX' : 'ObjFun', 'XPrRsdl' : 'PrimalRsdl', 'XDlRsdl' : 'DualRsdl', 'XRho' : 'Rho'}, isdmap = {'ObjFunD' : 'DFid', 'DPrRsdl' : 'PrimalRsdl', 'DDlRsdl' : 'DualRsdl', 'DRho' : 'Rho'}, evlmap = {}, hdrtxt = ['Itn', 'FncX', 'r_X', 's_X', u('ρ_X'), 'FncD', 'r_D', 's_D', u('ρ_D')], hdrmap = {'Itn' : 'Iter', 'FncX' : 'ObjFunX', 'r_X' : 'XPrRsdl', 's_X' : 'XDlRsdl', u('ρ_X') : 'XRho', 'FncD' : 'ObjFunD', 'r_D' : 'DPrRsdl', 's_D' : 'DDlRsdl', u('ρ_D') : 'DRho'} ) self.isc = isc self.xstep = xstep self.dstep = dstep self.itstat = [] self.j = 0 # Increment `runtime` to reflect object initialisation # time. The timer object is reset to avoid double-counting of # elapsed time if a similar increment is applied in a derived # class __init__. self.runtime += self.timer.elapsed(reset=True)
def __init__(self, D, S, lmbda=None, opt=None, dimK=None, dimN=2): r"""We use the same layout as ConvBPDN as input and output, but for internal computation we use a differnt layout. Internal Parameters ------------------- X: [K, m, N] Convolutional representation of the input signal. m is the size of atom in a dictionary, K is the batch size of input signals, and N is the number of slices extracted from each signal (usually number of pixels in an image). Y: [K, n, N] Splitted variable with contraint :math:`D_l x_i - y_i = 0`. n represents the size of each slice. U: [K, n, N] Dual variable with the same size as Y. """ if opt is None: opt = ConvBPDNSlice.Options() # Set dtype attribute based on S.dtype and opt['DataType'] self.set_dtype(opt, S.dtype) if not hasattr(self, 'cri'): self.cri = cr.CSC_ConvRepIndexing(D, S, dimK=dimK, dimN=dimN) self.boundary = opt['Boundary'] # Number of elements of sparse representation x is invariant to # slice/FFT solvers. Nx = np.product(self.cri.shpX) # NOTE: To incorporate with im2slices/slices2im, where each slice # is organized as in_channels x patch_size x patch_size, the dictionary # is first transposed to [in_channels, patch_size, patch_size, out_channels], # and then reshape to 2-D (N, M). self.setdict(D) # Externally the input signal should have a data layout as # S(N0, N1, ..., C, K). # First convert to common pytorch Variable layout. # [H, W, C, K, 1] -> [K, C, H, W] self.S = np.asarray(S.reshape(self.cri.shpS), dtype=S.dtype) self.S = self.S.squeeze(-1).transpose((3, 2, 0, 1)) # [K, n, N] self.S_slice = self.im2slices(self.S) self.lmbda = lmbda # Set penalty parameter if not set self.set_attr('rho', opt['rho'], dval=(50.0*self.lmbda + 1.0), dtype=self.dtype) super().__init__(Nx, self.S_slice.shape, self.S_slice.shape, S.dtype, opt) self.X = np.zeros( (self.S_slice.shape[0], self.D.shape[-1], self.Y.shape[-1]), dtype=self.dtype ) self.extra_timer = su.Timer(['xstep', 'ystep'])
def __init__(self, D, S, lmbda=None, opt=None, dimK=None, dimN=2): if opt is None: opt = ConvBPDNSliceTwoBlockCnstrnt.Options() # Set dtype attribute based on S.dtype and opt['DataType'] self.set_dtype(opt, S.dtype) if not hasattr(self, 'cri'): self.cri = cr.CSC_ConvRepIndexing(D, S, dimK=dimK, dimN=dimN) self.lmbda = self.dtype.type(lmbda) # Set penalty parameter if not set self.set_attr('rho', opt['rho'], dval=(50.0*self.lmbda + 1.0), dtype=self.dtype) # Set xi if not set self.set_attr('tau_xi', opt['AutoRho', 'RsdlTarget'], dval=(1.0+18.3**(np.log10(self.lmbda)+1.0)), dtype=self.dtype) # set boundary condition self.set_attr('boundary', opt['Boundary'], dval='circulant_back', dtype=None) # set weight factor between two constraints self.set_attr('gamma', opt['Gamma'], dval=1., dtype=self.dtype) self.setdict(D) # Number of elements of sparse representation x is invariant to # slice/FFT solvers. Nx = np.product(self.cri.shpX) # Externally the input signal should have a data layout as # S(N0, N1, ..., C, K). # First convert to common pytorch Variable layout. # [H, W, C, K, 1] -> [K, C, H, W] self.S = np.asarray(S.reshape(self.cri.shpS), dtype=S.dtype) self.S = self.S.squeeze(-1).transpose((3, 2, 0, 1)) # [K, n, N] self.S_slice = self.im2slices(self.S) yshape = (self.S_slice.shape[0], self.D.shape[0] + self.D.shape[1], self.S_slice.shape[-1]) super().__init__(Nx, yshape, 1, self.D.shape[0], S.dtype, opt) self.X = np.zeros_like(self._Y1, dtype=self.dtype) self.extra_timer = su.Timer(['xstep', 'ystep'])
# Load dictionary D = util.convdicts()['G:12x12x72'] # Set up ConvBPDN options lmbda = 1e-2 opt = cbpdn.ConvBPDN.Options({'Verbose': True, 'MaxMainIter': 200, 'HighMemSolve': True, 'RelStopTol': 5e-3, 'AuxVarObj': False, 'AutoRho': {'Enabled': False}, 'rho': 5.0}) # Time CUDA cbpdn solve t = util.Timer() with util.ContextTimer(t): X = cucbpdn.cbpdn(D, sh, lmbda, opt) print("Image size: %d x %d" % sh.shape) print("GPU ConvBPDN solve time: %.2fs" % t.elapsed()) # Reconstruct the image from the sparse representation shr = np.sum(spl.fftconv(D, X), axis=2) imgr = sl + shr #Display representation and reconstructed image. fig = plot.figure(figsize=(14, 14)) plot.subplot(2, 2, 1) plot.imview(sl, fig=fig, title='Lowpass component')
def __new__(cls, *args, **kwargs): instance = super(OnlineDictLearnDenseSurrogate, cls).__new__(cls) instance.timer = su.Timer(['init', 'solve', 'solve_wo_eval', 'hessian', 'xstep', 'dstep']) instance.timer.start('init') return instance
def test_22(self): t = util.Timer() with util.ContextTimer(t): t0 = t.elapsed() assert t.elapsed() >= 0.0
# Set up ConvBPDN options lmbda = 1e-2 opt = cbpdn.ConvBPDN.Options({ 'Verbose': False, 'MaxMainIter': 0, 'HighMemSolve': True, 'LinSolveCheck': True, 'RelStopTol': 1e-5, 'AuxVarObj': False, 'AutoRho': { 'Enabled': False } }) # Compute initialisation time: solve with 0 iterations t0 = util.Timer() with util.ContextTimer(t0): X = cucbpdn.cbpdn(D, sh, lmbda, opt) # Solve with Niter iterations Niter = 200 opt['MaxMainIter'] = Niter t1 = util.Timer() with util.ContextTimer(t1): X = cucbpdn.cbpdn(D, sh, lmbda, opt) # Print run time information print("GPU ConvBPDN init time: %.3fs" % t0.elapsed()) print("GPU ConvBPDN solve time per iteration: %.3fs" % (t1.elapsed() / Niter))
def __new__(cls, *args, **kwargs): instance = super(OnlineSliceDictLearn, cls).__new__(cls) instance.timer = su.Timer( ['init', 'solve', 'solve_wo_eval', 'xstep', 'dstep']) instance.timer.start('init') return instance
'GradWeight': wgr, 'AutoRho': { 'Enabled': False, 'StdResiduals': False } }) """ Construct :class:`.admm.cbpdn.AddMaskSim` wrapper for :class:`.admm.cbpdn.ConvBPDNGradReg` and solve via wrapper. If the ``sporco-cuda`` extension is installed and a GPU is available, use the CUDA implementation of this combination. """ if cuda.device_count() > 0: opt['L1Weight'] = wl1 opt['GradWeight'] = wgr ams = None print('%s GPU found: running CUDA solver' % cuda.device_name()) tm = util.Timer() with sys_pipes(), util.ContextTimer(tm): X = cuda.cbpdngrdmsk(Di, imgwp, mskp, lmbda, mu, opt) t = tm.elapsed() imgr = crop(np.sum(linalg.fftconv(Di, X), axis=-1)) else: opt['L1Weight'] = wl1i opt['GradWeight'] = wgri ams = cbpdn.AddMaskSim(cbpdn.ConvBPDNGradReg, Di, imgwp, mskp, lmbda, mu, opt=opt) X = ams.solve().squeeze()
def __init__(self, Nx, yshape, ushape, dtype, opt=None): """ Initialise an ADMM object with problem size and options. Parameters ---------- Nx : int Size of variable :math:`\mathbf{x}` in objective function yshape : tuple of ints Shape of working variable Y (the auxiliary variable) ushape : tuple of ints Shape of working variable U (the scaled dual variable) dtype : data-type Data type for working variables (overridden by 'DataType' option) opt : :class:`ADMM.Options` object Algorithm options """ if opt is None: opt = ADMM.Options() if not isinstance(opt, ADMM.Options): raise TypeError("Parameter opt must be an instance of ADMM.Options") # Management of timing of object initialisation is the # responsibility of derived classes. Timing of :meth:`solve` # is managed by this class. self.runtime = 0.0 self.timer = util.Timer() self.opt = opt self.Nx = Nx # Working variable U has the same dimensionality as constant c # in the constraint Ax + By = c self.Nc = np.product(ushape) # DataType option overrides data type inferred from __init__ # parameters of derived class self.set_dtype(opt, dtype) # Initialise attributes representing penalty parameter and other # parameters self.set_attr('rho', opt['rho'], dval=1.0, dtype=self.dtype) self.set_attr('rho_tau', opt['AutoRho', 'Scaling'], dval=2.0, dtype=self.dtype) self.set_attr('rho_mu', opt['AutoRho', 'RsdlRatio'], dval=10.0, dtype=self.dtype) self.set_attr('rho_xi', opt['AutoRho', 'RsdlTarget'], dval=1.0, dtype=self.dtype) self.set_attr('rlx', opt['RelaxParam'], dval=1.0, dtype=self.dtype) # Initialise working variable Y if self.opt['Y0'] is None: self.Y = self.yinit(yshape) else: self.Y = self.opt['Y0'].astype(self.dtype, copy=True) self.Yprev = self.Y.copy() # Initialise working variable U if self.opt['U0'] is None: self.U = self.uinit(ushape) else: self.U = self.opt['U0'].astype(self.dtype, copy=True) self.itstat = [] self.k = 0