/
.grad_16Jan2012.py
executable file
·94 lines (90 loc) · 3.93 KB
/
.grad_16Jan2012.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
#!/usr/bin/python
from cvxopt import solvers, matrix, spdiag, log
import numpy, math
logfile = open('grad.log', 'w')
class Netcal(object):
def routing_matrix(self): # {{{
H = [[[0. for j in range(self.J)] for l in range(self.L)] for i in range(self.I)]
H[0][0][0] = 1.
H[0][1][1] = 1.
H[0][2][0] = 1.
H[1][0][0] = 1.
H[1][1][1] = 1.
H[1][2][0] = 1.
return H # }}}
def __init__(self,q=0.001,NULL = 1e-300, I = 2, J = 2, L = 3, capa = -1): # {{{
self.q = q
self.NULL = NULL
self.I = I
self.J = J
self.L = L
self.IJ = I*J
self.GH1 = numpy.array([[NULL for ij in range(self.IJ)] for l in range(self.L)])
if capa == -1:
self.capa = matrix(.1 * numpy.ones((self.L)))
else: self.capa = capa
self.rhs2st = matrix(numpy.zeros(self.IJ))
self.H = self.routing_matrix() # }}}
def utility(self,z): # {{{
u = numpy.empty((self.L))
u1 = lambda l: 1. / self.capa[l] * (sum(sum(self.H[i][l][j] * z[i][j] for j in range(self.J)) for i in range(self.I)))
for l in range(self.L): u[l] = u1(l)
return u # }}}
def hfunc(self,m, n, p, k, z): # {{{
u = self.utility(z)
if m == p and n == k:
return self.endhost_weight[m] / sum(z[m][j] for j in range(self.J)) ** 2 + \
self.q * sum(((self.H[m][l][n] / self.capa[l]) ** 2) * math.exp(u[l]) for l in range(self.L))
elif m == p:
return self.endhost_weight[m] / sum(z[m][j] for j in range(self.J)) ** 2 + \
self.q * sum((self.H[m][l][n] * self.H[p][l][k] / self.capa[l] ** 2) * math.exp(u[l]) for l in range(self.L))
else:
return self.q * sum(self.H[m][l][n] * self.H[p][l][k] / (self.capa[l] ** 2) * math.exp(u[l]) for l in range(self.L)) # }}}
def func(self,x): # {{{
z = numpy.reshape(x, (self.I, self.J))
u = self.utility(z)
f = -sum(self.endhost_weight[i] * log(sum(z[i][j] for j in range(self.J))) for i in range(self.I)) + self.q * sum(math.exp(u[l]) for l in range(self.L))
return f # }}}
def gradFunc(self,x): # {{{
z = numpy.reshape(x, (self.I, self.J))
Df = numpy.empty((self.I, self.J))
u = self.utility(z)
df1 = lambda m, n:-self.endhost_weight[m] / sum(z[m][j] for j in range(self.J)) + \
self.q * sum(self.H[m][l][n] / self.capa[l] * math.exp(u[l]) for l in range(self.L))
for i in range(self.I):
for j in range(self.J):
Df[i][j] = df1(i, j)
Df1 = matrix(numpy.reshape(Df, (self.IJ)))
return Df1.T # }}}
def hessianFunc(self,x): # {{{
z = numpy.reshape(x, (self.I, self.J))
Hf = numpy.empty((self.I, self.J, self.I, self.J))
for m in range(self.I):
for n in range(self.J):
for p in range(self.I):
for k in range(self.J):
Hf[m][n][p][k] = self.hfunc(m, n, p, k, z)
Hf1 = matrix(numpy.reshape(Hf, (self.IJ, self.IJ)))
return Hf1 # }}}
def F(self,x=None, z=None): # {{{
n = self.I * self.J
if x is None: return 0, matrix(1.0, (n, 1))
if min(x) <= 0.:return None
f = self.func(x)
Df = self.gradFunc(x)
if z is None: return f, Df
H = self.hessianFunc(x)
return f, Df, H # }}}
def optFunc(self,endhost_weight): # {{{
self.endhost_weight = endhost_weight
for l in range(self.L):
for i in range(self.I):
for j in range(self.J):
self.GH1[l][i * self.J + j] = self.H[i][l][j]
GH = matrix(self.GH1)
DI = -numpy.identity(self.IJ)
G = matrix(numpy.vstack((GH, DI)))
h = matrix(numpy.vstack((self.capa, self.rhs2st)))
sol = solvers.cp(self.F, G, h)
return sol['x'],sol['z'] # }}}
logfile.close