def nodelink_incidence(graph, rm_redundant = False):
"""
get node-link incidence matrix
Parameters
----------
graph: graph object
rm_redundant: if True, remove redundant constraints for the ue solver
Return value
------------
C: matrix of incidence node-link
ind: indices of a basis formed by the rows of C
"""
m, n = graph.numnodes, graph.numlinks
entries, I, J = [], [], []
for id1,node in graph.nodes.items():
for id2,link in node.inlinks.items(): entries.append(1.0); I.append(id1-1); J.append(graph.indlinks[id2])
for id2,link in node.outlinks.items(): entries.append(-1.0); I.append(id1-1); J.append(graph.indlinks[id2])
C = spmatrix(entries, I, J, (m,n))
if rm_redundant:
M = matrix(C)
r = rn.rank(M)
if r < m:
print 'Remove {} redundant constraint(s)'.format(m-r)
ind = find_basis(M.trans())
return C[ind,:], ind
return C, range(m)
def nodelink_incidence(graph, rm_redundant = False):
"""
get node-link incidence matrix
Parameters
----------
graph: graph object
rm_redundant: if True, remove redundant constraints for the ue solver
Return value
------------
C: matrix of incidence node-link
ind: indices of a basis formed by the rows of C
"""
m, n = graph.numnodes, graph.numlinks
entries, I, J = [], [], []
for id1,node in graph.nodes.items():
for id2,link in node.inlinks.items(): entries.append(1.0); I.append(id1-1); J.append(graph.indlinks[id2])
for id2,link in node.outlinks.items(): entries.append(-1.0); I.append(id1-1); J.append(graph.indlinks[id2])
C = spmatrix(entries, I, J, (m,n))
if rm_redundant:
M = matrix(C)
r = rn.rank(M)
if r < m:
print 'Remove {} redundant constraint(s)'.format(m-r)
ind = find_basis(M.trans())
return C[ind,:], ind
return C, range(m)
def feasible_pathflows(graph, l_obs, obs=None, update=False,
with_cell_paths=False, with_ODs=False, x_true=None, wp_trajs=None):
"""Attempts to find feasible pathflows given partial of full linkflows
Parameters:
----------
graph: Graph object
l_obs: observations of link flows
obs: indices of the observed links
update: if True, update path flows in graph
with_cell_paths: if True, include cell paths as constraints
with_ODs: if True, include ODs in the constraints if no with_cell_paths or in the objective if with_cell_paths
"""
assert with_cell_paths or with_ODs # we must have some measurements!
n = graph.numpaths
# route to links flow constraints
A, b = linkpath_incidence(graph), l_obs
if obs: A = A[obs,:] # trim matrix if we have partial observations
Aineq, bineq = spmatrix(-1.0, range(n), range(n)), matrix(0.0, (n,1)) # positive constraints
if not with_cell_paths: # if just with ODs flow measurements:
Aeq, beq = path_to_OD_simplex(graph) # route to OD flow constraints
else: # if we have cellpath flow measurements:
assert wp_trajs is not None
Aeq, beq = WP.simplex(graph, wp_trajs) # route to cellpath flow constraints
if with_ODs: # if we have ODs + cellpaths measurements
T, d = path_to_OD_simplex(graph) # route to OD flow constraints included in objective
A, b = matrix([A, T]), matrix([b, d]) # add the constraints to the objective
if x_true is not None:
err1 = np.linalg.norm(A * x_true - b, 1) / np.linalg.norm(b, 1)
err2 = np.linalg.norm(Aeq * x_true - beq) / np.linalg.norm(beq, 1)
assert err1 < TOL, 'Ax!=b'
assert err2 < TOL, 'Aeq x!=beq'
# construct objective for cvxopt.solvers.qp
Q, c = A.trans()*A, -A.trans()*b
#x = solvers.qp(Q + REG_EPS*spmatrix(1.0, range(n), range(n)), c, Aineq, bineq, Aeq, beq)['x']
# try with cvxopt.solvers.cp
def qp_objective(x=None, z=None):
if x is None: return 0, matrix(1.0, (n, 1))
f = 0.5 * x.trans()*Q*x + c.trans() * x
Df = (Q*x + c).trans()
if z is None: return f, Df
return f, Df, z[0]*Q
dims = {'l': n, 'q': [], 's': []}
x = solvers.cp(qp_objective, G=Aineq, h=bineq, A=Aeq, b=beq,
kktsolver=get_kktsolver(Aineq, dims, Aeq, qp_objective))['x']
if update:
logging.info('Update link flows, delays in Graph.'); graph.update_linkflows_linkdelays(P*x)
logging.info('Update path delays in Graph.'); graph.update_pathdelays()
logging.info('Update path flows in Graph object.'); graph.update_pathflows(x)
#import ipdb
#rank = 5
#if with_ODs == False:
# ipdb.set_trace()
return x, rn.rank(matrix([A, Aeq])), n
def SetT(self):
if self.H_hat.shape[0] != 0:
NS = nullspace(self.H_hat)
if rank(NS) >= self.Nj:
self.PrecodingT = NS[:, 0:self.Nj]
else:
self.PrecodingT = [None]
else:
self.PrecodingT = [None]
def checkit(a):
print "a:"
print a
r = rank(a)
print "rank is", r
ns = nullspace(a)
print "nullspace:"
print ns
if ns.size > 0:
res = np.abs(np.dot(a, ns)).max()
print "max residual is", res
def solver(data, ls, degree, full=False):
"""Solves the inverse optimization problem
Parameters
----------
data: Aeq, beqs, ffdelays, slopes from get_data(graphs)
ls: list of link flow vectors in equilibrium
degree: degree of the polynomial function to estimate
full: if False, just return theta, if True, return the whole primal solution
"""
c, A, b = constraints(data, ls, degree)
print A.size
r = rn.rank(matrix(A))
print r
if full: return solvers.lp(c, G=A, h=b)['x']
return solvers.lp(c, G=A, h=b)['x'][range(degree)]
return numpy.asarray(x).reshape(-1)
def matMulFlatten(a,x):
return flatten(a * numpy.matrix(numpy.reshape(x,[a.shape[1],1])))
nSides = 6
for kFlips in range(1,4):
print
print '***** nSides =',nSides,'kFlips =',kFlips
# first check insisting on unbiasedness
# completely determines the estimate for
# one flip from a nSides-slides system
sNK = freqSystem(nSides,kFlips)
# print sNK
print 'full rank'
print rank(sNK['a'].T * sNK['a'])==kFlips+1
print 'bias free determined solution'
printEsts(flatten(numpy.linalg.solve(sNK['a'].T * sNK['a'], \
sNK['a'].T * sNK['b'])))
print 'standard empirical solution'
printEsts(empiricalMeansEstimates(nSides,kFlips))
print 'losses for standard empirical solution'
print printLosses(losses(nSides,empiricalMeansEstimates(nSides,kFlips)))
# now show the Bayes solution has smaller loss
bayesSoln = bayesMeansEstimates(nSides,kFlips)
print 'Bayes solution'
printEsts(bayesSoln)
print 'losses for Bayes solution'
printLosses(losses(nSides,bayesSoln))
print 'Bayes max loss improvement'
def feasible_pathflows(graph,
l_obs,
obs=None,
update=False,
with_cell_paths=False,
with_ODs=False,
x_true=None,
wp_trajs=None):
"""Attempts to find feasible pathflows given partial of full linkflows
Parameters:
----------
graph: Graph object
l_obs: observations of link flows
obs: indices of the observed links
update: if True, update path flows in graph
with_cell_paths: if True, include cell paths as constraints
with_ODs: if True, include ODs in the constraints if no with_cell_paths or in the objective if with_cell_paths
"""
assert with_cell_paths or with_ODs # we must have some measurements!
n = graph.numpaths
# route to links flow constraints
A, b = linkpath_incidence(graph), l_obs
if obs: A = A[obs, :] # trim matrix if we have partial observations
Aineq, bineq = spmatrix(-1.0, range(n),
range(n)), matrix(0.0,
(n, 1)) # positive constraints
if not with_cell_paths: # if just with ODs flow measurements:
Aeq, beq = path_to_OD_simplex(graph) # route to OD flow constraints
else: # if we have cellpath flow measurements:
assert wp_trajs is not None
Aeq, beq = WP.simplex(graph,
wp_trajs) # route to cellpath flow constraints
if with_ODs: # if we have ODs + cellpaths measurements
T, d = path_to_OD_simplex(
graph) # route to OD flow constraints included in objective
A, b = matrix([A, T]), matrix(
[b, d]) # add the constraints to the objective
if x_true is not None:
err1 = np.linalg.norm(A * x_true - b, 1) / np.linalg.norm(b, 1)
err2 = np.linalg.norm(Aeq * x_true - beq) / np.linalg.norm(beq, 1)
assert err1 < TOL, 'Ax!=b'
assert err2 < TOL, 'Aeq x!=beq'
# construct objective for cvxopt.solvers.qp
Q, c = A.trans() * A, -A.trans() * b
#x = solvers.qp(Q + REG_EPS*spmatrix(1.0, range(n), range(n)), c, Aineq, bineq, Aeq, beq)['x']
# try with cvxopt.solvers.cp
def qp_objective(x=None, z=None):
if x is None: return 0, matrix(1.0, (n, 1))
f = 0.5 * x.trans() * Q * x + c.trans() * x
Df = (Q * x + c).trans()
if z is None: return f, Df
return f, Df, z[0] * Q
dims = {'l': n, 'q': [], 's': []}
x = solvers.cp(qp_objective,
G=Aineq,
h=bineq,
A=Aeq,
b=beq,
kktsolver=get_kktsolver(Aineq, dims, Aeq,
qp_objective))['x']
if update:
logging.info('Update link flows, delays in Graph.')
graph.update_linkflows_linkdelays(P * x)
logging.info('Update path delays in Graph.')
graph.update_pathdelays()
logging.info('Update path flows in Graph object.')
graph.update_pathflows(x)
#import ipdb
#rank = 5
#if with_ODs == False:
# ipdb.set_trace()
return x, rn.rank(matrix([A, Aeq])), n
def matMulFlatten(a, x):
return flatten(a * numpy.matrix(numpy.reshape(x, [a.shape[1], 1])))
nSides = 6
for kFlips in range(1, 4):
print
print '***** nSides =', nSides, 'kFlips =', kFlips
# first check insisting on unbiasedness
# completely determines the estimate for
# one flip from a nSides-slides system
sNK = freqSystem(nSides, kFlips)
# print sNK
print 'full rank'
print rank(sNK['a'].T * sNK['a']) == kFlips + 1
print 'bias free determined solution'
printEsts(flatten(numpy.linalg.solve(sNK['a'].T * sNK['a'], \
sNK['a'].T * sNK['b'])))
print 'standard empirical solution'
printEsts(empiricalMeansEstimates(nSides, kFlips))
print 'losses for standard empirical solution'
print printLosses(losses(nSides, empiricalMeansEstimates(nSides, kFlips)))
# now show the Bayes solution has smaller loss
bayesSoln = bayesMeansEstimates(nSides, kFlips)
print 'Bayes solution'
printEsts(bayesSoln)
print 'losses for Bayes solution'
printLosses(losses(nSides, bayesSoln))
print 'Bayes max loss improvement'
