def compute(self, X, y):
XC = asColumnMatrix(X)
y = np.asarray(y)
n = len(y)
c = len(np.unique(y))
pca = PCA(num_components=(n-c))
lda = LDA(num_components=self._num_components)
model = ChainOperator(pca, lda)
model.compute(X, y)
self._eigenvalues = lda.eigenvalues
self._num_components = lda.num_components
self._eigenvectors = np.dot(pca.eigenvectors, lda.eigenvectors)
features = []
for x in X:
xp = self.project(x.reshape(-1, 1))
features.append(xp)
return features
def compute(self, X, y):
XC = asColumnMatrix(X)
y = np.asarray(y)
if self._num_components <= 0 or (self._num_components > XC.shape[1]-1):
self._num_components = XC.shape[1]-1
self._mean = XC.mean(axis=1).reshape(-1,1)
XC = XC - self._mean
n_features = XC.shape[0]
self._kpca = KernelPCA(n_components=self._num_components,
kernel=self._kernel,
degree=self._degree,
coef0=self._coef0,
gamma=self._gamma)
self._kpca.fit(XC.T)
features = []
for x in X:
features.append(self.extract(x))
return features
def compute(self, X, y):
XC = asColumnMatrix(X)
self._mean = XC.mean()
self._std = XC.std()
Xp = []
for xi in X:
Xp.append(self.extract(xi))
return Xp
def compute(self, X, y):
Xp = []
XC = asColumnMatrix(X)
self._min = np.min(XC)
self._max = np.max(XC)
for xi in X:
Xp.append(self.extract(xi))
return Xp
def compute(self, X, y):
XC = asColumnMatrix(X)
y = np.asarray(y)
d = XC.shape[0]
c = len(np.unique(y))
if self._num_components <= 0:
self._num_components = c - 1
elif self._num_components > (c - 1):
self._num_components = c - 1
mean_total = XC.mean(axis=1).reshape(-1, 1)
Sw = np.zeros((d, d), dtype=np.float32)
Sb = np.zeros((d, d), dtype=np.float32)
for i in range(0, c):
Xi = XC[:, np.where(y==i)[0]]
mean_class = np.mean(Xi, axis=1).reshape(-1, 1)
Sw = Sw + np.dot((Xi - mean_class), (Xi - mean_class).T)
Sb = Sb + Xi.shape[1] * np.dot((mean_class - mean_total), (mean_class - mean_total).T)
self._eigenvalues, self._eigenvectors = np.linalg.eig(np.linalg.inv(Sw) * Sb)
idx = np.argsort(-self._eigenvalues.real)
self._eigenvalues, self._eigenvectors = self._eigenvalues[idx], self._eigenvectors[:, idx]
self._eigenvalues = np.array(self._eigenvalues[0:self._num_components].real, dtype=np.float32, copy=True)
self._eigenvectors = np.matrix(self._eigenvectors[0:, 0:self._num_components].real, dtype=np.float32, copy=True)
features = []
for x in X:
xp = self.project(x.reshape(-1, 1))
features.append(xp)
return features
def compute(self, X, y):
XC = asColumnMatrix(X)
y = np.asarray(y)
if self._num_components <= 0 or (self._num_components > XC.shape[1] - 1):
self._num_components = XC.shape[1] - 1
self._mean = XC.mean(axis=1).reshape(-1, 1)
XC = XC - self._mean
self._eigenvectors, self._eigenvalues, variances = np.linalg.svd(XC, full_matrices=False)
self._eigenvalues = np.power(self._eigenvalues, 2) / XC.shape[1]
self._total_energy = np.sum(self._eigenvalues)
idx = np.argsort(-self._eigenvalues)
self._eigenvalues, self._eigenvectors = self._eigenvalues[idx], self._eigenvectors[:, idx]
self._eigenvectors = self._eigenvectors[:, :self._num_components].copy()
self._eigenvalues = self._eigenvalues[:self._num_components].copy()
features = []
for x in X:
xp = self.project(x.reshape(-1, 1))
features.append(xp)
return features