def plot_sliding_window(series, width, step):
'''
Plot a sliding-window graph
Parameters
----------
series: time-series, array , 3-D
width: window width
step: window step size, in samples. If not provided, window and step size are equal.
'''
from nilearn import plotting
import numpy as np
from nilearn.connectome import sym_matrix_to_vec
from nilearn.connectome import ConnectivityMeasure
cut = sliding_window_2d(series, width, step)
cut_matrix = np.zeros((cut.shape[0], cut.shape[2], cut.shape[2]))
correlation_measure = ConnectivityMeasure(kind='correlation')
for i in range(cut.shape[0]):
matrix = correlation_measure.fit_transform([cut[i]])[0]
cut_matrix[i, :, :] = matrix
vectors = np.zeros(
(cut_matrix.shape[0], sym_matrix_to_vec(cut_matrix[1]).shape[0]))
for i in range(cut_matrix.shape[0]):
vec = sym_matrix_to_vec(cut_matrix[i])
vectors[i, :] = vec
ax = np.corrcoef(vectors)
plotting.plot_matrix(ax, title="width={} step={}".format(width, step))
def plot_matrix(mat, labels, modules, outfile="", zero_diag=True):
# plot group-mean matrix
norm = MidpointNormalize(midpoint=0)
if zero_diag:
mat[range(mat.shape[0]), range(mat.shape[0])] = 0
plotting.plot_matrix(mat,
labels=labels.tolist(),
auto_fit=True,
norm=norm,
cmap=ListedColormap(
sns.diverging_palette(220, 15, sep=1, n=31)),
figure=(10, 10))
prev = ""
idx = 0
for i in range(len(labels)):
if modules[i] != prev:
plt.plot([-5, len(labels) + 0.5], [i - 0.5, i - 0.5],
linewidth=1,
color='gray')
plt.plot([i - 0.5, i - 0.5], [-5, len(labels) + 0.5],
linewidth=1,
color='gray')
idx = idx + 1
prev = modules[i]
if outfile:
figure = plt.gcf()
figure.savefig(outfile, bbox_inches='tight')
plt.close(figure)
else:
plotting.show()
def compute_correlation_matrix_from_hypergraph(hypergraph, time_series, delay=0, savefigure=None):
correlation_matrix = np.zeros(hypergraph.shape)
if delay == 0:
k_circular = []
k_circular.append(0)
else:
k_circular = range(-1 * delay, delay + 1, 1)
hypergraph = hypergraph.astype(bool)
for i in range(hypergraph.shape[0]):
print(i)
for j in range(i + 1, hypergraph.shape[0], 1):
m = []
for lag in k_circular:
time_serie_lagged = np.roll(time_series[:, hypergraph[j, :]], lag)
m.append(dcor.u_distance_correlation_sqr(time_series[:, hypergraph[i, :]], time_serie_lagged))
correlation_matrix[i, j] = max(m)
correlation_matrix[j, i] = correlation_matrix[i, j]
if savefigure is not None:
figure = plt.figure(figsize=(6, 6))
plotting.plot_matrix(correlation_matrix, figure=figure, vmax=1., vmin=0.)
figure.savefig(savefigure, dpi=200)
plt.close(figure)
return correlation_matrix
def compute_hypergraph_elastic_net(time_series, savefigure=None, alpha=0.1, threshold=0):
# 1 / (2 * n_samples) * ||y - Xw||^2_2 + alpha * l1_ratio * ||w||_1 + 0.5 * alpha * (1 - l1_ratio) * ||w||^2_2
clf = ElasticNet(alpha=alpha, l1_ratio=0.25, max_iter=8000, tol=1e-2)
hypergraph = np.zeros((time_series.shape[1], time_series.shape[1]))
for i in range(time_series.shape[1]):
X = time_series.copy()
Y = X[:, i].copy()
X[:, i] = 0
hypergraph[i, :] = clf.fit(X, Y).coef_
hypergraph[i, np.where(hypergraph[i, :] > threshold)] = 1
hypergraph[i, np.where(hypergraph[i, :] < -threshold)] = 1
hypergraph[i, np.where(hypergraph[i, :] != 1)] = 0
if savefigure is not None:
figure = plt.figure(figsize=(6, 6))
plotting.plot_matrix(hypergraph, figure=figure, vmax=1., vmin=-1.)
figure.savefig(savefigure, dpi=200)
plt.close(figure)
print('HyperGraph computing finished')
return hypergraph
def run(ts_path, output_path, savefigure, faster=False):
x = np.loadtxt(ts_path, delimiter=',')
alphas = np.arange(0.1, 0.8, 0.2)
output_path = join(output_path, 'hypergraph_parcellation')
makedir(output_path)
hypergraph_list = []
for alpha in alphas:
alpha = round(alpha, 2)
print('Computing a HyperGraph with ' + str(alpha) + ' sparse level')
output_file = join(output_path, '_hypergraph_' + str(alpha) + '.txt')
if not path.exists(output_file):
hypergraph = compute_hypergraph_elastic_net(time_series=x, alpha=alpha, savefigure=savefigure + str(alpha) + '.png')
np.savetxt(output_file, hypergraph, delimiter=',', fmt='%i')
else:
hypergraph = np.loadtxt(output_file, delimiter=',')
hypergraph_list.append(hypergraph)
np_hypergraph_list = np.asarray(hypergraph_list).astype(np.int8)
print(np_hypergraph_list.shape)
median_h = np.median(np_hypergraph_list, axis=0)
figure = plt.figure(figsize=(6, 6))
plotting.plot_matrix(median_h, figure=figure, vmax=1., vmin=-1.)
figure.savefig(savefigure + 'median.png', dpi=200)
plt.close(figure)
return hypergraph_list
def savefig_connectome(connectivity_matrix,
outfile,
labels=None,
title=None,
reorder=True):
"""
Save a connectome figure using nilearn's plot_matrix.
"""
fake_labels = [str(i) for i in range(1, connectivity_matrix.shape[0] + 1)]
atlas_labels = labels[1:] if labels is not None else fake_labels
connectome = connectivity_matrix.copy()
np.fill_diagonal(connectome, 0)
fig = plt.figure(figsize=(10, 8))
plotting.plot_matrix(connectome,
figure=fig,
labels=atlas_labels,
vmin=-0.8,
vmax=0.8,
reorder=reorder)
if title is not None:
fig.suptitle(title)
plt.savefig(outfile)
def plot_conn_mat(conn_matrix, label_names, out_path_fig):
import matplotlib
matplotlib.use('agg')
from matplotlib import pyplot as plt
#from pynets import thresholding
from nilearn.plotting import plot_matrix
dpi_resolution = 500
#conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
rois_num = conn_matrix.shape[0]
if rois_num < 100:
plot_matrix(conn_matrix,
figure=(10, 10),
labels=label_names,
vmax=z_max,
vmin=z_min,
reorder=True,
auto_fit=True,
grid=False,
colorbar=False)
else:
plot_matrix(conn_matrix,
figure=(10, 10),
vmax=z_max,
vmin=z_min,
auto_fit=True,
grid=False,
colorbar=False)
plt.savefig(out_path_fig, dpi=dpi_resolution)
plt.close()
return
def plot_matrices(cov, prec, title):
"""Plot covariance and precision matrices, for a given processing. """
import matplotlib.pyplot as plt
prec = prec.copy() # avoid side effects
# Put zeros on the diagonal, for graph clarity.
size = prec.shape[0]
prec[list(range(size)), list(range(size))] = 0
span = max(abs(prec.min()), abs(prec.max()))
# Display covariance matrix
plotting.plot_matrix(cov,
cmap=plotting.cm.bwr,
vmin=-1,
vmax=1,
colorbar=True)
plt.title("%s / covariance" % title)
# Display precision matrix
plotting.plot_matrix(cov,
cmap=plotting.cm.bwr,
vmin=-span,
vmax=span,
colorbar=True)
plt.title("%s / precision" % title)
def plotMatrix(matrix, plot_path, labels, title, ticks, vmin=-1., vmax=1.):
"""Plot matrix.
param matrix: two dimensional array. The matrix to plot
param plot_path : string. Full path and name of the plotting picture
param labels: list. The labels
param title: string. The title of the plot
param ticks: list. The ticks of the plot
vmin: float. Minimum value
vmax: float. Maximum value
return: None
"""
ticks = list(map(lambda x: x - 0.5, ticks))
ticks_middle = [(((ticks[i + 1] - ticks[i]) / 2) + ticks[i])
for i in range(0,
len(ticks) - 1)]
fig, ax = plt.subplots()
fig.set_size_inches(16.5, 9.5)
ax.xaxis.set_minor_locator(plt.FixedLocator(ticks[1:]))
ax.yaxis.set_minor_locator(plt.FixedLocator(ticks[1:]))
ax.grid(color='black', linestyle='-', linewidth=1.2, which='minor')
plt.title(label=title, fontsize=20)
plotting.plot_matrix(matrix, colorbar=True, axes=ax, vmin=vmin, vmax=vmax)
plt.yticks(ticks_middle, list(labels))
plt.xticks(ticks_middle,
list(labels),
rotation=55,
horizontalalignment='right')
for item in (ax.get_xticklabels() + ax.get_yticklabels()):
item.set_color(net_dic.labelToColorDic[item.get_text()])
item.set_fontsize(14)
fig.savefig(plot_path)
plt.close()
def plot_conn_mat(conn_matrix, labels, out_path_fig):
"""
:param conn_matrix:
:param labels:
:param out_path_fig:
:return:
"""
import matplotlib
matplotlib.use('agg')
from matplotlib import pyplot as plt
#from pynets import thresholding
from nilearn.plotting import plot_matrix
dpi_resolution = 300
# conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
rois_num = conn_matrix.shape[0]
if rois_num < 100:
try:
plot_matrix(conn_matrix, figure=(10, 10), labels=labels, vmax=z_max*0.5, vmin=z_min*0.5, reorder=True,
auto_fit=True, grid=False, colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
else:
try:
plot_matrix(conn_matrix, figure=(10, 10), vmax=z_max*0.5, vmin=z_min*0.5, auto_fit=True, grid=False,
colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
plt.savefig(out_path_fig, dpi=dpi_resolution)
plt.close()
return
def plot_corr(time_series, labels):
'''
Parameters
----------
time_series : array
Time series of the signal in each region .
labels : list
Labels of all the regions in parcellation.
Returns
-------
None.
'''
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Mask the main diagonal for visualization:
np.fill_diagonal(correlation_matrix, 0)
# The labels we have start with the background (0), hence we skip the first label
plotting.plot_matrix(correlation_matrix,
figure=(10, 8),
labels=labels[1:],
vmax=0.8,
vmin=-0.8,
reorder=True)
def plot_community_conn_mat(conn_matrix, labels, out_path_fig_comm, community_aff):
"""
:param conn_matrix:
:param labels:
:param out_path_fig_comm:
:param community_aff:
:return:
"""
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.patches as patches
matplotlib.use('agg')
#from pynets import thresholding
from nilearn.plotting import plot_matrix
dpi_resolution = 300
#conn_matrix = np.array(np.array(thresholding.autofix(conn_matrix)))
sorting_array = sorted(range(len(community_aff)), key=lambda k: community_aff[k])
sorted_conn_matrix = conn_matrix[sorting_array, :]
sorted_conn_matrix = sorted_conn_matrix[:, sorting_array]
[z_min, z_max] = -np.abs(sorted_conn_matrix).max(), np.abs(sorted_conn_matrix).max()
rois_num = sorted_conn_matrix.shape[0]
if rois_num < 100:
try:
plot_matrix(conn_matrix, figure=(10, 10), labels=labels, vmax=z_max, vmin=z_min,
reorder=False, auto_fit=True, grid=False, colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
else:
try:
plot_matrix(conn_matrix, figure=(10, 10), vmax=z_max, vmin=z_min, auto_fit=True, grid=False, colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
ax = plt.gca()
total_size = 0
for community in np.unique(community_aff):
size = sum(sorted(community_aff) == community)
ax.add_patch(patches.Rectangle(
(total_size, total_size),
size,
size,
fill=False,
edgecolor='black',
alpha=None,
linewidth=1
)
)
total_size += size
plt.savefig(out_path_fig_comm, dpi=dpi_resolution)
plt.close()
return
def plot_conn_mat(conn_matrix,
labels,
out_path_fig,
cmap,
binarized=False,
dpi_resolution=300):
"""
Plot a connectivity matrix.
Parameters
----------
conn_matrix : array
NxN matrix.
labels : list
List of string labels corresponding to ROI nodes.
out_path_fig : str
File path to save the connectivity matrix image as a .png figure.
"""
import matplotlib
matplotlib.use("agg")
from matplotlib import pyplot as plt
from nilearn.plotting import plot_matrix
from pynets.core import thresholding
import matplotlib.ticker as mticker
conn_matrix = thresholding.standardize(conn_matrix)
conn_matrix_bin = thresholding.binarize(conn_matrix)
conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin))
try:
plot_matrix(
conn_matrix_plt,
figure=(10, 10),
labels=labels,
vmax=np.percentile(conn_matrix_plt[conn_matrix_plt > 0], 95),
vmin=np.min(conn_matrix_plt) - 0.000001,
reorder="average",
auto_fit=True,
grid=False,
colorbar=False,
cmap=cmap,
)
except RuntimeWarning:
print("Connectivity matrix too sparse for plotting...")
if len(labels) > 40:
tick_interval = int(np.around(len(labels) / 40))
else:
tick_interval = int(np.around(len(labels)))
plt.axes().yaxis.set_major_locator(mticker.MultipleLocator(tick_interval))
plt.axes().xaxis.set_major_locator(mticker.MultipleLocator(tick_interval))
plt.savefig(out_path_fig, dpi=dpi_resolution)
plt.close()
return
def plot_correlation_matrix(correlation_matrix, atlas_data):
np.fill_diagonal(correlation_matrix,
0) #mask the main diagonal for visualization:
labels = np.unique(atlas_data)
plotting.plot_matrix(correlation_matrix,
figure=(10, 8),
labels=labels,
vmax=1,
vmin=-1,
reorder=True)
plotting.show()
def main(argv=None):
args = get_parser().parse_args(argv)
output_dir = op.join(args.dset, 'derivatives', args.deriv, args.sub,
args.ses)
os.makedirs(output_dir, exist_ok=True)
nii_files = glob(
op.join(args.dset, 'derivatives',
'3dTproject_denoise_acompcor_csfwm+12mo+0.35mm', args.sub,
args.ses, '*.nii.gz'))
for tmp_nii_file in nii_files:
print(tmp_nii_file)
imgs = nib.load(tmp_nii_file)
fsaverage = fetch_surf_fsaverage(mesh='fsaverage5')
mask = compute_background_mask(imgs)
surf_lh = surface.vol_to_surf(imgs,
fsaverage.pial_left,
radius=24,
interpolation='nearest',
kind='ball',
n_samples=None,
mask_img=mask)
surf_rh = surface.vol_to_surf(imgs,
fsaverage.pial_right,
radius=24,
interpolation='nearest',
kind='ball',
n_samples=None,
mask_img=mask)
time_series = np.transpose(np.vstack((surf_lh, surf_rh)))
correlation = ConnectivityMeasure(kind='correlation')
time_series = correlation.fit_transform([time_series])[0]
plotting.plot_matrix(time_series, figure=(10, 8))
plt.savefig(
op.join(
output_dir, '{0}-correlation_matrix.png'.format(
op.basename(tmp_nii_file).split('.')[0])))
plt.close()
with open(
op.join(
output_dir, '{0}-correlation_matrix.pkl'.format(
op.basename(tmp_nii_file).split('.')[0])), 'wb') as fo:
pickle.dump(time_series, fo)
def plotMatrix(matrix, plot_path, labels, title, ticks, vmin, vmax):
"""Plot matrix.
param matrix: two dimensional array. The matrix to plot
param plot_path : string. Full path and name of the plotting picture
param labels: list. The labels
param title: string. The title of the plot
param ticks: list. The ticks of the plot
vmin: float. Minimum value
vmax: float. Maximum value
return: None
"""
ticks = list(map(lambda x: x - 0.5, ticks))
labelToColorDic = {
"Uncertain": "olive",
"SSH": "cyan",
"SSM": "orange",
"CO": "purple",
"Auditory": "m",
"DMN": "red",
"Memory": "grey",
"Visual": "blue",
"FP": "gold",
"Salience": "black",
"Subcortical": "brown",
"VAN": "teal",
"DAN": "green",
"Cerebellum": "purple"
}
ticks_middle = [(((ticks[i + 1] - ticks[i]) / 2) + ticks[i])
for i in range(0,
len(ticks) - 1)]
fig, ax = plt.subplots()
fig.set_size_inches(16.5, 9.5)
plt.yticks(ticks_middle, labels)
plt.xticks(ticks_middle, labels, rotation=55, horizontalalignment='right')
ax.xaxis.set_minor_locator(plt.FixedLocator(ticks[1:]))
ax.yaxis.set_minor_locator(plt.FixedLocator(ticks[1:]))
ax.grid(color='black', linestyle='-', linewidth=1.2, which='minor')
plt.title(label=title, fontsize=20)
for item in (ax.get_xticklabels() + ax.get_yticklabels()):
item.set_color(labelToColorDic[item.get_text()])
item.set_fontsize(14)
plotting.plot_matrix(matrix,
colorbar=True,
figure=fig,
vmin=vmin,
vmax=vmax)
fig.savefig(plot_path)
plt.close()
def plot_cor_matrix(correlation_matrix, title, labels=None):
## plot the correlation matrix
np.fill_diagonal(correlation_matrix, 0)
if labels:
plot_matrix(correlation_matrix, figure=(10, 8),
labels=labels,
vmax=0.8, vmin=-0.8, reorder=True)
else:
plot_matrix(correlation_matrix, figure=(10, 8),
labels=range(correlation_matrix.shape[1]),
vmax=0.8, vmin=-0.8, reorder=True)
plt.title(title)
plt.show()
def plot_conn_matrices(sc_mat, fc_mat):
fig = plt.figure(figsize=(12, 8))
ax1 = plt.subplot(1, 2, 1)
plotting.plot_matrix(sc_mat[0:78, 0:78],
colorbar=False,
cmap="Reds",
axes=ax1)
ax1.set_title("Structural Connectivity", fontsize=20)
ax2 = plt.subplot(1, 2, 2)
plotting.plot_matrix(fc_mat[0:78, 0:78],
colorbar=True,
cmap="Reds",
axes=ax2)
ax2.set_title("Functional Connectivity", fontsize=20)
plt.savefig("../../figures/conn_matrices_plot.png")
def plot_conn_mat(conn_matrix, labels, out_path_fig):
"""
Plot a connectivity matrix.
Parameters
----------
conn_matrix : array
NxN matrix.
labels : list
List of string labels corresponding to ROI nodes.
out_path_fig : str
File path to save the connectivity matrix image as a .png figure.
"""
import matplotlib
matplotlib.use('agg')
from matplotlib import pyplot as plt
from nilearn.plotting import plot_matrix
dpi_resolution = 300
[z_min, z_max] = -np.abs(conn_matrix).max(), np.abs(conn_matrix).max()
rois_num = conn_matrix.shape[0]
if rois_num < 100:
try:
plot_matrix(conn_matrix,
figure=(10, 10),
labels=labels,
vmax=z_max * 0.5,
vmin=z_min * 0.5,
reorder=False,
auto_fit=True,
grid=False,
colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
else:
try:
plot_matrix(conn_matrix,
figure=(10, 10),
auto_fit=True,
vmax=z_max * 0.5,
vmin=z_min * 0.5,
grid=False,
colorbar=False)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
plt.savefig(out_path_fig, dpi=dpi_resolution)
plt.close()
return
def plot_matrices(cov, prec, title):
"""Plot covariance and precision matrices, for a given processing. """
prec = prec.copy() # avoid side effects
# Put zeros on the diagonal, for graph clarity.
size = prec.shape[0]
prec[list(range(size)), list(range(size))] = 0
span = max(abs(prec.min()), abs(prec.max()))
# Display covariance matrix
plotting.plot_matrix(cov, cmap=plotting.cm.bwr,
vmin=-1, vmax=1, title="%s / covariance" % title)
# Display precision matrix
plotting.plot_matrix(cov, cmap=plotting.cm.bwr,
vmin=-span, vmax=span, title="%s / precision" % title)
def _run_interface(self, runtime):
fname = self.inputs.fmri_denoised
entities = parse_file_entities(fname)
bold_img = nb.load(fname)
parcellation_file = get_parcellation_file_path(entities['space'])
masker = NiftiLabelsMasker(labels_img=parcellation_file,
standardize=True)
time_series = masker.fit_transform(bold_img, confounds=None)
corr_measure = ConnectivityMeasure(kind='correlation')
corr_mat = corr_measure.fit_transform([time_series])[0]
entities['pipeline'] = extract_pipeline_from_path(fname)
conn_file = join(self.inputs.output_dir,
build_path(entities, self.conn_file_pattern, False))
carpet_plot_file = join(
self.inputs.output_dir,
build_path(entities, self.carpet_plot_pattern, False))
matrix_plot_file = join(
self.inputs.output_dir,
build_path(entities, self.matrix_plot_pattern, False))
make_carpetplot(time_series, carpet_plot_file)
mplot = plot_matrix(corr_mat, vmin=-1, vmax=1)
mplot.figure.savefig(matrix_plot_file)
np.save(conn_file, corr_mat)
self._results['corr_mat'] = conn_file
self._results['carpet_plot'] = carpet_plot_file
self._results['matrix_plot'] = matrix_plot_file
return runtime
def _run_interface(self, runtime):
fname = self.inputs.fmri_denoised
bold_img = nb.load(fname)
masker = NiftiLabelsMasker(labels_img=self.inputs.parcellation,
standardize=True)
time_series = masker.fit_transform(bold_img, confounds=None)
corr_measure = ConnectivityMeasure(kind='correlation')
corr_mat = corr_measure.fit_transform([time_series])[0]
_, base, _ = split_filename(fname)
conn_file = f'{self.inputs.output_dir}/{base}_conn_mat.npy'
carpet_plot_file = join(self.inputs.output_dir,
f'{base}_carpet_plot.png')
matrix_plot_file = join(self.inputs.output_dir,
f'{base}_matrix_plot.png')
create_carpetplot(time_series, carpet_plot_file)
mplot = plot_matrix(corr_mat, vmin=-1, vmax=1)
mplot.figure.savefig(matrix_plot_file)
np.save(conn_file, corr_mat)
self._results['corr_mat'] = conn_file
self._results['carpet_plot'] = carpet_plot_file
self._results['matrix_plot'] = matrix_plot_file
return runtime
def getConnectome(imgPath=None,
atlasPath=None,
viewInBrowser=False,
displayCovMatrix=False):
"""
Gets the connectome of a functional MRI scan
imgPath -> absolute or relative path to the .nii file
atlasPath -> download path for the reference MSDL atlas
viewInBrowser (optional, default=False) -> if True, opens up an interactive viewer in the browser
displayCovMatrix (optional, default=False) -> display the inverse covariance matrix
Returns a tuple of shape (estimator, atlas)
"""
# Download the reference atlas
atlas = datasets.fetch_atlas_msdl(data_dir=atlasPath)
# Loading atlas image stored in 'maps'
atlasFilename = atlas['maps']
# Get the time series for the fMRI scan
masker = NiftiMapsMasker(maps_img=atlasFilename,
standardize=True,
memory='nilearn_cache',
verbose=5)
timeSeries = masker.fit_transform(imgPath)
# Compute the connectome using sparse inverse covariance
estimator = GraphicalLassoCV()
estimator.fit(timeSeries)
if (displayCovMatrix):
labels = atlas['labels']
plotting.plot_matrix(estimator.covariance_,
labels=labels,
figure=(9, 7),
vmax=1,
vmin=-1,
title='Covariance')
plotting.plot_matrix(estimator.precision_,
labels=labels,
figure=(9, 7),
vmax=1,
vmin=-1,
title='Inverse covariance (Precision)')
#covPlot.get_figure().savefig('Covariance.png')
# precPlot.get_figure().savefig('Inverse Covariance.png')
if (viewInBrowser):
coords = atlas.region_coords
view = plotting.view_connectome(-estimator.precision_, coords, '60.0%')
#view.save_as_html(file_name='Connectome Test.html')
view.open_in_browser()
return (estimator, atlas)
def plot_matrices(matrices, matrix_kind):
n_matrices = len(matrices)
fig = plt.figure(figsize=(n_matrices * 4, 4))
for n_subject, matrix in enumerate(matrices):
plt.subplot(1, n_matrices, n_subject + 1)
matrix = matrix.copy() # avoid side effects
# Set diagonal to zero, for better visualization
np.fill_diagonal(matrix, 0)
vmax = np.max(np.abs(matrix))
title = '{0}, subject {1}'.format(matrix_kind, n_subject)
plotting.plot_matrix(matrix,
vmin=-vmax,
vmax=vmax,
cmap='RdBu_r',
title=title,
figure=fig,
colorbar=False)
def _run_interface(self, runtime):
import numpy as np
from nilearn import plotting
import matplotlib.pyplot as plt
import dcor
from datetime import datetime
from utils.utils import absmax
hypergraph = np.loadtxt(self.inputs.hypergraph_path, delimiter=',')
time_series = np.loadtxt(self.inputs.time_series_path, delimiter=',')
k_circular = [0] if self.inputs.lag == 0 else range(-1 * self.inputs.lag, self.inputs.lag + 1, 1)
correlation_matrix = np.zeros(hypergraph.shape)
threshold = 0.3
hypergraph[np.where(hypergraph > threshold)] = 1
hypergraph[np.where(hypergraph != 1)] = 0
hypergraph = hypergraph.astype(bool)
then = datetime.now()
for i in range(hypergraph.shape[0]):
print(i)
for j in range(i + 1, hypergraph.shape[0], 1):
correlation_values_from_laggeds = []
for lag in k_circular:
correlation_values_from_laggeds.append(
dcor.u_distance_correlation_sqr(time_series[:, hypergraph[i, :]],
np.roll(time_series[:, hypergraph[j, :]], lag)))
# correlation_matrix[i, j] = dcor.u_distance_correlation_sqr(time_series[:, hypergraph[i, :]],
# time_series[:, hypergraph[j, :]])
correlation_matrix[i, j] = np.max(correlation_values_from_laggeds)
# correlation_matrix[j, i] = correlation_matrix[i, j]
figure = plt.figure(figsize=(6, 6))
plotting.plot_matrix(correlation_matrix, figure=figure, vmax=1., vmin=0.)
figure.savefig(self.inputs.correlation_matrix_plot_out_file, dpi=300)
np.savetxt(self.inputs.correlation_matrix_out_file, correlation_matrix, delimiter=',', fmt='%10.2f')
print('Total time: ', (datetime.now() - then).total_seconds())
return runtime
def plot_matrices(cov, prec, title, labels):
"""Plot covariance and precision matrices, for a given processing. """
prec = prec.copy() # avoid side effects
# Put zeros on the diagonal, for graph clarity.
size = prec.shape[0]
prec[list(range(size)), list(range(size))] = 0
span = max(abs(prec.min()), abs(prec.max()))
# Display covariance matrix
plotting.plot_matrix(cov, cmap=plotting.cm.bwr,
vmin=-1, vmax=1, title="%s / covariance" % title,
labels=labels)
# Display precision matrix
plotting.plot_matrix(prec, cmap=plotting.cm.bwr,
vmin=-span, vmax=span, title="%s / precision" % title,
labels=labels)
def forward(self, batch):
if type(batch) == list: # Data list
batch = Batch.from_data_list(batch)
all_x = [
batch.x.to(self.device),
batch.adj_statistics.to(self.device),
batch.raw_adj.to(self.device),
]
edge_index, edge_attr = batch.edge_index.to(
self.device), batch.edge_attr
edge_attr = edge_attr.to(
self.device) if edge_attr is not None else edge_attr
num_graphs, batch_mask = batch.num_graphs, batch.batch.to(self.device)
x = torch.cat([op(x) for op, x in zip(self.first_fc, all_x)], dim=-1)
# domain_x_out = self.first_domain_fc(x.reshape(num_graphs, -1))
# CNP
cnp1_out_all, p1_x, p1_ei, p1_ea, p1_batch, p1_loss, p1_assignment = self.cnp1(
x, edge_index, edge_attr, batch)
reg = p1_loss.unsqueeze(0)
# reg = torch.tensor(0.).to(self.device)
# domain
# domain_out = self.domain_conv(torch.cat([x for _ in range(self.alpha_dim)], dim=-1),
# self.cnp1.alpha_index, self.cnp1.alpha, batch_mask)
# domain_out = torch.cat([torch.cat(d, dim=1) for d in domain_out], dim=-1)
# domain_out = domain_out.reshape(num_graphs, self.in_nodes, self.hidden_dim * self.conv_depth, self.alpha_dim)
# domain_out = torch.cat([domain_out.max(dim=1)[0], domain_out.mean(dim=1)], dim=-1) # readout
p1_x = p1_x.reshape(num_graphs, self.pool1_nodes, self.hidden_dim,
self.alpha_dim)
p1_x = p1_x.max(dim=1)[0] # max pooling
self.fc_in = p1_x.reshape(num_graphs, -1)
fc_out = self.final_fc(self.fc_in)
self.fc_out = fc_out
# domain_fc_out = self.domain_fc(domain_out.reshape(num_graphs, -1))
domain_fc_out = None
if self.logging_hist:
self.writer.add_histogram('alpha1',
self.cnp1.alpha.detach().cpu().flatten())
self.writer.add_histogram('p1_ea', p1_ea.detach().cpu().flatten())
self.writer.add_histogram('p1_assignment',
p1_assignment.detach().cpu().flatten())
adj_1 = batch_to_adj(self.cnp1.alpha_index, self.cnp1.alpha, 360,
num_graphs)
torch.save(adj_1, 'adj_1')
fig_1 = plot_matrix(adj_1[0, 0].detach().cpu())
fig_1.show()
self.writer.add_figure('alpha1', fig_1)
return fc_out, domain_fc_out, reg
def plot_conn_mat(conn_matrix, label_names):
import matplotlib as mpl
import seaborn as sns
from matplotlib import colors
from matplotlib import pyplot as plt
from nilearn.plotting import plot_matrix
plt.rcParams['axes.facecolor'] = 'black'
plt.rcParams['figure.facecolor'] = 'black'
colors.Normalize(vmin=0, vmax=1)
clust_pal = mpl.colors.ListedColormap(sns.color_palette("RdBu_r", 40))
rois_num = conn_matrix.shape[0]
if rois_num < 100:
try:
fig = plot_matrix(conn_matrix, figure=(10, 10), labels=label_names, vmax=1, vmin=0, reorder=True,
auto_fit=True, grid=False, colorbar=False, cmap=clust_pal)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
else:
try:
fig = plot_matrix(conn_matrix, figure=(10, 10), vmax=1, vmin=0, auto_fit=True, grid=False,
colorbar=False, cmap=clust_pal)
except RuntimeWarning:
print('Connectivity matrix too sparse for plotting...')
cur_axes = plt.gca()
for spine in cur_axes.axes.spines.values():
spine.set_visible(False)
fig.figure.tight_layout(pad=0)
fig.figure.patch.set_facecolor('black')
cur_axes.axes.get_xaxis().set_visible(False)
cur_axes.axes.get_yaxis().set_visible(False)
cur_axes.axes.get_xaxis().set_ticks([])
cur_axes.axes.get_yaxis().set_ticks([])
cur_axes.axes.get_xaxis().set_ticklabels([])
cur_axes.axes.get_yaxis().set_ticklabels([])
cur_axes.axes.get_xaxis().set_major_locator(plt.NullLocator())
cur_axes.axes.get_yaxis().set_major_locator(plt.NullLocator())
cur_axes.set_frame_on(False)
cur_axes.margins(0,0, tight=True)
cur_axes.set_axis_off()
return fig
def compute_faster_correlation_matrix_from_hypergraph(hypergraph, time_series, savefigure=None):
hypergraph_shape = hypergraph.shape
correlation_matrix = np.zeros(hypergraph_shape)
hypergraph = hypergraph.astype(bool)
for i in range(hypergraph_shape[0]):
print(i)
for j in range(i + 1, hypergraph_shape[0], 1):
correlation_matrix[i, j] = dcor.u_distance_correlation_sqr(time_series[:, hypergraph[i, :]],
time_series[:, hypergraph[j, :]])
#correlation_matrix[j, i] = correlation_matrix[i, j]
if savefigure is not None:
figure = plt.figure(figsize=(6, 6))
plotting.plot_matrix(correlation_matrix, figure=figure, vmax=1., vmin=0.)
figure.savefig(savefigure, dpi=200)
plt.close(figure)
return correlation_matrix
def plot_conn_mat(conn_matrix, labels, out_path_fig, cmap, dpi_resolution=300):
"""
Plot a connectivity matrix.
Parameters
----------
conn_matrix : array
NxN matrix.
labels : list
List of string labels corresponding to ROI nodes.
out_path_fig : str
File path to save the connectivity matrix image as a .png figure.
"""
import matplotlib
matplotlib.use("agg")
from matplotlib import pyplot as plt
from nilearn.plotting import plot_matrix
from pynets.core import thresholding
conn_matrix_bin = thresholding.binarize(conn_matrix)
conn_matrix = thresholding.standardize(conn_matrix)
conn_matrix_plt = np.nan_to_num(np.multiply(conn_matrix, conn_matrix_bin))
try:
plot_matrix(
conn_matrix_plt,
figure=(10, 10),
labels=labels,
vmax=np.abs(np.max(conn_matrix_plt)),
vmin=-np.abs(np.max(conn_matrix_plt)),
reorder="average",
auto_fit=True,
grid=False,
colorbar=False,
cmap=cmap,
)
except RuntimeWarning:
print("Connectivity matrix too sparse for plotting...")
plt.savefig(out_path_fig, dpi=dpi_resolution)
plt.close()
return
def plot_connectome_mixture(data=None, index=None, metric="correlation", save_as=None, show=False, **kwargs):
# extract time series from all subjects and concatenate them
mm = data.X[index, :].copy()
time_series = [np.vstack(mm)]
# calculate correlation matrices across indexed frames in data
connectome_measure = ConnectivityMeasure(kind=metric)
connectome_measure.fit_transform(time_series)
connectivity = connectome_measure.mean_
np.fill_diagonal(connectivity, 0)
#connectivity[np.abs(connectivity) < 0.2] = 0.0
# grab center coordinates for atlas labels
atlas = kwargs.pop('atlas', data.atlas)
coords = plotting.find_parcellation_cut_coords(labels_img=atlas)
# assign node colors
cmap = kwargs.pop('cmap', 'jet')
node_cmap = plt.get_cmap('bone')
node_norm = mpl.colors.Normalize(vmin=-0.8, vmax=1.2)
node_colors = np.ravel([_[-1] for i,_ in enumerate(coords)])
node_colors = [_ / np.max(node_colors) for _ in node_colors]
node_colors = node_cmap(node_norm(node_colors))
# plot connectome matrix
fig = plt.figure(figsize=(12,5))
ax = plt.subplot2grid((1, 2), (0, 1), rowspan=1, colspan=1)
display = plotting.plot_matrix(
connectivity,
vmin=-.5, vmax=.5, colorbar=True, cmap=cmap,
axes=ax, #title='{} Matrix'.format(metric.title()),
)
# plot connectome with 99.7% edge strength in the connectivity
ax = plt.subplot2grid((1, 2), (0, 0), rowspan=1, colspan=1)
display = plotting.plot_connectome(
connectivity, coords,
edge_threshold="99.9%", display_mode='z',
node_color=node_colors, node_size=20, edge_kwargs=dict(lw=4),
edge_vmin=-.8, edge_vmax=.8, edge_cmap=cmap,
colorbar=False, black_bg=not True, alpha=0.5,
annotate=False,
axes=ax,
)
if show is True:
plt.show()
plt.subplots_adjust(left=0.05, right=0.95, bottom=0.05, top=0.95)
if save_as:
fig.savefig(save_as, transparent=True)#, facecolor='slategray', edgecolor='white')
plt.close(fig)
return display
# `time_series` is now a 2D matrix, of shape (number of time points x
# number of regions)
print(time_series.shape)
############################################################################
# Build and display a correlation matrix
# ---------------------------------------
from nilearn.connectome import ConnectivityMeasure
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Display the correlation matrix
import numpy as np
from nilearn import plotting
# Mask out the major diagonal
np.fill_diagonal(correlation_matrix, 0)
plotting.plot_matrix(correlation_matrix, labels=labels, colorbar=True,
vmax=0.8, vmin=-0.8)
############################################################################
# And now display the corresponding graph
# ----------------------------------------
from nilearn import plotting
coords = atlas.region_coords
# We threshold to keep only the 20% of edges with the highest value
# because the graph is very dense
plotting.plot_connectome(correlation_matrix, coords,
edge_threshold="80%", colorbar=True)
plotting.show()
##############################################################################
# Compute and display a correlation matrix
# -----------------------------------------
from nilearn.connectome import ConnectivityMeasure
correlation_measure = ConnectivityMeasure(kind='correlation')
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Plot the correlation matrix
import numpy as np
from nilearn import plotting
# Make a large figure
# Mask the main diagonal for visualization:
np.fill_diagonal(correlation_matrix, 0)
# The labels we have start with the background (0), hence we skip the
# first label
plotting.plot_matrix(correlation_matrix, figure=(10, 8), labels=labels[1:],
vmax=0.8, vmin=-0.8)
###############################################################################
# Same thing without confounds, to stress the importance of confounds
# --------------------------------------------------------------------
time_series = masker.fit_transform(fmri_filenames)
# Note how we did not specify confounds above. This is bad!
correlation_matrix = correlation_measure.fit_transform([time_series])[0]
# Mask the main diagonal for visualization:
np.fill_diagonal(correlation_matrix, 0)
plotting.plot_matrix(correlation_matrix, figure=(10, 8), labels=labels[1:],
vmax=0.8, vmin=-0.8, title='No confounds')
# ----------------------------------------
from matplotlib import pyplot as plt
plt.figure(figsize=(4, 3))
plt.boxplot([cv_scores_ova, cv_scores_ovo])
plt.xticks([1, 2], ['One vs All', 'One vs One'])
plt.title('Prediction: accuracy score')
##############################################################################
# Plot a confusion matrix
# ------------------------
# We fit on the the first 10 sessions and plot a confusion matrix on the
# last 2 sessions
from sklearn.metrics import confusion_matrix
from nilearn.plotting import plot_matrix
svc_ovo.fit(X[session < 10], y[session < 10])
y_pred_ovo = svc_ovo.predict(X[session >= 10])
plot_matrix(confusion_matrix(y_pred_ovo, y[session >= 10]),
labels=unique_conditions,
title='Confusion matrix: One vs One', cmap='hot_r')
svc_ova.fit(X[session < 10], y[session < 10])
y_pred_ova = svc_ova.predict(X[session >= 10])
plot_matrix(confusion_matrix(y_pred_ova, y[session >= 10]),
labels=unique_conditions,
title='Confusion matrix: One vs All', cmap='hot_r')
plt.show()
covariance_estimator.fit(timeseries)
###############################################################################
# and get the ROI-to-ROI covariance matrix.
matrix = covariance_estimator.covariance_
print('Covariance matrix has shape {0}.'.format(matrix.shape))
###############################################################################
# Plot matrix and graph
# ---------------------
#
# We use nilearn.plotting.plot_matrix to visualize our correlation matrix
# and display the graph of connections with `nilearn.plotting.plot_connectome`.
from nilearn import plotting
plotting.plot_matrix(matrix, vmin=-1., vmax=1., colorbar=True,
title='Power correlation matrix')
# Tweak edge_threshold to keep only the strongest connections.
plotting.plot_connectome(matrix, coords, title='Power correlation graph',
edge_threshold='99.8%', node_size=20, colorbar=True)
###############################################################################
# Note the 1. on the matrix diagonal: These are the signals variances, set to
# 1. by the `spheres_masker`. Hence the covariance of the signal is a
# correlation matrix
###############################################################################
# Connectome extracted from Dosenbach's atlas
# -------------------------------------------
#
# We repeat the same steps for Dosenbach's atlas.
# Generate synthetic data
from nilearn._utils.testing import generate_group_sparse_gaussian_graphs
n_subjects = 20 # number of subjects
n_displayed = 3 # number of subjects displayed
subjects, precisions, topology = generate_group_sparse_gaussian_graphs(
n_subjects=n_subjects, n_features=10, min_n_samples=30, max_n_samples=50,
density=0.1)
from nilearn import plotting
fig = plt.figure(figsize=(10, 7))
plt.subplots_adjust(hspace=0.4)
for n in range(n_displayed):
ax = plt.subplot(n_displayed, 4, 4 * n + 1)
max_precision = precisions[n].max()
plotting.plot_matrix(precisions[n], vmin=-max_precision,
vmax=max_precision, axes=ax, colorbar=False)
if n == 0:
plt.title("ground truth")
plt.ylabel("subject %d" % n)
# Run group-sparse covariance on all subjects
from nilearn.connectome import GroupSparseCovarianceCV
gsc = GroupSparseCovarianceCV(max_iter=50, verbose=1)
gsc.fit(subjects)
for n in range(n_displayed):
ax = plt.subplot(n_displayed, 4, 4 * n + 2)
max_precision = gsc.precisions_[..., n].max()
plotting.plot_matrix(gsc.precisions_[..., n], axes=ax, vmin=-max_precision,
# saving each subject correlation to correlations
correlations.append(correlation)
# Mean of all correlations
import numpy as np
mean_correlations = np.mean(correlations, axis=0).reshape(n_regions_extracted,
n_regions_extracted)
###############################################################################
# Plot resulting connectomes
# ----------------------------
title = 'Correlation between %d regions' % n_regions_extracted
# First plot the matrix
display = plotting.plot_matrix(mean_correlations, vmax=1, vmin=-1,
colorbar=True, title=title)
# Then find the center of the regions and plot a connectome
regions_img = regions_extracted_img
coords_connectome = plotting.find_probabilistic_atlas_cut_coords(regions_img)
plotting.plot_connectome(mean_correlations, coords_connectome,
edge_threshold='90%', title=title)
################################################################################
# Plot regions extracted for only one specific network
# ----------------------------------------------------
# First, we plot a network of index=4 without region extraction (left plot)
from nilearn import image
# Compute the sparse inverse covariance
# --------------------------------------
from sklearn.covariance import GraphLassoCV
estimator = GraphLassoCV()
estimator.fit(time_series)
##############################################################################
# Display the connectome matrix
# ------------------------------
from nilearn import plotting
# Display the covariance
# The covariance can be found at estimator.covariance_
plotting.plot_matrix(estimator.covariance_, labels=labels,
figure=(9, 7), vmax=1, vmin=-1,
title='Covariance')
##############################################################################
# And now display the corresponding graph
# ----------------------------------------
coords = atlas.region_coords
plotting.plot_connectome(estimator.covariance_, coords,
title='Covariance')
##############################################################################
# Display the sparse inverse covariance
# --------------------------------------
# we negate it to get partial correlations
