def plot_mean_locations():
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
Ls_mean = np.mean(Ls_rot, 0)
fig = create_figure(figsize=(1.4, 2.5))
plt.subplot(211, aspect='equal')
wheel_cmap = gradient_cmap(
[colors[0], colors[3], colors[2], colors[1], colors[0]])
for i, k in enumerate(node_perm):
color = wheel_cmap((np.pi + pfs_th[k]) / (2 * np.pi))
plt.plot(pfs[k, 0],
pfs[k, 1],
'o',
markerfacecolor=color,
markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45, 45)
# plt.xlabel("$x$")
plt.xticks([-40, -20, 0, 20, 40], [])
plt.ylim(-45, 45)
# plt.ylabel("$y$")
plt.yticks([-40, -20, 0, 20, 40], [])
# Now plot the inferred locations
plt.subplot(212, aspect='equal')
for i, k in enumerate(node_perm):
color = wheel_cmap((np.pi + pfs_th[k]) / (2 * np.pi))
plt.plot(Ls_mean[k, 0],
Ls_mean[k, 1],
'o',
markerfacecolor=color,
markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("Mean Locations")
plt.xlim(-30, 30)
plt.xticks([])
plt.ylim(-30, 30)
plt.yticks([])
plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_mean_locations.pdf"))
plt.show()
def plot(self, A, W, ax=None, L_true=None):
"""
If D==2, plot the embedded nodes and the connections between them
:param L_true: If given, rotate the inferred features to match F_true
:return:
"""
import matplotlib.pyplot as plt
# Color the weights by the
import matplotlib.cm as cm
cmap = cm.get_cmap("RdBu")
W_lim = abs(W[:,:,0]).max()
W_rel = (W[:,:,0] - (-W_lim)) / (2*W_lim)
assert self.dim==2, "Can only plot for D==2"
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111, aspect="equal")
# If true locations are given, rotate L to match L_true
L = self.L.copy()
if L_true is not None:
from graphistician.internals.utils import compute_optimal_rotation
R = compute_optimal_rotation(L, L_true)
L = L.dot(R)
# Scatter plot the node embeddings
# Plot the edges between nodes
for n1 in xrange(self.N):
for n2 in xrange(self.N):
if A[n1,n2]:
ax.plot([L[n1,0], L[n2,0]],
[L[n1,1], L[n2,1]],
'-', color=cmap(W_rel[n1,n2]),
lw=1.0)
ax.plot(L[:,0], L[:,1], 's', color='k', markerfacecolor='k', markeredgecolor='k')
# Get extreme feature values
b = np.amax(abs(L)) + L[:].std() / 2.0
# Plot grids for origin
ax.plot([0,0], [-b,b], ':k', lw=0.5)
ax.plot([-b,b], [0,0], ':k', lw=0.5)
# Set the limits
ax.set_xlim([-b,b])
ax.set_ylim([-b,b])
# Labels
ax.set_xlabel('Latent Dimension 1')
ax.set_ylabel('Latent Dimension 2')
plt.show()
return ax
def plot(self, A, ax=None, color='k', L_true=None, lmbda_true=None):
"""
If D==2, plot the embedded nodes and the connections between them
:param L_true: If given, rotate the inferred features to match F_true
:return:
"""
import matplotlib.pyplot as plt
assert self.dim == 2, "Can only plot for D==2"
if ax is None:
fig = plt.figure()
ax = fig.add_subplot(111, aspect="equal")
# If true locations are given, rotate L to match L_true
L = self.L
if L_true is not None:
from graphistician.internals.utils import compute_optimal_rotation
R = compute_optimal_rotation(self.L, L_true)
L = L.dot(R)
# Scatter plot the node embeddings
ax.plot(L[:, 0],
L[:, 1],
's',
color=color,
markerfacecolor=color,
markeredgecolor=color)
# Plot the edges between nodes
for n1 in xrange(self.N):
for n2 in xrange(self.N):
if A[n1, n2]:
ax.plot([L[n1, 0], L[n2, 0]], [L[n1, 1], L[n2, 1]],
'-',
color=color,
lw=1.0)
# Get extreme feature values
b = np.amax(abs(L)) + L[:].std() / 2.0
# Plot grids for origin
ax.plot([0, 0], [-b, b], ':k', lw=0.5)
ax.plot([-b, b], [0, 0], ':k', lw=0.5)
# Set the limits
ax.set_xlim([-b, b])
ax.set_ylim([-b, b])
# Labels
ax.set_xlabel('Latent Dimension 1')
ax.set_ylabel('Latent Dimension 2')
plt.show()
return ax
def plot_mean_locations():
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
Ls_mean = np.mean(Ls_rot, 0)
fig = create_figure(figsize=(1.4,2.5))
plt.subplot(211, aspect='equal')
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45, 45)
# plt.xlabel("$x$")
plt.xticks([-40, -20, 0, 20, 40], [])
plt.ylim(-45, 45)
# plt.ylabel("$y$")
plt.yticks([-40, -20, 0, 20, 40], [])
# Now plot the inferred locations
plt.subplot(212, aspect='equal')
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Ls_mean[k,0], Ls_mean[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("Mean Locations")
plt.xlim(-30, 30)
plt.xticks([])
plt.ylim(-30, 30)
plt.yticks([])
plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_mean_locations.pdf"))
plt.show()
def plot_mean_and_pca_locations(result):
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs, scale=False)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
Ls_mean = np.mean(Ls_rot, 0)
# Bin the data
from pyhawkes.utils.utils import convert_continuous_to_discrete
S_dt = convert_continuous_to_discrete(S, C, 0.25, 0, T)
# Smooth the data to get a firing rate
from scipy.ndimage.filters import gaussian_filter1d
S_smooth = np.array([gaussian_filter1d(s, 4) for s in S_dt.T]).T
# Run pca to gte an embedding
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(S_smooth)
Z = pca.components_.T
# Rotate
R = compute_optimal_rotation(Z, pfs, scale=False)
Z = Z.dot(R)
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
fig = create_figure(figsize=(1.4,2.9))
# plt.subplot(211, aspect='equal')
ax = create_axis_at_location(fig, .3, 1.7, 1, 1)
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Ls_mean[k,0], Ls_mean[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("Mean Locations")
plt.xlim(-3, 3)
plt.xticks([-2, 0, 2])
plt.ylim(-3, 3)
plt.yticks([-2, 0, 2])
# plt.subplot(212, aspect='equal')
ax = create_axis_at_location(fig, .3, .2, 1, 1)
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Z[k,0], Z[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("PCA Locations")
plt.xlim(-.5, .5)
# plt.xlabel("$x$")
plt.xticks([-.4, 0, .4])
plt.ylim(-.5, .5)
# plt.ylabel("$y$")
plt.yticks([-.4, 0, .4])
# plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_mean_pca_locations.pdf"))
plt.show()
def plot_pca_locations():
### Plot the sampled locations for a few neurons
# Bin the data
from pyhawkes.utils.utils import convert_continuous_to_discrete
S_dt = convert_continuous_to_discrete(S, C, 0.25, 0, T)
# Smooth the data to get a firing rate
from scipy.ndimage.filters import gaussian_filter1d
S_smooth = np.array([gaussian_filter1d(s, 4) for s in S_dt.T]).T
# Run pca to gte an embedding
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(S_smooth)
Z = pca.components_.T
# Rotate
R = compute_optimal_rotation(Z, pfs)
Z = Z.dot(R)
fig = create_figure(figsize=(1.4,2.5))
plt.subplot(211, aspect='equal')
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45, 45)
# plt.xlabel("$x$")
plt.xticks([-40, -20, 0, 20, 40], [])
plt.ylim(-45, 45)
# plt.ylabel("$y$")
plt.yticks([-40, -20, 0, 20, 40], [])
# Now plot the inferred locations
plt.subplot(212, aspect='equal')
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Z[k,0], Z[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("PCA Locations")
plt.xlim(-25, 25)
# plt.xlabel("$x$")
plt.xticks([-20, 0, 20], [])
plt.ylim(-25, 25)
# plt.ylabel("$y$")
plt.yticks([-20, 0, 20], [])
plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_pca_locations.pdf"))
plt.show()
def plot_locations(result, offset=0):
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs, scale=False)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
fig = create_figure(figsize=(1.4,2.9))
ax = create_axis_at_location(fig, .3, 1.7, 1, 1)
# toplot = np.random.choice(np.arange(K), size=4, replace=False)
toplot = np.linspace(offset,K+offset, 4, endpoint=False).astype(np.int)
print(toplot)
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
plot_colors = [wheel_cmap((np.pi+pfs_th[node_perm[j]])/(2*np.pi)) for j in toplot]
for i,k in enumerate(node_perm):
# plt.text(pfs[k,0], pfs[k,1], "%d" % i)
if i not in toplot:
color = 0.8 * np.ones(3)
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=1.0)
for i,k in enumerate(node_perm):
# plt.text(pfs[k,0], pfs[k,1], "%d" % i)
if i in toplot:
j = np.where(toplot==i)[0][0]
color = plot_colors[j]
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k])
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45,45)
plt.xticks([-40, -20, 0, 20, 40])
# plt.xlabel("$x$")
plt.ylim(-45,45)
plt.yticks([-40, -20, 0, 20, 40])
# plt.ylabel("$y$")
# Now plot the inferred locations
# plt.subplot(212, aspect='equal')
ax = create_axis_at_location(fig, .3, .2, 1, 1)
for L in Ls_rot[::2]:
for j in np.random.permutation(len(toplot)):
k = node_perm[toplot][j]
color = plot_colors[j]
plt.plot(L[k,0], L[k,1], 'o',
markerfacecolor=color, markeredgecolor="none",
markersize=4, alpha=0.25)
plt.title("Locations Samples")
# plt.xlim(-30, 30)
# plt.xticks([])
# plt.ylim(-30, 30)
# plt.yticks([])
plt.xlim(-3, 3)
plt.xticks([-2, 0, 2])
plt.ylim(-3, 3)
plt.yticks([-2, 0, 2])
plt.savefig(os.path.join(results_dir, "locations_%d.pdf" % offset))
def plot_mean_and_pca_locations(result):
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs, scale=False)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
Ls_mean = np.mean(Ls_rot, 0)
# Bin the data
from pyhawkes.utils.utils import convert_continuous_to_discrete
S_dt = convert_continuous_to_discrete(S, C, 0.25, 0, T)
# Smooth the data to get a firing rate
from scipy.ndimage.filters import gaussian_filter1d
S_smooth = np.array([gaussian_filter1d(s, 4) for s in S_dt.T]).T
# Run pca to gte an embedding
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(S_smooth)
Z = pca.components_.T
# Rotate
R = compute_optimal_rotation(Z, pfs, scale=False)
Z = Z.dot(R)
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
fig = create_figure(figsize=(1.4,2.9))
# plt.subplot(211, aspect='equal')
ax = create_axis_at_location(fig, .3, 1.7, 1, 1)
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Ls_mean[k,0], Ls_mean[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("Mean Locations")
plt.xlim(-3, 3)
plt.xticks([-2, 0, 2])
plt.ylim(-3, 3)
plt.yticks([-2, 0, 2])
# plt.subplot(212, aspect='equal')
ax = create_axis_at_location(fig, .3, .2, 1, 1)
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Z[k,0], Z[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("PCA Locations")
plt.xlim(-.5, .5)
# plt.xlabel("$x$")
plt.xticks([-.4, 0, .4])
plt.ylim(-.5, .5)
# plt.ylabel("$y$")
plt.yticks([-.4, 0, .4])
# plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_mean_pca_locations.pdf"))
plt.show()
def plot_pca_locations():
### Plot the sampled locations for a few neurons
# Bin the data
from pyhawkes.utils.utils import convert_continuous_to_discrete
S_dt = convert_continuous_to_discrete(S, C, 0.25, 0, T)
# Smooth the data to get a firing rate
from scipy.ndimage.filters import gaussian_filter1d
S_smooth = np.array([gaussian_filter1d(s, 4) for s in S_dt.T]).T
# Run pca to gte an embedding
from sklearn.decomposition import PCA
pca = PCA(n_components=2)
pca.fit(S_smooth)
Z = pca.components_.T
# Rotate
R = compute_optimal_rotation(Z, pfs)
Z = Z.dot(R)
fig = create_figure(figsize=(1.4,2.5))
plt.subplot(211, aspect='equal')
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45, 45)
# plt.xlabel("$x$")
plt.xticks([-40, -20, 0, 20, 40], [])
plt.ylim(-45, 45)
# plt.ylabel("$y$")
plt.yticks([-40, -20, 0, 20, 40], [])
# Now plot the inferred locations
plt.subplot(212, aspect='equal')
for i,k in enumerate(node_perm):
color = wheel_cmap((np.pi+pfs_th[k])/(2*np.pi))
plt.plot(Z[k,0], Z[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=0.7)
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("PCA Locations")
plt.xlim(-25, 25)
# plt.xlabel("$x$")
plt.xticks([-20, 0, 20], [])
plt.ylim(-25, 25)
# plt.ylabel("$y$")
plt.yticks([-20, 0, 20], [])
plt.tight_layout()
plt.savefig(os.path.join(results_dir, "hipp_pca_locations.pdf"))
plt.show()
def plot_locations(result, offset=0):
### Plot the sampled locations for a few neurons
_, _, _, _, Ls = result
Ls_rot = []
for L in Ls:
R = compute_optimal_rotation(L, pfs, scale=False)
Ls_rot.append(L.dot(R))
Ls_rot = np.array(Ls_rot)
fig = create_figure(figsize=(1.4,2.9))
ax = create_axis_at_location(fig, .3, 1.7, 1, 1)
# toplot = np.random.choice(np.arange(K), size=4, replace=False)
toplot = np.linspace(offset,K+offset, 4, endpoint=False).astype(np.int)
print toplot
wheel_cmap = gradient_cmap([colors[0], colors[3], colors[2], colors[1], colors[0]])
plot_colors = [wheel_cmap((np.pi+pfs_th[node_perm[j]])/(2*np.pi)) for j in toplot]
for i,k in enumerate(node_perm):
# plt.text(pfs[k,0], pfs[k,1], "%d" % i)
if i not in toplot:
color = 0.8 * np.ones(3)
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k],
alpha=1.0)
for i,k in enumerate(node_perm):
# plt.text(pfs[k,0], pfs[k,1], "%d" % i)
if i in toplot:
j = np.where(toplot==i)[0][0]
color = plot_colors[j]
plt.plot(pfs[k,0], pfs[k, 1], 'o',
markerfacecolor=color, markeredgecolor=color,
markersize=4 + 4 * pf_size[k])
# plt.gca().add_patch(Circle((0,0), radius=rad, ec='k', fc="none"))
plt.title("True Place Fields")
plt.xlim(-45,45)
plt.xticks([-40, -20, 0, 20, 40])
# plt.xlabel("$x$")
plt.ylim(-45,45)
plt.yticks([-40, -20, 0, 20, 40])
# plt.ylabel("$y$")
# Now plot the inferred locations
# plt.subplot(212, aspect='equal')
ax = create_axis_at_location(fig, .3, .2, 1, 1)
for L in Ls_rot[::2]:
for j in np.random.permutation(len(toplot)):
k = node_perm[toplot][j]
color = plot_colors[j]
plt.plot(L[k,0], L[k,1], 'o',
markerfacecolor=color, markeredgecolor="none",
markersize=4, alpha=0.25)
plt.title("Locations Samples")
# plt.xlim(-30, 30)
# plt.xticks([])
# plt.ylim(-30, 30)
# plt.yticks([])
plt.xlim(-3, 3)
plt.xticks([-2, 0, 2])
plt.ylim(-3, 3)
plt.yticks([-2, 0, 2])
plt.savefig(os.path.join(results_dir, "locations_%d.pdf" % offset))
