def interior_point(X, y, lam):
"""
solve lasso using an interior point method
requires cvxmod (Jacob Mattingley and Stephen Boyd)
http://cvxmod.net/
"""
import cvxmod as cvx
n, m = X.shape
X_cvx = cvx.matrix(np.array(X))
y_cvx = cvx.matrix(np.array(y))
theta = cvx.optvar('theta', m)
p = cvx.problem(cvx.minimize(cvx.sum(cvx.atoms.power(X_cvx*theta - y_cvx, 2)) +
(2*lam)*cvx.norm1(theta)))
p.solve()
return np.array(cvx.value(theta))
def compute_combinaison_safe(self,target,rcond = 0.0,regul = None):
"""
Computes the combination of base targets allowing to reproduce
'target' (or giving the best approximation), while keeping
coefficients between 0 and 1.
arguments :
- target : target to fit
- rcond : cut off on the singular values as a fraction of
the biggest one. Only base vectors corresponding
to singular values bigger than rcond*largest_singular_value
- regul : regularisation factor for least square fitting. This force
the algorithm to use fewer targets.
"""
from cvxmod import optvar,param,norm2,norm1,problem,matrix,minimize
if type(target) is str or type(target) is unicode :
target = read_target(target)
cond = self.s>= rcond*self.s[0]
u = self.u[ : , cond ]
vt = self.vt[ cond ]
s = self.s[cond]
t = target.flatten()
dim,ntargets = self.vt.shape
nvert = target.shape[0]
pt = np.dot(u.T,t.reshape(nvert*3,1))
A = param('A',value = matrix(s.reshape(dim,1)*vt))
b = param('b',value = matrix(pt))
x = optvar('x',ntargets)
if regul is None : prob = problem(minimize(norm2(A*x-b)),[x>=0.,x<=1.])
else : prob = problem(minimize(norm2(A*x-b) + regul * norm1(x)),[x>=0.,x<=1.])
prob.solve()
bs = np.array(x.value).flatten()
# Body setting files have a precision of at most 1.e-3
return bs*(bs>=1e-3)
def reconstruct_target(target_file,base_prefix,regul = None):
"""
Reconstruct the target in 'target_file' using constrained,
and optionally regularized, least square optimisation.
arguments :
target_file : file contaiing the target to fit
base_prefix : prefix for the files of the base.
"""
vlist = read_vertex_list(base_prefix+'_vertices.dat')
t = read_target(target_file,vlist)
U = load(base_prefix+"_U.npy").astype('float')
S = load(base_prefix+"_S.npy").astype('float')
V = load(base_prefix+"_V.npy").astype('float')
ntargets,dim = V.shape
nvert = len(t)
pt = dot(U.T,t.reshape(nvert*3,1))
pbase = S[:dim].reshape(dim,1)*V.T
A = param('A',value = matrix(pbase))
b = param('b',value = matrix(pt))
x = optvar('x',ntargets)
if regul is None : prob = problem(minimize(norm2(A*x-b)),[x>=0.,x<=1.])
else : prob = problem(minimize(norm2(A*x-b) + regul * norm1(x)),[x>=0.,x<=1.])
prob.solve()
targ_names_file = base_prefix+"_names.txt"
with open(targ_names_file) as f :
tnames = [line.strip() for line in f.readlines() ]
tnames.sort()
base,ext = os.path.splitext(target_file)
bs_name = base+".bs"
with open(bs_name,"w") as f :
for tn,v in zip(tnames,x.value):
if v >= 1e-3 : f.write("%s %0.3f\n"%(tn,v))
def reconstruct_target(target_file,base_prefix,regul = None):
"""
Reconstruct the target in 'target_file' using constrained,
and optionally regularized, least square optimisation.
arguments :
target_file : file contaiing the target to fit
base_prefix : prefix for the files of the base.
"""
vlist = read_vertex_list(base_prefix+'_vertices.dat')
t = read_target(target_file,vlist)
U = load(base_prefix+"_U.npy").astype('float')
S = load(base_prefix+"_S.npy").astype('float')
V = load(base_prefix+"_V.npy").astype('float')
ntargets,dim = V.shape
nvert = len(t)
pt = dot(U.T,t.reshape(nvert*3,1))
pbase = S[:dim].reshape(dim,1)*V.T
A = param('A',value = matrix(pbase))
b = param('b',value = matrix(pt))
x = optvar('x',ntargets)
if regul is None : prob = problem(minimize(norm2(A*x-b)),[x>=0.,x<=1.])
else : prob = problem(minimize(norm2(A*x-b) + regul * norm1(x)),[x>=0.,x<=1.])
prob.solve()
targ_names_file = base_prefix+"_names.txt"
with open(targ_names_file) as f :
tnames = [line.strip() for line in f.readlines() ]
tnames.sort()
base,ext = os.path.splitext(target_file)
bs_name = base+".bs"
with open(bs_name,"w") as f :
for tn,v in zip(tnames,x.value):
if v >= 1e-3 : f.write("%s %0.3f\n"%(tn,v))
def fit_ellipse_stack_abs(dx, dy, dz, di):
"""
fit ellipoid using squared loss
idea to learn all stacks together including smoothness
"""
# sanity check
assert len(dx) == len(dy)
assert len(dx) == len(dz)
assert len(dx) == len(di)
# unique zs
dat = defaultdict(list)
# resort data
for idx in range(len(dx)):
dat[dz[idx]].append( [dx[idx], dy[idx], di[idx]] )
# init ret
ellipse_stack = []
for idx in range(max(dz)):
ellipse_stack.append(Ellipse(0, 0, idx, 1, 1, 0))
total_N = len(dx)
M = len(dat.keys())
D = 5
X_matrix = []
thetas = []
slacks = []
eps_slacks = []
mean_di = float(numpy.mean(di))
for z in dat.keys():
x = numpy.array(dat[z])[:,0]
y = numpy.array(dat[z])[:,1]
# intensities
i = numpy.array(dat[z])[:,2]
# log intensities
i = numpy.log(i)
# create matrix
ity = numpy.diag(i)# / mean_di
# dimensionality
N = len(x)
d = numpy.zeros((N, D))
d[:,0] = x*x
d[:,1] = y*y
#d[:,2] = x*y
d[:,2] = x
d[:,3] = y
d[:,4] = numpy.ones(N)
#d[:,0] = x*x
#d[:,1] = y*y
#d[:,2] = x*y
#d[:,3] = x
#d[:,4] = y
#d[:,5] = numpy.ones(N)
print "old", d
# consider intensities
old_shape = d.shape
d = numpy.dot(ity, d)
print "new", d
assert d.shape == old_shape
print d.shape
d = cvxmod.matrix(d)
#### parameters
# da
X = cvxmod.param("X" + str(z), N, D)
X.value = d
X_matrix.append(X)
#### varibales
# parameter vector
theta = cvxmod.optvar("theta" + str(z), D)
thetas.append(theta)
# construct obj
objective = 0
# loss term
for i in xrange(M):
objective += cvxmod.atoms.norm1(X_matrix[i] * thetas[i])
# add smoothness regularization
reg_const = 5 * float(total_N) / float(M-1)
for i in xrange(M-1):
objective += reg_const * cvxmod.norm1(thetas[i] - thetas[i+1])
# create problem
prob = cvxmod.problem(cvxmod.minimize(objective))
# add constraints
"""
for (i,X) in enumerate(X_matrix):
p.constr.append(X*thetas[i] <= slacks[i])
p.constr.append(-X*thetas[i] <= slacks[i])
#eps = 0.5
#p.constr.append(slacks[i] - eps <= eps_slacks[i])
#p.constr.append(0 <= eps_slacks[i])
"""
# add non-degeneracy constraints
for i in xrange(1, M-1):
prob.constr.append(thetas[i][0] + thetas[i][1] == 1.0) # A + C = 1
# pinch ends
prob.constr.append(cvxmod.sum(thetas[0]) >= -0.01)
prob.constr.append(cvxmod.sum(thetas[-1]) >= -0.01)
print prob
###### set values
from cvxopt import solvers
solvers.options['reltol'] = 1e-1
solvers.options['abstol'] = 1e-1
print solvers.options
prob.solve()
# wrap up result
ellipse_stack = {}
active_layers = dat.keys()
assert len(active_layers) == M
# reconstruct original parameterization
for i in xrange(M):
theta_ = numpy.array(cvxmod.value(thetas[i]))
z_layer = active_layers[i]
ellipse_stack[z_layer] = conic_to_ellipse(theta_)
ellipse_stack[z_layer].cz = z_layer
return ellipse_stack