def sci(z, n_class_atoms, reg='l0'): """ the sparsity concentration index of a coefficient vector z for a given regularizer """ n_classes = len(n_class_atoms) if reg == 'l0': norm_const = z.nonzero()[0].size nom = np.max([z[get_class_atoms(c, n_class_atoms)].nonzero()[0].size for c in range(n_classes)]) elif reg == 'l1': nom = np.max([np.sum(np.abs(z[get_class_atoms(c, n_class_atoms)])) for c in range(n_classes)]) norm_const = np.sum(np.abs(z)) sci_index = (n_classes * (nom / norm_const) - 1) / float(n_classes - 1) return sci_index
def local_sparse_predict(X, D, sparse_coder, n_class_atoms): n_samples = X.shape[1] n_classes = len(n_class_atoms) n_total_atoms = np.sum(n_class_atoms) # sparsely encode each datapoint over each class specific dictionary Z = np.zeros((n_total_atoms, n_samples)) for c in range(n_classes): c_idx = get_class_atoms(c, n_class_atoms) Zc = sparse_coder(X, D[:, c_idx]) Z[c_idx, :] = Zc predictions = [] for i in xrange(n_samples): sp = np.zeros((n_classes)).astype(int) for c in range(n_classes): c_idx = get_class_atoms(c, D, n_class_atoms) sp[c] = Z[c_idx, i].nonzero()[0].size pred = np.argmin(sp) predictions.append(pred) return predictions
def local_error(X, D, n_class_atoms, sparse_coder): """ computes the approximation error of the dataset to each class-specific dictionary. Each datapoint is first encoded over the each dictionary seperately. """ n_samples = X.shape[1] n_classes = len(n_class_atoms) E = np.zeros((n_classes, n_samples)) for c in range(n_classes): c_idx = get_class_atoms(c, n_class_atoms) Dc = D[:, c_idx] Zc = sparse_coder(X, Dc) E[c, :] = approx_error(Dc, Zc, X) return E
def global_sparse_predict(X, D, sparse_coder, n_class_atoms): """ works in the same way as 'global_error_predict' but we classify according to the sparsest solution """ Z = sparse_coder(X, D) n_samples = X.shape[1] n_classes = len(n_class_atoms) predictions = [] for i in xrange(n_samples): sp = np.zeros((n_classes)).astype(int) for c in range(n_classes): c_idx = get_class_atoms(c, n_class_atoms) sp[c] = Z[c_idx, i].nonzero()[0].size pred = np.argmin(sp) predictions.append(pred) return predictions
def global_error(X, D, sparse_coder, n_class_atoms, n_jobs=1): """ computes the approximation error of the dataset to each class-specific dictionary. The dataset is first encoded over the joint dictionary. """ Z = sparse_coder(X, D) n_samples = X.shape[1] n_classes = len(n_class_atoms) E = np.zeros((n_classes, n_samples)) if n_jobs > 1: set_openblas_threads(n_jobs) for c in range(n_classes): c_idx = get_class_atoms(c, n_class_atoms) E[c, :] = np.sum(np.power(fast_dot(D[:, c_idx], Z[c_idx, :]) - X, 2), axis=0) if n_jobs > 1: set_openblas_threads(1) return E
def test_get_class_atoms(self): n_class_atoms = [2, 3, 5] cl = 1 self.assertEqual(get_class_atoms(cl, n_class_atoms=n_class_atoms), [2, 3, 4])