├── .gitignore ├── wass_div.png ├── data ├── sg_demo.npz └── mihi_demo.mat ├── dist_align.png ├── README.md ├── src ├── utils.py └── hiwa.py └── HiWA-Demo.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | **/.ipynb_checkpoints 2 | **/__pycache__ -------------------------------------------------------------------------------- /wass_div.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nerdslab/PyHiWA/HEAD/wass_div.png -------------------------------------------------------------------------------- /data/sg_demo.npz: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nerdslab/PyHiWA/HEAD/data/sg_demo.npz -------------------------------------------------------------------------------- /dist_align.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nerdslab/PyHiWA/HEAD/dist_align.png -------------------------------------------------------------------------------- /data/mihi_demo.mat: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/nerdslab/PyHiWA/HEAD/data/mihi_demo.mat -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Hierarchical Wasserstein Alignment (HiWA) 2 | -------------------------------------------- 3 | This repository contains a Python package implementing the algorithm described in this paper: 4 | 5 | John Lee, Max Dabagia, E Dyer, C Rozell: Hierarchical Wasserstein Alignment for Multimodal Distributions, NeurIPS 2019. https://arxiv.org/abs/1906.11768 6 | 7 | ## Overview 8 | ---------- 9 | Optimal transport approaches to distribution alignment attempt to minimize the divergence between two distributions, as quantified by the Wasserstein distance between them. HiWA introduces some further assumptions which make this problem tractable even in the presence of noise and ambiguity, which are unavoidable in real-world datasets. These assumptions are: 10 | 1. Well-defined cluster structure exists in each dataset. 11 | 2. The inter- and intra-cluster structure is consistent between datasets. 12 | HiWA leverages this cluster structure by first determining how best to align the clusters, and then using this information to influence a aligning transformation of the entire dataset to match the target. 13 | 14 | ## Contents 15 | ---------- 16 | The `HiWA` class in this repository is a self-contained implementation of the algorithm. The included Jupyter Notebook is a comprehensive demo with the algorithm applied to both a synthetic dataset and a real-world neuroscience problem on decoding movement intention from neuron firing patterns in the primary motor cortex of a non-human primate. 17 | 18 | ## Dependencies 19 | --------------- 20 | `numpy, scipy, matplotlib, scikit-learn` 21 | 22 | ## Tips 23 | ------- 24 | - The dimensionality reduction technique used to construct the low-dimensional embedding is *critically* important to the algorithm's success. The first thing to check if it is not working is whether the low-dimensional embeddings of the source and target datasets are capturing the same structure, and whether that structure is alignable (i.e. there are no pathological symmetries). 25 | -------------------------------------------------------------------------------- /src/utils.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from scipy.io import loadmat 3 | import matplotlib.pyplot as plt 4 | from scipy.linalg import sqrtm 5 | from scipy.stats import mode 6 | from sklearn.neighbors import NearestNeighbors 7 | from itertools import permutations 8 | from mpl_toolkits.mplot3d import Axes3D 9 | 10 | def load_data(file_name): 11 | mat_dict = loadmat(file_name, appendmat=True) 12 | return np.array(mat_dict['Tte']), np.array(mat_dict['Ttr']), np.array(mat_dict['Xte']), np.array(mat_dict['Xtr']), np.array(mat_dict['Yte']), np.array(mat_dict['Ytr']) 13 | 14 | 15 | def normal(X): 16 | mean_X = np.mean(X, axis=0) 17 | cov_X = np.cov(X, rowvar=False) 18 | X_n = X 19 | #for col in range(X.shape[1]): 20 | # X_n[:, col] = (X_n[:, col] - mean_X[col]) / np.sqrt(cov_X[col, col]) 21 | return np.matmul(X_n - mean_X, np.linalg.inv(sqrtm(cov_X))) 22 | 23 | def remove_const_cols(Y): 24 | return Y[:, ~np.all(Y[1:] == Y[:-1], axis=0)] 25 | 26 | def map_X_3D(X): 27 | return np.column_stack((X[:, 0], X[:, 1], np.linalg.norm(X, axis=1))) 28 | 29 | def LS_oracle(X_test, Y_test): 30 | X_n = X_test 31 | H_inv = X_n.T @ np.linalg.pinv(Y_test).T 32 | return H_inv 33 | 34 | def plot_2d_clusters(X, labels): 35 | for i in np.unique(labels): 36 | plt.plot(X[labels == i, 0], X[labels == i, 1], linestyle='', marker='.', markersize=15) 37 | 38 | 39 | def plot_3d_clusters(X, labels): 40 | for i in np.unique(labels): 41 | plt.scatter(X[id == i, 0], X[id == i, 1], X[id == i, 2], marker='.') 42 | 43 | 44 | def eval_R2(X, Y): 45 | X = normal(X) 46 | Y = normal(Y) 47 | return 1 - np.mean(np.power(Y - X, 2), axis=0).sum() / np.var(Y, axis=0).sum() 48 | 49 | def match_clustered_labels(X, X_labels, Y, Y_labels): 50 | """Find the optimal permutation of labels found by clustering, via 1-nearest neighbors classification accuracy. 51 | 52 | Parameters 53 | ---------- 54 | X : array-like, shape (n_samples_x, n_features) 55 | Dataset of labels to match to. 56 | 57 | X_labels : array-like, shape (n_samples_x, ) 58 | Labels to match to. 59 | 60 | Y : array-like, shape (n_samples_y, n_features) 61 | Dataset of labels to be matched. 62 | 63 | Y_labels : array-like, shape (n_samples_y, ) 64 | Labels to be matched. 65 | 66 | Returns 67 | ---------- 68 | Y_new : New Y labels. 69 | 70 | """ 71 | nbrs = NearestNeighbors() 72 | nbrs.fit(X) 73 | idx = nbrs.kneighbors(Y, n_neighbors=1, return_distance=False).squeeze() 74 | 75 | Y_new = np.zeros(Y_labels.shape, dtype=int) 76 | for i in np.unique(Y_labels): 77 | idc = idx[Y_labels == i] 78 | Y_new[Y_labels == i], _ = mode(X_labels[idc]) 79 | 80 | return Y_new 81 | -------------------------------------------------------------------------------- /src/hiwa.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from sklearn.decomposition import PCA 3 | from scipy.linalg import sqrtm, orth 4 | 5 | def _normal(X): 6 | """Normalize a matrix of observations in rows and variables in columns.""" 7 | return (X - np.mean(X, axis=0)) @ np.linalg.inv(sqrtm(np.cov(X, rowvar=False))) 8 | 9 | 10 | def _closed_form_rotation_solver(m): 11 | """Closed form rotation solver via SVD method.""" 12 | u, _, vh = np.linalg.svd(m) 13 | return u @ vh 14 | 15 | 16 | def _sinkhorn(p, q, X, Y, gamma, maxiter): 17 | """Entropy-Regularized (Sinkhorn) Optimal Transport between distributions""" 18 | x2, y2 = np.sum(np.power(X, 2), axis=0), np.sum(np.power(Y, 2), axis=0) 19 | C = np.tile(y2[np.newaxis, :], (X.shape[1], 1)) + np.tile(x2[:, np.newaxis], (1, Y.shape[1])) - 2 * (X.T @ Y) 20 | K = np.exp(-C / gamma) 21 | b = np.full(q.shape, 1 / len(q)) 22 | for n in range(maxiter): 23 | a = p / (K @ b) 24 | b = q / (K.T @ a) 25 | if np.isnan(a).any(): 26 | raise ArithmeticError('NaN found!') 27 | P = np.diag(a.squeeze()) @ K @ np.diag(b.squeeze()) 28 | return P, np.sum(C * P) 29 | 30 | 31 | def _sinkhorn_clusters(p, q, C, gamma, maxiter): 32 | """Entropy-Regularized (Sinkhorn) Optimal Transport between clusters""" 33 | K = np.exp(-C / gamma) 34 | b = np.ones(q.shape) 35 | for n in range(maxiter): 36 | a = p / (K @ b) 37 | b = q / (K.T @ a) 38 | 39 | P = np.diag(a.squeeze()) @ K @ np.diag(b.squeeze()) 40 | 41 | return P, np.sum(C * P) 42 | 43 | 44 | def _rMSE(X, Rg, Rgt): 45 | """Relative mean square error""" 46 | return np.linalg.norm(Rgt @ X.T - Rg @ X.T, 'fro') ** 2 / np.linalg.norm(Rgt @ X.T, 'fro') ** 2 47 | 48 | 49 | def _eval_R2(X, Rg, Rgt): 50 | """Correlation coefficient""" 51 | X = (Rgt @ X.T).T 52 | Y = (Rg @ X.T).T 53 | return 1 - np.mean(Y - X, axis=0).sum() / np.var(Y, axis=0).sum() 54 | 55 | 56 | class HiWA: 57 | """Hierarchical Wasserstein Alignment (HiWA) 58 | 59 | Applies nested OT between points XX and YY with decreasing entropy 60 | 61 | Parameters 62 | ---------- 63 | dim_red_method : object with a fit_transform() method or None 64 | Method to compute a low-d embedding of the source and target distributions. 65 | Defaults to PCA. 66 | 67 | parallelize : Boolean 68 | Whether to use the multiprocessing module to run ADMM iterations concurrently. 69 | Defaults to True 70 | 71 | normalize : Boolean 72 | Whether to normalize source and target before attempting alignment. 73 | Defaults to True, should be performed to prevent numerical errors. 74 | 75 | maxiter : int or None 76 | Maximum iterations for ADMM 77 | Defaults to 300 78 | 79 | tol : float, double, or None 80 | Stopping criterion for ADMM 81 | The change between rotation matrices on subsequent iterations must be 82 | greater than this (measured as Frobenius norm of the difference) 83 | Defaults to 0.1 84 | 85 | mu : float, double, or None 86 | ADMM parameter 87 | smaller = slower & more accurate, larger = faster & less accurate 88 | Defaults to 0.005 89 | 90 | shorn_maxiter : int or None 91 | Maximum iterations for Sinkhorn OT between clusters 92 | Defaults to 1000 93 | 94 | shorn_gamma : float, double, or None 95 | Entropy temperature for Sinkhorn OT between clusters 96 | larger = slower & more accurate, smaller = faster & less accurate 97 | Defaults to 0.2 98 | 99 | sa_maxiter : int or None 100 | Maximum iterations for subspace alignment procedure 101 | Defaults to 100 102 | 103 | sa_tol : float, double, or None 104 | Stopping criterion for subspace alignment procedure 105 | Defaults to 0.01 106 | 107 | sa_shorn_maxiter : int or None 108 | Maximum iterations for Sinkhorn OT within SA procedure 109 | Defaults to 150 110 | 111 | sa_shorn_gamma : float, double, or None 112 | Entropy temperature for Sinkhorn OT within SA procedure 113 | larger = slower & more accurate, smaller = faster & less accurate 114 | Defaults to 0.1 115 | """ 116 | 117 | def __init__(self, dim_red_method=PCA(n_components=2), normalize=True, maxiter=300, 118 | tol=1e-1, mu=5e-3, shorn_maxiter=1000, shorn_gamma=2e-1, sa_maxiter=100, 119 | sa_tol=1e-2, sa_shorn_maxiter=150, sa_shorn_gamma=1e-1): 120 | 121 | # Save parameters 122 | self.dim_red_method = dim_red_method 123 | self.normalize = normalize 124 | self.maxiter = maxiter 125 | self.tol = tol 126 | self.mu = mu 127 | self.shorn_maxiter = shorn_maxiter 128 | self.shorn_gamma = shorn_gamma 129 | self.sa_maxiter = sa_maxiter 130 | self.sa_tol = sa_tol 131 | self.sa_shorn_maxiter = sa_shorn_maxiter 132 | self.sa_shorn_gamma = sa_shorn_gamma 133 | 134 | def fit(self, X, X_labels, Y, Y_labels, **kwargs): 135 | """Fit the model with X, learning a rotation to match X to Y. 136 | 137 | Parameters 138 | ---------- 139 | X : array-like, shape (n_samples_x, n_features) 140 | Source dataset, to be rotated. 141 | 142 | X_labels : array-like, shape (n_samples_x, ) 143 | Cluster labels for the source dataset. 144 | 145 | Y : arraylike, shape (n_samples_y, n_features) 146 | Target dataset, of the same number of features as X, to rotate X to match. 147 | 148 | Y_labels : array-like, shape (n_samples_y, ) 149 | Cluster labels for the target dataset. 150 | 151 | """ 152 | # If not provided, compute transformations for source and target datasets using the method specified during 153 | # initialization 154 | if self.normalize: 155 | X = _normal(X) 156 | Y = _normal(Y) 157 | X_transform = kwargs.get('X_transform', np.linalg.pinv(X) @ self.dim_red_method.fit_transform(X)) 158 | Y_transform = kwargs.get('Y_transform', np.linalg.pinv(Y) @ self.dim_red_method.fit_transform(Y)) 159 | self.Rgt = kwargs.get('Rgt', np.identity(X.shape[1])) 160 | 161 | # Initialization 162 | h_dim, num_clusters_x, num_clusters_y = X.shape[1], len(np.unique(X_labels)), len(np.unique(Y_labels)) 163 | # Rg = np.identity(h_dim) 164 | Rg = _closed_form_rotation_solver(np.random.random((h_dim, h_dim))) 165 | P = np.full((num_clusters_x, num_clusters_y), 1 / (num_clusters_x * num_clusters_y)) 166 | p = np.full((num_clusters_x, 1), 1 / num_clusters_x) 167 | q = np.full((num_clusters_y, 1), 1 / num_clusters_y) 168 | # Lagrangian multipliers 169 | L = np.zeros((h_dim, h_dim, num_clusters_x, num_clusters_y)) 170 | # Auxiliary variables 171 | R = np.zeros((h_dim, h_dim, num_clusters_x, num_clusters_y)) 172 | R[:, :, :, :] = np.identity(h_dim)[:, :, np.newaxis, np.newaxis] 173 | 174 | C = np.zeros((num_clusters_x, num_clusters_y)) 175 | 176 | diagnostics = {'gamma': np.zeros(self.maxiter, dtype=float), 177 | 'Rg_norm': np.zeros(self.maxiter, dtype=float), 178 | 'rMSE': np.zeros(self.maxiter, dtype=float), 179 | 'R2': np.zeros(self.maxiter, dtype=float), 180 | 'C': np.zeros(C.shape, dtype=float)} 181 | 182 | # Compute low-d embeddings in high-d space and scale 183 | X_mbed = (X_transform @ X_transform.T @ X.T).T / np.sqrt(h_dim) 184 | Y_mbed = (Y_transform @ Y_transform.T @ Y.T).T / np.sqrt(h_dim) 185 | 186 | clust_ids_x = np.unique(X_labels) 187 | clust_ids_y = np.unique(Y_labels) 188 | 189 | # Distributed ADMM 190 | for n in range(self.maxiter): 191 | # Solve for each Q (potentially in parallel) 192 | 193 | for i in range(num_clusters_x): 194 | for j in range(num_clusters_y): 195 | T = (self.mu / h_dim) * (Rg - L[:, :, i, j]) 196 | R[:, :, i, j], _, C[i, j] = self._subspace_alignment_solver( 197 | X_mbed[(X_labels == clust_ids_x[i]).squeeze(), :], 198 | Y_mbed[(Y_labels == clust_ids_y[j]).squeeze(), :], 199 | P[i, j], T) 200 | 201 | # Solve for P 202 | P, _ = _sinkhorn_clusters(p, q, C, self.shorn_gamma, self.shorn_maxiter) 203 | 204 | # Solve for global rotation, Rg 205 | Rg_prev = Rg 206 | Rg = _closed_form_rotation_solver( 207 | np.mean(np.reshape(R + L, [h_dim, h_dim, num_clusters_x * num_clusters_y], order='F'), axis=2)) 208 | 209 | # Update Lagrangian multipliers 210 | L = L + R - Rg[:, :, np.newaxis, np.newaxis] 211 | 212 | diagnostics['gamma'][n] = self.shorn_gamma 213 | diagnostics['Rg_norm'][n] = np.linalg.norm(Rg_prev - Rg, 'fro') 214 | diagnostics['rMSE'][n] = _rMSE(X, Rg, self.Rgt) 215 | diagnostics['R2'][n] = _eval_R2(X, Rg, self.Rgt) 216 | 217 | if (np.isnan(P).any() or diagnostics['Rg_norm'][n] <= self.tol) and n >= 5: 218 | diagnostics['gamma'] = diagnostics['gamma'][0:n + 1] 219 | diagnostics['Rg_norm'] = diagnostics['Rg_norm'][0:n + 1] 220 | diagnostics['rMSE'] = diagnostics['rMSE'][0:n + 1] 221 | diagnostics['R2'] = diagnostics['R2'][0:n + 1] 222 | diagnostics['C'] = C 223 | break 224 | 225 | self.Rg = Rg 226 | self.P = P 227 | self.diagnostics = diagnostics 228 | 229 | def transform(self, X): 230 | """Transform X by applying the learned rotation to it. 231 | 232 | Parameters 233 | ---------- 234 | X : array-like, shape (n_samples_x, n_features) 235 | Source dataset, to be rotated. 236 | 237 | Returns 238 | ---------- 239 | X_new : array-like, shape(n_samples_x, n_features) 240 | """ 241 | return (self.Rg @ X.T).T 242 | 243 | def fit_transform(self, X, X_labels, Y, Y_labels, **kwargs): 244 | """Fit the model with X, learning a rotation to match X to Y, and apply the learned rotation to it. 245 | 246 | Parameters 247 | ---------- 248 | X : array-like, shape (n_samples_x, n_features) 249 | Source dataset, to be rotated. 250 | 251 | X_labels : array-like, shape (n_samples_x, ) 252 | Cluster labels for the source dataset. 253 | 254 | Y : arraylike, shape (n_samples_y, n_features) 255 | Target dataset, of the same number of features as X, to rotate X to match. 256 | 257 | Y_labels : array-like, shape (n_samples_y, ) 258 | Cluster labels for the target dataset. 259 | 260 | Returns 261 | ---------- 262 | X_new : array-like, shape(n_samples_x, n_features) 263 | 264 | """ 265 | self.fit(X, X_labels, Y, Y_labels, **kwargs) 266 | return self.transform(X) 267 | 268 | def _subspace_alignment_solver(self, X, Y, P, T): 269 | """Earth Mover's Distance on low-rank projections""" 270 | # Initialization 271 | h_dim, num_x, num_y = X.shape[1], X.shape[0], Y.shape[0] 272 | R = orth(np.random.random((h_dim, h_dim))) 273 | # R = np.identity(h_dim) 274 | Q = np.full((num_x, num_y), 1 / (num_x * num_y)) 275 | p = np.full((num_x, 1), 1 / num_x) 276 | q = np.full((num_y, 1), 1 / num_y) 277 | 278 | # Alternating minimization 279 | for i in range(self.sa_maxiter): 280 | R_prev = R 281 | 282 | # Solve rotation 283 | R = _closed_form_rotation_solver(2 * P * (Y.T @ Q.T @ X) + T) 284 | 285 | # Solve Sinkhorn OT 286 | Q, dist = _sinkhorn(p, q, R @ X.T, Y.T, self.sa_shorn_gamma / P, self.sa_shorn_maxiter) 287 | 288 | if np.linalg.norm(R_prev - R, 2) <= self.sa_tol: 289 | break 290 | 291 | return R, Q, dist 292 | -------------------------------------------------------------------------------- /HiWA-Demo.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Hierarchical Wasserstein Alignment (HiWA)\n", 8 | "\n", 9 | "_Aim:_ Decompose data into potential clusters and then find global alignment across two datasets by leveraging clustering structure.\n", 10 | "\n", 11 | "_Paper describing HiWA:_ John Lee, Max Dabagia, E Dyer, C Rozell: Hierarchical Wasserstein Alignment for Multimodal Distributions, May 2019.\n", 12 | "\n", 13 | "#### In this demo there are steps to:\n", 14 | "\n", 15 | "- Dimensionality reduction to first simplify problem\n", 16 | "- Clustering data to feed labels into HiWA\n", 17 | "- Alignment between clusters and then global alignment with HiWA" 18 | ] 19 | }, 20 | { 21 | "cell_type": "code", 22 | "execution_count": 67, 23 | "metadata": {}, 24 | "outputs": [], 25 | "source": [ 26 | "# Import necessary packages\n", 27 | "\n", 28 | "import numpy as np\n", 29 | "from src import utils, hiwa\n", 30 | "from sklearn.datasets import make_spd_matrix\n", 31 | "from sklearn.decomposition import PCA, FactorAnalysis\n", 32 | "from sklearn.manifold import Isomap\n", 33 | "from sklearn.neighbors import NearestNeighbors\n", 34 | "from sklearn.mixture import GaussianMixture\n", 35 | "from scipy.linalg import pinv\n", 36 | "import time\n", 37 | "import os\n", 38 | "import matplotlib.pyplot as plt\n", 39 | "%matplotlib inline" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "### Example A - Synthetic Gaussians " 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "#### Step 0. Load data from numpy archive" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 262, 59 | "metadata": {}, 60 | "outputs": [], 61 | "source": [ 62 | "with np.load(os.path.join('data', 'sg_demo.npz')) as dataz:\n", 63 | " X_te = dataz['X_te']\n", 64 | " T_te = dataz['T_te']\n", 65 | " X_tr = dataz['X_tr']\n", 66 | " T_tr = dataz['T_tr']" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "#### Step 1. Align data with HiWA" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 272, 79 | "metadata": {}, 80 | "outputs": [ 81 | { 82 | "name": "stdout", 83 | "output_type": "stream", 84 | "text": [ 85 | "Time elapsed: 0.57946 seconds\n" 86 | ] 87 | } 88 | ], 89 | "source": [ 90 | "# Fit the model and transform the source dataset\n", 91 | "t1 = time.time()\n", 92 | "\n", 93 | "# This indicates to the model it should compute a low-d embedding with isomap, \n", 94 | "# and that the parameter datasets will not be normalized.\n", 95 | "hwa = hiwa.HiWA(dim_red_method=Isomap(n_components=2), normalize=True)\n", 96 | "\n", 97 | "# Fit the model, also passing in the correct rotation in Rgt since we can \n", 98 | "# calculate it in this case (for computing error metrics)\n", 99 | "# Note that we can provide the low-d mapping for either the source or target; \n", 100 | "# the model will calculate whatever isn't provided\n", 101 | "hwa.fit(X_te, T_te, X_tr, T_tr, Rgt=Rgt)\n", 102 | "\n", 103 | "# Transform the dataset with the learned rotation\n", 104 | "X_te_rec = hwa.transform(X_te)\n", 105 | "t2 = time.time()\n", 106 | "print('Time elapsed: {:.5} seconds'.format(t2 - t1))" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "#### Step 2. Evaluate performance with 1NN target accuracy" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 273, 119 | "metadata": {}, 120 | "outputs": [ 121 | { 122 | "name": "stdout", 123 | "output_type": "stream", 124 | "text": [ 125 | "NN Accuracy (Before): 26.00%\n", 126 | "NN Accuracy (After): 94.75%\n" 127 | ] 128 | } 129 | ], 130 | "source": [ 131 | "# Evaluate nearest neighbors classification accuracy before alignment\n", 132 | "nbrs = NearestNeighbors()\n", 133 | "nbrs.fit(X_te)\n", 134 | "idx = nbrs.kneighbors(X_tr, n_neighbors=1, return_distance=False).squeeze()\n", 135 | "nn_hwa_prealign = (T_te[idx] == T_tr).sum() / T_tr.shape[0]\n", 136 | "print('NN Accuracy (Before): {:.2%}'.format(nn_hwa_prealign))\n", 137 | "\n", 138 | "# Evaluate nearest neighbors classification accuracy after alignment\n", 139 | "nbrs = NearestNeighbors()\n", 140 | "nbrs.fit(X_te_rec)\n", 141 | "idx = nbrs.kneighbors(X_tr, n_neighbors=1, return_distance=False).squeeze()\n", 142 | "nn_hwa = (T_te[idx] == T_tr).sum() / T_tr.shape[0]\n", 143 | "print('NN Accuracy (After): {:.2%}'.format(nn_hwa))" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "#### Step 3. Visualize results" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 274, 156 | "metadata": {}, 157 | "outputs": [ 158 | { 159 | "data": { 160 | "image/png": "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\n", 161 | "text/plain": [ 162 | "
" 163 | ] 164 | }, 165 | "metadata": { 166 | "needs_background": "light" 167 | }, 168 | "output_type": "display_data" 169 | } 170 | ], 171 | "source": [ 172 | "# Plot the results, plus some diagnostics\n", 173 | "plt.figure(figsize=(12, 11))\n", 174 | "plt.subplot(2, 3, 1)\n", 175 | "plt.title('Rotated (NN Accuracy = {:.2%})'.format(nn_hwa_prealign))\n", 176 | "utils.plot_2d_clusters(X_te, T_te)\n", 177 | "plt.subplot(2, 3, 2)\n", 178 | "plt.title('Rotated (NN Accuracy = {:.2%})'.format(nn_hwa))\n", 179 | "utils.plot_2d_clusters(X_te_rec, T_te)\n", 180 | "plt.subplot(2, 3, 3)\n", 181 | "plt.title('Target')\n", 182 | "utils.plot_2d_clusters(X_tr, T_tr)\n", 183 | "ax = plt.subplot(2, 3, 4)\n", 184 | "plt.plot(hwa.diagnostics['Rg_norm'])\n", 185 | "ax.set_yscale('log')\n", 186 | "plt.title('Residual Norm')\n", 187 | "plt.xlabel('Iteration')\n", 188 | "plt.subplot(2, 3, 5)\n", 189 | "plt.imshow(hwa.P)\n", 190 | "plt.xticks(np.arange(4))\n", 191 | "plt.yticks(np.arange(4))\n", 192 | "plt.title('Correspondence (Entropy$ = $ %.4f)' %(-np.sum(hwa.P * np.log(hwa.P))))\n", 193 | "plt.subplot(2, 3, 6)\n", 194 | "plt.xticks(np.arange(4))\n", 195 | "plt.yticks(np.arange(4))\n", 196 | "plt.title('Distance Matrix')\n", 197 | "c = plt.imshow(hwa.diagnostics['C'])" 198 | ] 199 | }, 200 | { 201 | "cell_type": "markdown", 202 | "metadata": {}, 203 | "source": [ 204 | "### Example B - Motor cortex during reaching movements (NHP)\n", 205 | "_Data collected by:_ Matthew Perich, Lee Miller Lab (Northwestern)" 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "#### Step 0. Load datasets and reach direction labels" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 2, 218 | "metadata": {}, 219 | "outputs": [], 220 | "source": [ 221 | "# Load the datasets from a .mat file\n", 222 | "T_te, T_tr, X_te, X_tr, Y_te, Y_tr = utils.load_data(os.path.join('data', 'mihi_demo.mat'))\n", 223 | "T_te, T_tr = T_te.squeeze(), T_tr.squeeze()" 224 | ] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "#### Step 1. Apply initial dimensionality reduction" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 3, 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [ 239 | "# Apply initial dimensionality reduction (n_components)\n", 240 | "Y_te_3d = FactorAnalysis(n_components=3).fit_transform(utils.remove_const_cols(Y_te))\n", 241 | "X_tr_3d = utils.map_X_3D(X_tr)\n", 242 | "X_transform = np.linalg.pinv(X_tr_3d) @ X_tr" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "#### Step 2. Align data with HiWA" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 4, 255 | "metadata": {}, 256 | "outputs": [ 257 | { 258 | "name": "stdout", 259 | "output_type": "stream", 260 | "text": [ 261 | "Time elapsed: 8.0 seconds\n" 262 | ] 263 | } 264 | ], 265 | "source": [ 266 | "# Fit the model and transform the source dataset\n", 267 | "t1 = time.time()\n", 268 | "\n", 269 | "# This indicates to the model it should compute a low-d embedding with isomap, \n", 270 | "# and that the parameter datasets will not be normalized\n", 271 | "hwa = hiwa.HiWA(dim_red_method=Isomap(n_components=2, n_neighbors=12), normalize=True)\n", 272 | "\n", 273 | "# Fit the model, also passing in the correct rotation in Rgt since we can \n", 274 | "# calculate it in this case (for computing error metrics)\n", 275 | "# Note that we can provide the low-d mapping for either the source or target; \n", 276 | "# the model will calculate whatever isn't provided\n", 277 | "hwa.fit(Y_te_3d, T_te, X_tr_3d, T_tr, Y_transform=X_transform, Rgt=utils.LS_oracle(utils.map_X_3D(X_te), Y_te_3d))\n", 278 | "\n", 279 | "# Transform the dataset with the learned rotation\n", 280 | "Y_te_rec = hwa.transform(Y_te_3d)\n", 281 | "t2 = time.time()\n", 282 | "print('Time elapsed: {:.5} seconds'.format(t2 - t1))" 283 | ] 284 | }, 285 | { 286 | "cell_type": "markdown", 287 | "metadata": {}, 288 | "source": [ 289 | "#### Step 3. Evaluate performance metrics (R2 and target accuracy)" 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": 6, 295 | "metadata": {}, 296 | "outputs": [ 297 | { 298 | "name": "stdout", 299 | "output_type": "stream", 300 | "text": [ 301 | "R2 Value: 0.6307\n", 302 | "NN Accuracy (Before): 24.40%\n", 303 | "NN Accuracy (After): 52.65%\n" 304 | ] 305 | } 306 | ], 307 | "source": [ 308 | "# Evaluate decoding accuracy after alignment\n", 309 | "r2_hwa = utils.eval_R2(Y_te_rec[:,0:2], X_te)\n", 310 | "print('R2 Value: {:.4}'.format(r2_hwa))\n", 311 | "\n", 312 | "# Evaluate nearest neighbors classification accuracy before alignment\n", 313 | "nbrs = NearestNeighbors()\n", 314 | "nbrs.fit(Y_te_3d)\n", 315 | "idx = nbrs.kneighbors(X_tr_3d, n_neighbors=1, return_distance=False).squeeze()\n", 316 | "nn_hwa_prealign = (T_te[idx] == T_tr).sum() / T_tr.shape[0]\n", 317 | "print('NN Accuracy (Before): {:.2%}'.format(nn_hwa_prealign))\n", 318 | "\n", 319 | "# Evaluate nearest neighbors classification accuracy after alignment\n", 320 | "nbrs = NearestNeighbors()\n", 321 | "nbrs.fit(Y_te_rec)\n", 322 | "idx = nbrs.kneighbors(X_tr_3d, n_neighbors=1, return_distance=False).squeeze()\n", 323 | "nn_hwa = (T_te[idx] == T_tr).sum() / T_tr.shape[0]\n", 324 | "print('NN Accuracy (After): {:.2%}'.format(nn_hwa))" 325 | ] 326 | }, 327 | { 328 | "cell_type": "markdown", 329 | "metadata": {}, 330 | "source": [ 331 | "#### Step 4. Visualize results" 332 | ] 333 | }, 334 | { 335 | "cell_type": "code", 336 | "execution_count": 7, 337 | "metadata": {}, 338 | "outputs": [ 339 | { 340 | "data": { 341 | "image/png": "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\n", 342 | "text/plain": [ 343 | "
" 344 | ] 345 | }, 346 | "metadata": { 347 | "needs_background": "light" 348 | }, 349 | "output_type": "display_data" 350 | } 351 | ], 352 | "source": [ 353 | "# Plot the results, plus some diagnostics\n", 354 | "plt.figure(figsize=(12, 11))\n", 355 | "plt.subplot(2, 3, 1)\n", 356 | "plt.title('Rotated (NN Accuracy = {:.2%})'.format(nn_hwa_prealign))\n", 357 | "utils.plot_2d_clusters(Y_te_3d, T_te)\n", 358 | "plt.subplot(2, 3, 2)\n", 359 | "plt.title('Rotated (NN Accuracy = {:.2%})'.format(nn_hwa))\n", 360 | "utils.plot_2d_clusters(Y_te_rec, T_te)\n", 361 | "plt.subplot(2, 3, 3)\n", 362 | "plt.title('Target')\n", 363 | "utils.plot_2d_clusters(X_tr, T_tr)\n", 364 | "ax = plt.subplot(2, 3, 4)\n", 365 | "plt.plot(hwa.diagnostics['Rg_norm'])\n", 366 | "ax.set_yscale('log')\n", 367 | "plt.title('Residual Norm')\n", 368 | "plt.xlabel('Iteration')\n", 369 | "plt.subplot(2, 3, 5)\n", 370 | "plt.imshow(hwa.P)\n", 371 | "plt.xticks(np.arange(4))\n", 372 | "plt.yticks(np.arange(4))\n", 373 | "plt.title('Correspondence (Entropy$ = $ %.4f)' %(-np.sum(hwa.P * np.log(hwa.P))))\n", 374 | "plt.subplot(2, 3, 6)\n", 375 | "plt.xticks(np.arange(4))\n", 376 | "plt.yticks(np.arange(4))\n", 377 | "plt.title('Distance Matrix')\n", 378 | "c = plt.imshow(hwa.diagnostics['C'])" 379 | ] 380 | } 381 | ], 382 | "metadata": { 383 | "kernelspec": { 384 | "display_name": "Python 3", 385 | "language": "python", 386 | "name": "python3" 387 | }, 388 | "language_info": { 389 | "codemirror_mode": { 390 | "name": "ipython", 391 | "version": 3 392 | }, 393 | "file_extension": ".py", 394 | "mimetype": "text/x-python", 395 | "name": "python", 396 | "nbconvert_exporter": "python", 397 | "pygments_lexer": "ipython3", 398 | "version": "3.7.3" 399 | } 400 | }, 401 | "nbformat": 4, 402 | "nbformat_minor": 2 403 | } 404 | --------------------------------------------------------------------------------