def test_progress(): log = Logger(levl=10) i_max = 10 j_max = 100 for i in range(i_max): log.progress(name='progress1', iteration=i, i_max=i_max) for j in range(j_max): log.progress(name='progress2', iteration=j, i_max=j_max) log.process_queue() log.end()
def test_graphical_logging(): log = Logger(levl=10) i_max = 1000 for i in range(i_max): log.graphical_cost(cost=1/(i+1), n_iteration=i) if i == 50000: raise KeyboardInterrupt() log.process_queue() log.end()
import numpy as np from toolboxTom.logger import Logger log = Logger('MomentGD') from . import _GradientDescent class MomentGradientDescent(_GradientDescent): """Gradient Descent with moment update""" def __init__(self, problem, decreasing_rate='', alpha_moment=0.9, restart=True, debug=0, **kwargs): if debug: debug -= 1 log.set_level(10) super(MomentGradientDescent, self).__init__(problem, decreasing_rate, debug=debug, **kwargs) self.p_grad = np.zeros(self.pb.pt.shape) self.alpha_moment = alpha_moment self.restart = restart def __repr__(self): return 'MomentDescent - ' + str(self.restart) def p_update(self):
import numpy as np from math import sqrt from time import time from toolboxTom.logger import Logger log = Logger('_GD', 10) from . import get_log_rate, _GradientDescent class _AlternateDescent(object): """Class to hold gradient descent properties""" id_gd = 0 def __init__(self, problem, decreasing_rate='sqrt', stop='', tol=1e-10, graphical_cost=None, name=None, debug=0, logging=False, log_rate='log', i_max=1000, t_max=40, methods=[]): '''Gradient Descent handeler Parameters ---------- problem: _CoupledProblem to solve param: list of the Parameters alpha: learning rate controler grad: function computing the gradient given the current parameters decreasing_rate: {'sqrt', 'linear'} deacreasing rate for the learning rate
import numpy as np import sys from toolboxTom.logger import Logger import multiprocessing from multiprocessing import Process, Queue log = Logger(name='map') log.set_level(0) class WorkerGroups(Process): def __init__(self, qin, qout, fun, id_w=0, **kwargs): super(WorkerGroups, self).__init__(name='Worker n°{}'.format(id_w)) self.qin = qin self.qout = qout self.id = id_w self.fun = fun self.args = kwargs def run(self): idp, p = self.qin.get() while idp is not None: log.debug('Worker {} - |qin| = {}' ''.format(self.id, self.qin.qsize())) params = dict(p=p, **self.args) try: self.qout.put((idp, self.fun(**params))) except: import traceback msg = traceback.format_exc() print(msg) idp, p = self.qin.get()
def test_level(): log = Logger(levl=40) log.debug('Do not appear!!') log.info('Do not appear!!') log.warning('Do not appear!!') log.error('Should appear!!') log.critical('Should appear!!') log.process_queue() log.end()
from numpy import ndarray from multiprocessing import Queue from .worker_solver import WorkerSolver from .problem import _Problem from toolboxTom.logger import Logger log = Logger('//Solver', 20) class ParalelSolver(object): """Paralell sparse coding""" def __init__(self, n_jobs=4, debug=0, **kwargs): super(ParalelSolver, self).__init__() self.n_jobs = n_jobs self.param = kwargs if debug: log.set_level(10) debug -= 1 self.debug = debug def solve(self, problems, **kwargs): if type(problems) not in [list, ndarray]: problems = [problems] assert issubclass( type(problems[0]), _Problem), ('ParalelSolver argument is not a _Problem subclass') qin = Queue() qout = Queue() for i, pb in enumerate(problems): qin.put((i, pb))
import numpy as np from optim.problem import _Problem from toolboxTom.logger import Logger log = Logger() class Test(_Problem): """Test class for problem""" def __init__(self, lr=.1, **kwargs): super(Test, self).__init__(sizes=(1000, )) A = np.random.random(size=(100, 1000)) A = A < 0.07 A = A * np.random.normal(scale=2, size=A.shape) self.A = A + A[::-1] self.b = np.random.normal(size=(100, )) self.lr = lr self.L = np.sum(A * A) def cost(self, pt): res = self.A.dot(pt[0]) - self.b res = np.sum(res * res) return 0.5 * res + self.lr * np.sum(abs(pt[0])) def grad(self, pt): return [self.A.T.dot(self.A.dot(pt[0]) - self.b)] def prox(self, pt): return np.sign(pt) * np.maximum(abs(pt) - self.lr, 0)
from time import time from toolboxTom.logger import Logger from . import _GradientDescent log = Logger(name='Solver', levl=20) class Solver(object): """Encode a signal in the convolutional dictionary""" def __init__(self, optim=_GradientDescent, max_time=None, i_max=1e6, debug=0, **kwargs): self.optim = optim self.param = kwargs self.i_max = i_max self.max_time = max_time if debug: log.set_level(10) def solve(self, pb, **kwargs): self.pb = pb self.param.update(**kwargs) solver = self.optim(self.pb, **self.param) finished = False self.start_time = time() self.iter = 0 while not finished and not self._stop(): finished = solver.update()
import numpy as np from . import _GradientDescent from toolboxTom.logger import Logger log = Logger(name='ProximalDescent') class ProximalDescent(_GradientDescent): """Gradient Descent with the nesterov momentum""" def __init__(self, problem, decreasing_rate='', f_theta='boyd', restart=False, debug=0, **kwargs): self.restart = restart if debug > 0: debug -= 1 log.set_level(10) super(ProximalDescent, self).__init__(problem, decreasing_rate=decreasing_rate, debug=debug, **kwargs) self.theta = [1, 1] if type(f_theta) is float: self.theta = [1 - f_theta] * 2 self.p_grad = np.zeros(self.pb.pt.shape) self.f_theta = f_theta self.alpha = 1 / self.pb.L