def __calculate_firstn_features(self, X, y, S, model1_limit): f1 = self.model1.compute(X, y) f2 = self.model2.compute(X,y) SX = np.asarray(S).reshape(1,-1) corr1 = [] corr2 = [] for feature in asColumnMatrix(f1): if abs(np.linalg.norm(feature))<1e-12: corr1.append(1) else: corr1.append(-abs(1-self.operator(feature, SX))) for feature in asColumnMatrix(f2): if abs(np.linalg.norm(feature))<1e-12: corr2.append(1) else: corr2.append(-abs(1-self.operator(feature, SX))) if model1_limit==None: corr1.extend(corr2) self.idx = np.argsort(corr1) else: idx1 = np.argsort(corr1) idx2 = np.argsort(corr2) if model1_limit>len(idx1): model1_limit = len(idx1) idx2 = idx2+len(idx1) p1 = idx1[:model1_limit] p2 = idx2[:self.nm-model1_limit] p3 = idx1[model1_limit:] p4 = idx2[len(p2):] self.idx = np.hstack((p1,p2)) self.idx = np.hstack((self.idx,p3)) self.idx = np.hstack((self.idx, p4))
def compute(self,X,y): # build the column matrix XC = asColumnMatrix(X) y = np.asarray(y) # set a valid number of components if self._num_components <= 0 or (self._num_components > XC.shape[1]-1): self._num_components = XC.shape[1]-1 # center dataset self._mean = XC.mean(axis=1).reshape(-1,1) XC = XC - self._mean # perform an economy size decomposition (may still allocate too much memory for computation) self._eigenvectors, self._eigenvalues, variances = np.linalg.svd(XC, full_matrices=False) # sort eigenvectors by eigenvalues in descending order idx = np.argsort(-self._eigenvalues) self._eigenvalues, self._eigenvectors = self._eigenvalues[idx], self._eigenvectors[:,idx] # use only num_components self._eigenvectors = self._eigenvectors[0:,0:self._num_components].copy() self._eigenvalues = self._eigenvalues[0:self._num_components].copy() # finally turn singular values into eigenvalues self._eigenvalues = np.power(self._eigenvalues,2) / XC.shape[1] # get the features from the given data features = [] for x in X: xp = self.project(x.reshape(-1,1)) features.append(xp) return features
def compute(self, X, y): # turn into numpy representation Xc = asColumnMatrix(X) y = np.asarray(y) # gather some statistics about the dataset n = len(y) c = len(np.unique(y)) # define features to be extracted pca = PCA(num_components = (n-c)) lda = LDA(num_components = self._num_components) # fisherfaces are a chained feature of PCA followed by LDA model = ChainOperator(pca,lda) # computing the chained model then calculates both decompositions model.compute(X,y) # store eigenvalues and number of components used self._eigenvalues = lda.eigenvalues self._num_components = lda.num_components # compute the new eigenspace as pca.eigenvectors*lda.eigenvectors self._eigenvectors = np.dot(pca.eigenvectors,lda.eigenvectors) # finally compute the features (these are the Fisherfaces) features = [] for x in X: xp = self.project(x.reshape(-1,1)) features.append(xp) return features
def compute(self, X, y): # build the column matrix XC = asColumnMatrix(X) y = np.asarray(y) # set a valid number of components if self._num_components <= 0 or (self._num_components > XC.shape[1] - 1): self._num_components = XC.shape[1] - 1 # center dataset self._mean = XC.mean(axis=1).reshape(-1, 1) XC = XC - self._mean # perform an economy size decomposition (may still allocate too much memory for computation) self._eigenvectors, self._eigenvalues, variances = np.linalg.svd( XC, full_matrices=False) # sort eigenvectors by eigenvalues in descending order idx = np.argsort(-self._eigenvalues) self._eigenvalues, self._eigenvectors = self._eigenvalues[ idx], self._eigenvectors[:, idx] # use only num_components self._eigenvectors = self._eigenvectors[0:, 0:self._num_components].copy() self._eigenvalues = self._eigenvalues[0:self._num_components].copy() # finally turn singular values into eigenvalues self._eigenvalues = np.power(self._eigenvalues, 2) / XC.shape[1] # get the features from the given data features = [] for x in X: xp = self.project(x.reshape(-1, 1)) features.append(xp) return features
def compute(self, X, y): # turn into numpy representation Xc = asColumnMatrix(X) y = np.asarray(y) # gather some statistics about the dataset n = len(y) c = len(np.unique(y)) # define features to be extracted pca = PCA(num_components=(n - c)) lda = LDA(num_components=self._num_components) # fisherfaces are a chained feature of PCA followed by LDA model = ChainOperator(pca, lda) # computing the chained model then calculates both decompositions model.compute(X, y) # store eigenvalues and number of components used self._eigenvalues = lda.eigenvalues self._num_components = lda.num_components # compute the new eigenspace as pca.eigenvectors*lda.eigenvectors self._eigenvectors = np.dot(pca.eigenvectors, lda.eigenvectors) # finally compute the features (these are the Fisherfaces) features = [] for x in X: xp = self.project(x.reshape(-1, 1)) features.append(xp) return features
def compute(self, X, y): X = asColumnMatrix(X); y = np.asarray(y); n = len(y) c = len(np.unique(y)) # set a valid number of components if self._num_components <= 0: self._num_components = c elif self._num_components > n: self._num_components = n # compute the weight matrix and Laplacian matrix S = spatial.distance.pdist(X.T, 'sqeuclidean'); S = np.exp(-S/(self._weight*max(S))); S = spatial.distance.squareform(S); S[S < 0.0001] = 0; D = np.diag(S.sum(axis=0)); L = D - S; # calculate the eigenvectors eigenvalues, eigenvectors = linalg.eig(X.dot(L.dot(X.T)), X.dot(D.dot(X.T))); # sort eigenvectors by their eigenvalue in descending order idx = np.argsort(eigenvalues.real) eigenvalues, eigenvectors = eigenvalues[idx], eigenvectors[:,idx] # use only num_components self._eigenvectors = np.matrix(eigenvectors[:, 0:self._num_components].real, dtype=np.float32, copy=True) self._eigenvalues = np.array(eigenvalues[0:self._num_components].real, dtype=np.float32, copy=True) # get the features from the given data features = [] X = self._eigenvectors.T.dot(X); for x in X.T: features.append(x.T); return features;
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) self._mean = XC.mean() self._std = XC.std() Xp = [] for xi in X: Xp.append(self.extract(xi)) return Xp
def __init__(self, XSN): if XSN is None: raise ValueError("XSN cannot be None") # Reshape into a column matrix: XSN = asColumnMatrix(XSN) self.meanXSN = np.mean(XSN, axis=1) Sw = np.cov(XSN.T) w, v = np.linalg.eigh(Sw) idx = np.argsort(-w) w = w[idx] # Take the largest eigenvalue: maxeig = w[0] Sw = Sw + 0.1 * np.eye(Sw.shape[0]) * maxeig self.iSw = np.inv(Sw) self.sizeXSN = XSN.shape[1]
def compute(self, X, y): XC = asColumnMatrix(X) y = np.asarray(y) #calculate dimensions d = XC.shape[0] c = len(np.unique(y)) yset = set(y) if self._num_components <= 0: self._num_components = c - 1 elif self._num_components > (c - 1): self._num_components = c - 1 meanTotal = XC.mean(axis=1).reshape(-1, 1) #calculate the within and between scatter matrices" Sw = np.zeros((d, d), dtype=np.float32) Sb = np.zeros((d, d), dtype=np.float32) ysetlist = list(yset) for i in range(0, c): label = ysetlist[i] #grab entries from X for a given label Xi = XC[:, np.where(y == label)[0]] meanClass = np.mean(Xi, axis=1).reshape(-1, 1) Sw = Sw + np.dot((Xi - meanClass), (Xi - meanClass).T) Sb = Sb + Xi.shape[1] * np.dot((meanClass - meanTotal), (meanClass - meanTotal).T) #solve eigenvalue problem for a general matrix self._eigenvalues, self._eigenvectors = np.linalg.eig( np.linalg.inv(Sw) * Sb) # sort eigenvectors by their eigenvalue in descending order idx = np.argsort(-self._eigenvalues.real) self._eigenvalues, self._eigenvectors = self._eigenvalues[ idx], self._eigenvectors[:, idx] # only store (c-1) non-zero eigenvalues 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) # get the features from the given data features = [] for x in X: xp = self.project(x.reshape(-1, 1)) features.append(xp) return features
def compute(self, X, y): # build the column matrix XC = asColumnMatrix(X) y = np.asarray(y) # calculate dimensions d = XC.shape[0] c = len(np.unique(y)) # set a valid number of components if self._num_components <= 0: self._num_components = c - 1 elif self._num_components > (c - 1): self._num_components = c - 1 # calculate total mean meanTotal = XC.mean(axis=1).reshape(-1, 1) # calculate the within and between scatter matrices 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]] meanClass = np.mean(Xi, axis=1).reshape(-1, 1) Sw = Sw + np.dot((Xi - meanClass), (Xi - meanClass).T) Sb = Sb + Xi.shape[1] * np.dot((meanClass - meanTotal), (meanClass - meanTotal).T) # solve eigenvalue problem for a general matrix self._eigenvalues, self._eigenvectors = np.linalg.eig(np.linalg.inv(Sw) * Sb) # sort eigenvectors by their eigenvalue in descending order idx = np.argsort(-self._eigenvalues.real) self._eigenvalues, self._eigenvectors = self._eigenvalues[idx], self._eigenvectors[:, idx] # only store (c-1) non-zero eigenvalues 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 ) # get the features from the given data features = [] for x in X: xp = self.project(x.reshape(-1, 1)) features.append(xp) return features