def ml_cost(self, pos_v, neg_v):
"""
Variational approximation to the maximum likelihood positive phase.
:param v: T.matrix of shape (batch_size, n_v), training examples
:return: tuple (cost, gradient)
"""
pos_cost = T.mean(self.free_energy(pos_v))
neg_cost = T.mean(self.free_energy(neg_v))
cost = pos_cost - neg_cost
return costmod.Cost(cost, self.params(), [pos_v, neg_v])
def __init__(self, task, name=None, cost_obj=None):
assert isinstance(task, Task)
assert isinstance(cost_obj, cost.Cost)
self._this_task = task # this route belongs to task
self._name = name
self._cost = cost_obj if task.line_expense is None else \
cost.Cost(cost_obj.distance, task.line_expense, cost_obj.duration)
self._expected_end_time = \
self._this_task.expected_start_time + self._this_task.no_run_time + self._cost.duration
self._next_steps = list() # next reachable steps for sorting in future
self._profit = None
self._max_profit = None
def __init__(self, name, avl_loc=None, avl_time=0, candidate_num_limit=10):
self._name = name
self._avl_loc = avl_loc
self._avl_time = avl_time # hours
self._candidate_plans_sorted = list()
self._candidate_num_limit = candidate_num_limit
# record all possible plans with a virtual route, a self-loop route
self._start_route = Route(task=Task(loc_start=self._avl_loc,
loc_end=self._avl_loc,
start_time=self._avl_time,
occur_prob=1.0,
is_virtual=1,
name=self._name),
name=None,
cost_obj=cost.Cost())
def get_reg_cost(self, l2=None, l1=None):
"""
Builds the symbolic expression corresponding to first-order gradient descent
of the cost function ``cost'', with some amount of regularization defined by the other
parameters.
:param l2: dict whose values represent amount of L2 regularization to apply to
parameter specified by key.
:param l1: idem for l1.
"""
cost = T.zeros((), dtype=floatX)
params = []
for p in self.params():
if l1.get(p.name, 0):
cost += l1[p.name] * T.sum(abs(p))
params += [p]
if l2.get(p.name, 0):
cost += l2[p.name] * T.sum(p**2)
params += [p]
return costmod.Cost(cost, params)
def init(s_cost):
if (s_cost == 'parabola1d'):
bounds = np.array([[0.0, 1.0]])
maxmin = 1
tol = 1e-6
fCST = fnc_cost.parabola1d
elif (s_cost == 'parabola2d'):
bounds = np.array([[-1.0, 1.0], [-1.0, 1.0]])
maxmin = 1
tol = 1e-8
fCST = fnc_cost.parabola2d
elif (s_cost == 'sphere'):
bounds = np.array([[-1.0, 1.0], [-1.0, 1.0], [-1.0, 1.0]])
maxmin = 1
tol = 1e-6
fCST = fnc_cost.sphere
elif (s_cost == 'charbonneau1'):
bounds = np.array([[0.0, 1.0], [0.0, 1.0]])
maxmin = -1
tol = 1e-6
fCST = fnc_cost.charbonneau1
elif (s_cost == 'charbonneau2'):
bounds = np.array([[0.0, 1.0], [0.0, 1.0]])
maxmin = -1
tol = 1e-8
fCST = fnc_cost.charbonneau2
elif (s_cost == 'charbonneau4'):
bounds = np.array([[0.0, 2.0], [-1.0, 1.0], [0.01, 1.0], [0.0, 2.0],
[-1.0, 1.0], [0.001, 1.0]])
maxmin = 1
tol = 1e-8
fCST = fnc_cost.charbonneau4
else:
raise Exception('[init]: invalid s_prob %s')
return cost.Cost(fCST, bounds, tol, maxmin)