def _updateD(self):
Yhat = np.zeros_like(self.Y)
DCp1 = self._getDc(self.nclass)
for c in range(self.nclass):
Dc_range = range(self.D_range_ext[c], self.D_range_ext[c + 1])
Yc_range = range(self.Y_range[c], self.Y_range[c + 1])
Yc = self._getYc(c)
Dc = self._getDc(c)
Xc = utils.get_block_col(self.X, c, self.Y_range)
Xcc = utils.get_block_row(Xc, c, self.D_range_ext)
XCp1c = utils.get_block_row(Xc, self.nclass, self.D_range_ext)
Ychat = Yc - np.dot(self.D, Xc) + np.dot(Dc, Xcc)
Ycbar = Yc - np.dot(DCp1, XCp1c)
E = np.dot(Ychat + Ycbar, Xcc.T)
F = 2 * np.dot(Xcc, Xcc.T)
A = self.D.copy()
A = np.delete(A, Dc_range, axis=1)
self.D[:,
Dc_range] = optimize.DLSI_updateD(Dc, E, F, A.T, self.eta)
Yhat[:, Yc_range] = Yc - np.dot(self.D[:, Dc_range], Xcc)
## DCp1
XCp1 = utils.get_block_row(self.X, self.nclass, self.D_range_ext)
Ybar = self.Y - np.dot(self.D[:, : self.D_range_ext[-2]], \
self.X[: self.D_range_ext[-2], :])
E = np.dot(Ybar + Yhat, XCp1.T)
F = 2 * np.dot(XCp1, XCp1.T)
A = self.D[:, :self.D_range_ext[-2]]
DCp1_range = range(self.D_range_ext[-2], self.D_range_ext[-1])
self.D[:, DCp1_range] = optimize.DLSI_updateD(self.D[:, DCp1_range], E,
F, A.T, self.eta)
def loss(self):
"""
cost = COPAR_cost(Y, Y_range, D, D_range_ext, X, opts):
Calculating cost function of COPAR with parameters lambda and eta are
stored in `opts.lambda` and `opts.rho`.
`f(D, X) = 0.5*sum_{c=1}^C 05*||Y - DX||_F^2 +
sum_{c=1}^C ( ||Y_c - D_Cp1 X^Cp1_c - D_c X_c^c||F^2 +
sum_{i != c}||X^i_c||_F^2) + lambda*||X||_1 +
0.5*eta*sum_{i \neq c}||Di^T*Dc||_F^2`
-----------------------------------------------
Author: Tiep Vu, [email protected], 5/11/2016
(http://www.personal.psu.edu/thv102/)
-----------------------------------------------
"""
cost = self.lambd * utils.norm1(self.X)
cost1 = utils.normF2(self.Y - np.dot(self.D, self.X))
DCp1 = self._getDc(self.nclass)
for c in range(self.nclass):
Dc = self._getDc(c)
Yc = self._getYc(c)
Xc = utils.get_block_col(self.X, c, self.Y_range)
Xcc = utils.get_block_row(Xc, c, self.D_range_ext)
XCp1c = utils.get_block_row(Xc, self.nclass, self.D_range_ext)
cost1 += utils.normF2(Yc - np.dot(Dc, Xcc) - np.dot(DCp1, XCp1c))
XX = Xc[:self.D_range_ext[-2], :]
XX = np.delete(XX,
range(self.D_range_ext[c], self.D_range_ext[c + 1]),
axis=0)
cost1 += utils.normF2(XX)
cost += cost1 + .5*self.eta*utils.normF2(\
utils.erase_diagonal_blocks(np.dot(self.D.T, self.D), \
self.D_range_ext, self.D_range_ext))
return cost
def _calc_f(self, Xc):
"""
optimize later
"""
Xcc = utils.get_block_row(Xc, self.c, self.D_range_ext)
XCp1c = utils.get_block_row(Xc, self.nclass, self.D_range_ext)
cost = utils.normF2(self.Yc - np.dot(self.D, Xc))
# pdb.set_trace()
cost += utils.normF2(self.Yc - np.dot(self.Dc, Xcc) -\
np.dot(self.DCp1, XCp1c))
for i in range(self.nclass):
if i != self.c:
Xic = utils.get_block_row(Xc, i, self.D_range_ext)
cost += utils.normF2(Xic)
return .5 * cost
def _grad(self, Xc0):
Xc = Xc0.copy()
c = self.c
g0 = np.dot(self.DtD, Xc)
Xcc = utils.get_block_row(Xc, self.c, self.D_range_ext)
XCp1c = utils.get_block_row(Xc, self.nclass, self.D_range_ext)
if self.k0 > 0:
Xc[self.D_range_ext[c]: self.D_range_ext[c+1], :] = \
np.dot(self.DctDc, Xcc) + np.dot(self.DCp1tDc.T, XCp1c)
Xc[self.D_range_ext[-2]: self.D_range_ext[-1], :] = \
np.dot(self.DCp1tDCp1, XCp1c) + np.dot(self.DCp1tDc, Xcc)
else:
Xc[self.D_range_ext[c]:self.D_range_ext[c + 1], :] = np.dot(
self.DctDc, Xcc)
return g0 + Xc - self.DtYc2
def predict(self, Y, verbose = True, iterations = 100):
lasso = Lasso(self.D, self.lamb)
lasso.fit(Y, iterations = iterations)
X = lasso.coef_
E = np.zeros((self.C, Y.shape[1]))
for i in range(self.C):
Xi = utils.get_block_row(X, i, self.train_range)
Di = utils.get_block_col(self.D, i, self.train_range)
R = Y - np.dot(Di, Xi)
E[i,:] = (R*R).sum(axis = 0)
return utils.vec(np.argmin(E, axis = 0) + 1)
def _fidelity(self, X):
"""
* Calculating the fidelity term in FDDL[[4]](#fn_fdd):
* $\sum_{c=1}^C \Big(\|Y_c - D_cX^c_c\|_F^2 +
\sum_{i \neq c} \|D_c X^c_i\|_F^2\Big)$
"""
cost = 0
Y = self.Y
for c in xrange(self.nclass):
Yc = get_block_col(Y, c, self.Y_range)
Dc = get_block_col(self.D, c, self.D_range)
Xc = get_block_row(X, c, self.D_range)
Xcc = get_block_col(Xc, c, self.Y_range)
cost += normF2(Yc - np.dot(Dc, Xcc))
for i in xrange(self.nclass):
if i == c:
continue
Xci = get_block_col(Xc, i, self.Y_range)
cost += normF2(np.dot(Dc, Xci))
return cost