def __init__(self,s,k):
# s = vectors
# x = means
m = s.shape[1]
n = s.shape[0]# s[i] = column vector as matrix in R^n
x = randn(n,k)
for loop in range(10):
d = zeros(k,m)
for j in range(m):
for i in range(k):
d[i,j] = norm.l_p(s[:,j] - x[:,i], 2)
min_d = np.full((m), np.inf)
for j in range(m):
for i in range(k):
if d[i,j] < min_d[j]:
min_d[j] = d[i,j]
b = zeros(k,m)
for j in range(m):
for i in range(k):
if d[i,j] == min_d[j]:
b[i,j] = 1
else:
b[i,j] = 0
for i in range(k):
num = zeros(n,1)
den = 0
for j in range(m):
num += b[i,j]*s[:,j]
den += b[i,j]
if den != 0:
x[:,i] = num / den
else:
x[:,i] += random.gauss(0,1) # random walk
self.s = s
self.x = x
def __init__(self,x,y,λ=0.1,W=None):
# W = list of matricies
n = x.shape[0]
m = y.shape[0]
q = x.shape[1]
assert y.shape[1] == q
Q = zeros(m*n,m*n)
c = zeros(m*n)
for i in range(q):
if W is None:
Q += np.kron(eye(m), x[:,i] * x[:,i].T)
c += np.kron(eye(m), x[:,i]) *y[:,i]
else:
Q += np.kron(eye(m), x[:,i] * W[i].T * W[i]* x[:,i].T)
c += np.kron(eye(m), x[:,i]) * W[i].T * W[i] * y[:,i]
Q *= 2
c *= -2
vec_A = norm.linear_QP_reg_l_1( Q, c ).solve()
A = mat( vec_A, m, n )
t = np.mean(np.abs(vec_A))
for i in range(m):
for j in range(n):
if abs(A[i,j]) < t:
A[i,j] = 0
self.A = sparse(A)
def bias(self, x_pos, x_neg):
m_pos = x_pos.shape[1]
m_neg = x_neg.shape[1]
Q = None
c = np.bmat([\
[ zeros(1) ],\
[ ones(m_pos) ],\
[ ones(m_neg) ]\
])
A_ub = np.bmat([\
[ ones(m_pos), -eye(m_pos), zeros(m_pos,m_neg) ],\
[ -ones(m_neg), zeros(m_neg,m_pos), -eye(m_neg) ],\
[ zeros(m_pos), -eye(m_pos), zeros(m_pos,m_neg) ],\
[ zeros(m_neg), zeros(m_neg,m_pos), -eye(m_neg) ]\
])
b_ub = np.bmat([\
[ -ones(m_pos) ],\
[ -ones(m_neg) ],\
[ zeros(m_pos) ],\
[ zeros(m_neg) ]\
])
for i in range(m_pos):
b_ub[i, 0] += self.a(x_pos[:, i])
for i in range(m_neg):
b_ub[i + m_pos, 0] -= self.a(x_neg[:, i])
P = poly(A_ub, b_ub)
sol = QP(Q, c, P).solve()
b = sol[0, 0]
return b
def __init__(self,s):
"""
x ∈ R^n
"""
s = sampled_convex_set.remove_interior_points(s)
n = s.shape[0]
m = s.shape[1]
A_ub = np.bmat([[zeros(m,n),-eye(m)],[zeros(m,n),eye(m)]])
b_ub = np.bmat([[zeros(m)],[ones(m)]])
A_eq = np.bmat([[-eye(n),s],[zeros(1,n),ones(1,m)]])
b_eq = np.bmat([[zeros(n)],[ones(1)]])
self.P = poly(A_ub,b_ub,A_eq,b_eq)
def solve(self):
x = self.problem.solve()
x1 = x[0:self.n]
x2 = x[self.n:2*2]
x1_min = zeros(self.n,1)
x2_min = zeros(self.n,1)
for i in range(self.n):
x1_min[i] = x1[i]
x2_min[i] = x2[i]
d_min = norm.l_p(x1_min-x2_min,self.q)
self.sol = (d_min,x1,x2)
return self.sol
def __init__(self,a,b,c,d,P):
n = P.n
m = P.A_ub.shape[0]
r = P.A_eq.shape[0]
A_ub = np.bmat([[P.A_ub,-P.b_ub],[zeros(1,n),-ones(1)]])
b_ub = zeros(m+1)
A_eq = np.bmat([[P.A_eq,-P.b_eq],[c.T,-d]])
b_eq = np.bmat([[zeros(r)],[ones(1)]])
P = poly(A_ub,b_ub,A_eq,b_eq)
Q = None
c = np.bmat([[a],[b]])
self.QP = QP(None,c,P)
self.n = n
def dual(self, x, y):
m = y.shape[0]
c_dual = -ones(m)
Q_dual = eye(m)
for i in range(m):
for j in range(m):
Q_dual[i, j] = y[i, 0] * y[j, 0] * self.K(x[:, i], x[:, j])
A_ub = -eye(m)
b_ub = zeros(m)
A_eq = y.T
b_eq = zeros(1)
P_dual = poly(A_ub, b_ub, A_eq, b_eq)
z = QP(Q_dual, c_dual, P_dual).solve()
return z
def __init__(self,x):
n = x.shape[0]
m = x.shape[1]
self.x = x
P_list = []
for j in range(m):
A = zeros(m-1,n)
b = zeros(m-1,1)
i_ = 0
for i in range(m):
if i != j:
A[i_,:] = 2*(x[:,i].T-x[:,j].T)
b[i_] = x[:,i].T*x[:,i] - x[:,j].T*x[:,j]
i_ += 1
P_list.append(poly(A,b))
self.P_list = P_list
def poly_center(P):# poly(A,b) -> x_center
m = P.A_ub.shape[0]
A = P.A_ub
assert np.linalg.matrix_rank(A) == A.shape[1], "non-unique solution"
b = P.b_ub
c = zeros(m)
for i in range(A.shape[0]):
c[i,0] = A[i,:]*A[i,:].T
c /= 4.0
return np.linalg.pinv(A)*(b-c)
def soft_dual(self, x, y, λ=0.1):
assert λ >= 0, "λ >= 0"
m = y.shape[0]
c_dual = None
Q_dual = eye(m)
for i in range(m):
for j in range(m):
Q_dual[i, j] = y[i, 0] * y[j, 0] * self.K(x[:, i], x[:, j])
A_ub = np.bmat([\
[ -eye(m) ],\
[ eye(m) ]\
])
b_ub = np.bmat([\
[ zeros(m) ],\
[ λ*ones(1) ]\
])
A_eq = y.T
b_eq = zeros(1)
P_dual = poly(A_ub, b_ub, A_eq, b_eq)
z = QP(Q_dual, c_dual, P_dual).solve()
return z
def add(self, P):
"""
x ∈ POLYHEDRON_self + [x;y] ∈ POLYHEDRON_in 🠊 [x;y] ∈ POLYHEDRON_out
"""
n = self.n
m = P.n - n
assert m >= 0
A_ub = None
b_ub = None
A_eq = None
b_eq = None
if self.A_ub is not None and P.A_ub is not None:
A_ub = np.bmat([\
[\
np.bmat([\
[ self.A_ub, zeros(self.A_ub.shape[0],m) ]\
])
],\
[P.A_ub]\
])
b_ub = np.bmat([[self.b_ub], [P.b_ub]])
elif self.A_ub is None and P.A_ub is not None:
A_ub = P.A_ub
b_ub = P.b_ub
if self.A_eq is not None and P.A_eq is not None:
A_eq = np.bmat([\
[\
np.bmat([\
[ self.A_eq, zeros(self.A_eq.shape[0],m) ]\
])
],\
[P.A_eq]\
])
b_eq = np.bmat([[self.b_eq], [P.b_eq]])
elif self.A_eq is None and P.A_eq is not None:
A_eq = P.A_eq
b_eq = P.b_eq
return poly(A_ub, b_ub, A_eq, b_eq)
def plot_poly_center(self):
m = self.x.shape[1]
n = self.x.shape[0]
x_ = zeros(n,m)
for i in range(m):
x_[:,i] = poly_cells.poly_center(self.P_list[i])
x = np.asarray(self.x)
x_ = np.asarray(x_)
plt.figure(1)
plt.clf()
plt.plot(x[0],x[1],'.')
plt.plot(x_[0],x_[1],'o',markersize = 20,fillstyle = 'none')
plt.title('poly_center')
plt.savefig('./fig/Voronoi_poly_center.png')
def test():
n = 5
m = 10
q = 100
x = randn(n,q)
y = zeros(m,q)
while True:
A,r = sprandn(m,n,0.1)
if r < m*n:
break
for i in range(q):
y[:,i] = A * x[:,i]
print(min_complexity_model(x,y,1))
print('\nA_data = \n' + str(sparse(A))+'\n')
def test():
N = 1_000
m = 3
n = 3
A = np.asmatrix(np.random.rand(m,n))
b = np.asmatrix(np.random.rand(m,1))
W = np.matrix(np.random.randn(m,m))
# ----------------------------------------------------------------------
A_=[]
b_=[]
x_=[]
for i in range(N):
A_rand = np.matrix(np.random.randn(m,n))
b_rand = np.matrix(np.random.randn(m,1))
x_rand = np.matrix(np.random.randn(n,1))
A_.append(A_rand)
b_.append(b_rand)
x_.append(x_rand)
# ----------------------------------------------------------------------
EA = zeros(m,n)
Ex = zeros(n,1)
Eb = zeros(m,1)
EAx = zeros(m,1)
EAoA = zeros(m*m,n*n)
EAox = zeros(m*n,n*1)
EAoAx = zeros(m*m,n*1)
EAob = zeros(m*m,n*1)
for i in range(N):
EA += A_[i]
Ex += x_[i]
Eb += b_[i]
EAx += A_[i]*x_[i]
EAoA += np.kron(A_[i],A_[i])
EAox += np.kron(A_[i],x_[i])
EAoAx += np.kron(A_[i],A_[i]*x_[i])
EAob += np.kron(A_[i],b_[i])
EA /= N
Ex /= N
Eb /= N
EAx /= N
EAoA /= N
EAox /= N
EAoAx /= N
EAob /= N
problem = E_l_2(A,b, EA, Ex, Eb, EAx, EAoA, EAox, EAoAx, EAob, W)
print(problem)
print(problem.solve())
def __init__(self, P1, P2, q):
n = P1.n
assert P2.n is n
A = np.bmat([[eye(n),-eye(n)]])
b = zeros(n,1)
P = poly.diag(P1,P2)
if q is 1:
self.problem = norm.linear_l_1(A,b,P)
elif q is 2:
self.problem = norm.linear_l_2(A,b,P)
elif q is 'inf':
self.problem = norm.linear_l_inf(A,b,P)
else:
assert False, "q must be 1, 2, or \'inf\'"
self.P1 = P1
self.P2 = P2
self.P = P
self.n = n
self.q = q
self.sol = None
def init_E(EA, Ex, Eb, EAx, EAoA, EAox, EAoAx, EAob, W, m ,n):
if W is None:
M = eye(m)
else:
M = W.T * W
if EA is None:
EA = zeros(m,n)
if Ex is None:
Ex = zeros(n,1)
if Eb is None:
Eb = zeros(m,1)
if EAx is None:
EAx = zeros(m,1)
if EAoA is None:
EAoA = zeros(m*m,n*n)
if EAox is None:
EAox = zeros(m*n,n*1)
if EAoAx is None:
EAoAx = zeros(m*m,n*1)
if EAob is None:
EAob = zeros(m*m,n*1)
return (EA, Ex, Eb, EAx, EAoA, EAox, EAoAx, EAob, M)
def __init__(self, x_pos, x_neg, p='inf', λ=1):
"""
x_pos ∈ R^{n,m_pos}
x_neg ∈ R^{n,m_neg}
"""
n = x_pos.shape[0]
m_pos = x_pos.shape[1]
m_neg = x_neg.shape[1]
assert x_neg.shape[0] is n
if p is 1:
Q = None
c = np.bmat([[zeros(n + 1)], [λ * ones(m_pos + m_neg)], [ones(n)]])
A_ub = np.bmat([\
[ -x_pos.T, ones(m_pos), -eye(m_pos), zeros(m_pos,m_neg), zeros(m_pos,n) ],\
[ x_neg.T, -ones(m_neg), zeros(m_neg,m_pos), -eye(m_neg), zeros(m_neg,n) ],\
[ -eye(n), zeros(n), zeros(n,m_pos), zeros(n,m_neg), -eye(n) ],\
[ eye(n), zeros(n), zeros(n,m_pos), zeros(n,m_neg), -eye(n) ],\
[ zeros(m_pos,n), zeros(m_pos), -eye(m_pos), zeros(m_pos,m_neg), zeros(m_pos,n) ],\
[ zeros(m_neg,n), zeros(m_neg), zeros(m_neg,m_pos), -eye(m_neg), zeros(m_neg,n) ]])
b_ub = np.bmat([\
[ -ones(m_pos) ],\
[ -ones(m_neg) ],\
[ zeros(n) ],\
[ zeros(n) ],\
[ zeros(m_pos) ],\
[ zeros(m_neg) ]])
P = poly(A_ub, b_ub)
sol = QP(Q, c, P).solve()
self.a = sol[0:n, 0]
self.b = sol[n, 0]
if p is 2:
Q = zeros(n + 1 + m_pos + m_neg, n + 1 + m_pos + m_neg)
Q[0:n, 0:n] = 2 * eye(n)
c = zeros(n + 1 + m_pos + m_neg, 1)
c[(n + 1 + 1 - 1):(n + 1 + m_pos +
m_neg)] = λ * ones(m_pos + m_neg, 1)
A_ub = np.bmat([\
[ -x_pos.T, ones(m_pos), -eye(m_pos), zeros(m_pos,m_neg) ],\
[ x_neg.T, -ones(m_neg), zeros(m_neg,m_pos), -eye(m_neg) ],\
[ zeros(m_pos,n), zeros(m_pos), -eye(m_pos), zeros(m_pos,m_neg) ],\
[ zeros(m_neg,n), zeros(m_neg), zeros(m_neg,m_pos), -eye(m_neg) ]])
b_ub = np.bmat([\
[ -ones(m_pos) ],\
[ -ones(m_neg) ],\
[ zeros(m_pos) ],\
[ zeros(m_neg) ]\
])
P = poly(A_ub, b_ub)
sol = QP(Q, c, P).solve()
self.a = sol[0:n, 0]
self.b = sol[n, 0]
if p is 'inf':
Q = None
c = np.bmat([[zeros(n + 1)], [λ * ones(m_pos + m_neg)], [ones(1)]])
A_ub = np.bmat([\
[ -x_pos.T, ones(m_pos), -eye(m_pos), zeros(m_pos,m_neg), zeros(m_pos) ],\
[ x_neg.T, -ones(m_neg), zeros(m_neg,m_pos), -eye(m_neg), zeros(m_neg) ],\
[ -eye(n), zeros(n), zeros(n,m_pos), zeros(n,m_neg), -ones(n) ],\
[ eye(n), zeros(n), zeros(n,m_pos), zeros(n,m_neg), -ones(n) ],\
[ zeros(m_pos,n), zeros(m_pos), -eye(m_pos), zeros(m_pos,m_neg), zeros(m_pos) ],\
[ zeros(m_neg,n), zeros(m_neg), zeros(m_neg,m_pos), -eye(m_neg), zeros(m_neg) ]])
b_ub = np.bmat([\
[ -ones(m_pos) ],\
[ -ones(m_neg) ],\
[ zeros(n) ],\
[ zeros(n) ],\
[ zeros(m_pos) ],\
[ zeros(m_neg) ]])
P = poly(A_ub, b_ub)
sol = QP(Q, c, P).solve()
self.a = sol[0:n, 0]
self.b = sol[n, 0]
def s(self, x):
n = len(x)
y = zeros(n, 1)
for i in range(n):
y[i] = self.sigmoid.s(x[i])
return np.matrix(y)
