def computeLabelLayers(labelFile, surfaceAdjacency, borderFile):
"""
Method to find level structures of vertices, where each structure is a set
of vertices that are a distance k away from the border vertices.
"""
label = loaded.load(labelFile, 0)
surfAdj = loaded.load(surfaceAdjacency)
borders = loaded.load(borderFile)
# get set of non-zero labels in label file
L = set(label) - set([0])
layers = {}.fromkeys(L)
"""
fullList = Parallel(n_jobs=NUM_CORES)(delayed(labelLayers)(lab,
np.where(label == lab)[0],
surfAdj,borders[lab]) for lab in L)
"""
for i, labelValue in enumerate(L):
if labelValue in borders:
inds = np.where(label == labelValue)[0]
bm = borders[labelValue]
layers[labelValue] = labelLayers(labelValue, inds, surfAdj, bm)
return layers
def main(args):
components = loaded.load(args.components)
rest = loaded.load(args.rest)
if args.mask:
mask = loaded.load(args.mask)
components = components[np.where(mask)]
rest = rest[np.where(mask), :]
rest = rest.squeeze()
# instantiate dual regressor
Regressor = dr.Regressor(standardize=args.standardize,
hdr_alpha=args.alpha,
tr=args.rep_time,
s_filter=args.filter)
# fit spatial and temporal regression components
Regressor.fit(rest, components)
temporal = {'temporal': Regressor.temporal_}
spatial = {'spatial': Regressor.spatial_}
if args.mask:
temp = np.zeros((mask.shape[0], spatial['spatial'].shape[1]))
temp[np.where(mask), :] = spatial['spatial']
spatial['spatial'] = temp
sio.savemat(file_name='.'.join([args.output, 'Temporal.mat']),
mdict=temporal)
sio.savemat(file_name='.'.join([args.output, 'Spatial.mat']),
mdict=spatial)
def regionalizeStructures(timeSeries, levelStructures, midlines, level, R,
measure='median'):
"""
Method to regionalize the resting state connectivity, using only vertices
included at a minimum level away from the border vertices.
Parameters:
- - - - -
timeSeries : input resting state file
levelStrucutres : levelStructures created by computeLabelLayers
".RegionalLayers.p" file
level : depth to constaint layers at
midlines : path to midline indices
measure : measure to apply to correlation values ['mean','median']
"""
assert measure in ['median', 'mean']
assert level >= 1
resting = loaded.load(timeSeries)
midlines = loaded.load(midlines)
levelSets = loaded.load(levelStructures)
resting[midlines, :] = 0
condensedLevels = layerCondensation(levelSets, level)
regionalized = np.zeros((resting.shape[0], R))
# get the central vertices for region_id
for rid in condensedLevels.keys():
subregion = condensedLevels[rid]
subregion = list(set(subregion).difference(set(midlines)))
print('# subvertices: {:}'.format(len(subregion)))
# if subregion has at least 1 vertex
if len(subregion):
subrest = resting[subregion, :]
if np.ndim(subrest) == 1:
subrest.shape += (1,)
if subrest.shape[1] != resting.shape[1]:
subrest = subrest.T
corr = metrics.pairwise.pairwise_distances(
resting, subrest, metric='correlation')
if measure == 'median':
regionalized[:, rid-1] = np.median(1-corr, axis=1)
else:
regionalized[:, rid-1] = np.mean(1-corr, axis=1)
regionalized[midlines, :] = 0
return regionalized
def prep_data(subject_id, sreg, treg, region_map, dir_func, dir_dist,
hemisphere, nsize):
"""
Source and target distance and correlation data for modeling.
Parameters:
- - - - -
subject_id: string
Subject name
sreg, treg: string
source, target region pair
region_map: dictioary
mapping from region name to cortical indices
dir_func: string
Directory where Nearest Neighbor correlation maps exist
dir_dist: string:
Directory where Nearest Neighbor distance maps exist
hemisphere: string
Hemisphere to process, in ['L', 'R']
nsize: int
neighborhood size
Returns:
- - - -
inds: int, array
indices of source voxels
x: float, array
dispersion vector
y: float, array
correlation vector
"""
base_knn = '%s.%s.knn_mean.2.%s.func.gii' % (subject_id, hemisphere, treg)
in_knn = '%s%s/%s' % (dir_func, subject_id, base_knn)
knn = loaded.load(in_knn)
base_dist = '%s.%s.Distance.2.%s.func.gii' % (subject_id, hemisphere, treg)
in_dist = '%s%s/%s' % (dir_dist, subject_id, base_dist)
dist = loaded.load(in_dist)
source_indices = region_map[sreg]
nsize = nsize - 1
x = dist[source_indices, nsize]
y = knn[source_indices, nsize]
inds = np.arange(len(source_indices))[~np.isnan(y)]
inds = inds[y[inds] != 0]
x = x[inds]
y = y[inds]
return [inds, x, y]
def _raw_fit(self, input_files):
"""
:param input_files:
:return:
"""
W = []
for temp_file in input_files[:self.s_init]:
temp_matrix = loaded.load(temp_file)
nans = np.isnan(temp_matrix).sum()
infs = np.isinf(temp_matrix).sum()
if nans > 0 or infs > 0:
print('%s has %i NANs and %i INFs' % (temp_file, nans, infs))
continue
else:
W.append(self._merge_and_reduce(temp_matrix))
# Compute initial estimate of spatial eigenvectors
print('Computing initial estimate for {:} subjects.'.format(
self.s_init))
W = np.row_stack(W).squeeze()
print('Initialization matrix: {:}'.format(W.shape))
W = self._estimate(W)
print('Initial estimate shape: {:}'.format(W.shape))
for k, temp_file in enumerate(input_files[self.s_init:]):
print('Adding file # %i' % (k + 1 + self.s_init))
temp_matrix = loaded.load(temp_file)
nans = np.isnan(temp_matrix).sum()
infs = np.isinf(temp_matrix).sum()
if nans > 0 or infs > 0:
print('%s has %i NANs and %i INFs' % (temp_file, nans, infs))
continue
else:
print('Adding file: %s' % (temp_file))
update_data = self._merge_and_reduce(temp_matrix)
W = np.row_stack([W, update_data])
temporal, variance, spatial = randomized_svd(W,
self.m_eigen,
n_iter=3)
W = np.dot(np.diag(variance), spatial)
self.components_ = W[0:self.n_components, :]
def populationRegionSize(subjectList, labelDirectory, extension):
"""
Method to compute the sizes of each region across the training set.
Parameters:
- - - - -
subjectList : (list,.txt) list of subjects to include
labelDirectory : directory containing the label files
extension : label file extension
"""
if isinstance(subjectList, str):
with open(subjectList, 'r') as inFile:
subjects = inFile.readlines()
subjects = [x.strip() for x in subjects]
elif isinstance(subjectList, list):
subjects = subjectList
else:
print('Incorrect subject list type.')
labelSizes = {k: [] for k in np.arange(1, 181)}
for subj in subjects:
inLabel = labelDirectory + str(subj) + extension
if os.path.isfile(inLabel):
pred = loaded.load(inLabel)
for k in labelSizes.keys():
if k in set(pred):
labelSizes[k].append(len(np.where(pred == k)[0]))
return labelSizes
def _merge_and_reduce(self, input_files):
"""
Clean, temporally reduce, and concatenate resting state matrix files.
:param input_files: list of input resting state matrix files
:return signals: concatenated resting state arrays
"""
signals = []
for inp in input_files:
print('Loading {:}'.format(inp.split('/')[-1]))
matrix = loaded.load(inp)
try:
z
except NameError:
z = np.zeros((matrix.shape[0],))
else:
pass
finally:
zinds = np.where(np.abs(matrix).sum(1) == 0)[0]
if len(zinds) > 3000:
pass
else:
z[zinds] += 1
matrix = clean(matrix,standardize=self.standardize,
low_pass=self.low_pass,high_pass=self.high_pass,
t_r=self.t_r)
if self.pca_filter:
matrix = self._reduce(matrix)
signals.append(matrix)
self.mask = z.astype(np.bool)
print(self.mask.sum())
print(len(signals))
signals = np.column_stack(signals)
signals = signals[~self.mask, :]
print(signals.shape)
return signals.T
def func2mat(in_func, out_mat):
"""
Method to quickly convert between Matlab .mat and Gifti .func.gii files.
Parameters:
- - - - -
in_func: str
Gifti .func.gii or .label.gii file to convert
out_mat: str
Matlab .mat file to generate
"""
func = loaded.load(in_func)
func = func.squeeze()
mat = {'data': func}
sio.savemat(out_mat, mat)
def mat2func(in_mat, out_func, hemisphere):
"""
Method to quickly convert between Matlab .mat and Gifti .func.gii files.
Generally, the Matlab file will be a 1-dimensional array. If it is not,
each column (dimension) will be saved as a DataArray object in the
Gifti file.
Parameters:
- - - - -
in_mat: str
Matlab .mat file to convert
out_func: str
Gifti .func.gii to create
"""
mat = loaded.load(in_mat)
mat = mat.squeeze()
if mat.ndim > 1:
mat = mat.T.tolist()
write.save(mat, out_func, hemisphere)
def _merge_and_reduce(self, input_file):
"""
Clean, temporally reduce, and concatenate resting state matrix files.
:param input_files: list of input resting state matrix files
:return signals: concatenated resting state arrays
"""
print('Loading {:}'.format(input_file.split('/')[-1]))
matrix = loaded.load(input_file)
if matrix.shape[0] < matrix.shape[1]:
matrix = matrix.T
matrix = clean(matrix,
standardize=self.standardize,
low_pass=self.low_pass,
high_pass=self.high_pass,
t_r=self.t_r)
if self.pca_filter:
matrix = self._reduce(matrix)
return matrix.T
default=None)
parser.add_argument('-d',
'--dir',
help='Output directory.',
required=True,
type=str)
parser.add_argument('-bo',
'--outbase',
help='Output base name.',
required=True,
type=str)
print('Generating region map...')
args = parser.parse_args()
label = loaded.load(args.label)
R = re.Extractor(args.label)
indices = R.indices(R.map_regions(), args.rois)
sort_inds = np.argsort(indices)
print('Loading eta matrix...')
eta = loaded.load(args.eta)
eta[np.isinf(eta)] = 0
eta[np.isnan(eta)] = 0
cmin = args.clusters[0]
cmax = args.clusters[1]
print('Generating adjacency matrix...')
surf = nb.load(args.surface)
vertices = surf.darrays[0].data
parser.add_argument('-d',
'--dir',
help='Output directory.',
required=True,
type=str)
parser.add_argument('-bo',
'--outbase',
help='Output base name.',
required=True,
type=str)
args = parser.parse_args()
print('Subject: {:}'.format(args.subject))
label = loaded.load(args.label)
R = re.Extractor(args.label)
region_map = R.map_regions()
indices = []
for r in args.rois:
indices.append(region_map[r])
indices = np.concatenate(indices)
eta = loaded.load(args.eta)
eta[np.isinf(eta)] = 0
eta[np.isnan(eta)] = 0
cmin = args.clusters[0]
cmax = args.clusters[1]
parser.add_argument('-e',
'--evecs',
help='Number of eigenvalues to compute.',
required=False,
default=5,
type=int)
parser.add_argument('-n',
'--normalize',
help='Normalize eigenvectors to [0,1].',
required=False,
default=True,
type=bool)
args = parser.parse_args()
clusters = loaded.load(args.cluster)
try:
assert os.path.isfile(args.similarity)
except:
raise ('Similarity file does not exist.')
else:
print('Loading similarity file.')
sims = h5py.File(name=args.similarity, mode='r')
labels = list(sims.keys())
outEvecs = ''.join([args.dir, args.outbase, '.Evecs.h5'])
evecs = h5py.File(name=outEvecs, mode='a')
z = np.zeros((clusters.shape[0], args.evecs * len(labels)))
help='Base output name, without extension.', required=True, type=str)
args = parser.parse_args()
if not os.path.exists(args.dir):
print('Output directory does not exist -- creating now.')
os.mkdir(args.dir)
# Load region of interest
try:
assert os.path.isfile(args.cluster)
except:
raise('Mask ROI does not exist.')
else:
print('Loading ROI.')
cluster = loaded.load(args.cluster)
# Load feature matrix
try:
assert os.path.isfile(args.features)
except:
raise('Feature file for {:} does not exist.'.format(args.subject))
else:
print('Loading feature data.')
F = loaded.load(args.features)
n, p = F.shape
if n < p:
F = F.T
F = (F-F.mean(1)[:, None]) / (F.std(1)[:, None])
def neighborhoodErrorMap(labVal, labelAdjacency, truthLabFile,
predLabFile, labelLookup, outputColorMap):
"""
Method to visualize the results of a prediction map, focusing in on a
spefic core label.
Parameters:
- - - - -
core : region of interest
labelAdjacency : label adjacency list
truthLabFile : ground truth label file
predLabFile : predicted label file
labelLookup : label color lookup table
outputColorMap : new color map for label files
"""
# load files
labAdj = loaded.load(labelAdjacency)
truth = loaded.load(truthLabFile, 0)
pred = loaded.load(predLabFile, 0)
# extract current colors from colormap
parsedColors = parseColorLookUpFile(labelLookup)
# initialize new color map file
color_file = open(outputColorMap, "w")
trueColors = ' '.join(map(str, [255, 255, 255]))
trueName = 'Label {}'.format(labVal)
trueRGBA = '{} {} {}\n'.format(labVal, trueColors, 255)
trueStr = '\n'.join([trueName, trueRGBA])
color_file.writelines(trueStr)
# get labels that neighbor core
neighbors = labAdj[labVal]
# get indices of core label in true map
truthInds = np.where(truth == labVal)[0]
# initialize new map
visualizeMap = np.zeros((truth.shape))
visualizeMap[truthInds] = labVal
# get predicted label values existing at truthInds
predLabelsTruth = pred[truthInds]
for n in neighbors:
# get color code for label, adjust and write text to file
oriName = 'Label {}'.format(n)
oriCode = parsedColors[n]
oriColors = ' '.join(map(str, oriCode))
oriRGBA = '{} {} {}\n'.format(n, oriColors, 255)
oriStr = '\n'.join([oriName, oriRGBA])
color_file.writelines(oriStr)
adjLabel = n+180
adjName = 'Label {}'.format(adjLabel)
adjColors = shiftColor(oriCode, mag=30)
adjColors = ' '.join(map(str, adjColors))
adjRGBA = '{} {} {}\n'.format(adjLabel, adjColors, 255)
adjStr = '\n'.join([adjName, adjRGBA])
color_file.writelines(adjStr)
# find where true map == n and set this value
n_inds = np.where(truth == n)[0]
visualizeMap[n_inds] = n
# find where prediction(core) == n, and set to adjusted value
n_inds = np.where(predLabelsTruth == n)[0]
visualizeMap[truthInds[n_inds]] = adjLabel
color_file.close()
return visualizeMap
parser.add_argument('-bo', '--base_out', help='Base output name, without extension.', required=True, type=str)
args = parser.parse_args()
if not os.path.exists(args.dir):
print('Output directory does not exist -- creating now.')
os.mkdir(args.dir)
# Load region of interest
try:
assert os.path.isfile(args.roi)
except:
raise('Mask ROI does not exist.')
else:
print('Loading ROI.')
roi = loaded.load(args.roi)
roi = (roi>0)
# Load target region
if args.target:
try:
assert os.path.isfile(args.target)
except:
raise('Target mask does not exist.')
else:
print('Loading target.')
target_exists = True
target = loaded.load(args.target)
target = (target>0)
else:
target_exists = False
print('Computing similarity matrix.')
E2 = conmap.eta2(R)
return [E2, R]
if not os.path.exists(args.dir):
print('Output directory does not exist -- creating now.')
os.mkdir(args.dir)
# Load region of interest
if not os.path.isfile(args.label):
raise FileExistsError('Label file does not exist.')
else:
label = loaded.load(args.label)
R = re.Extractor(args.label)
index_map = R.map_regions()
# get source and target indices
sinds = index_map[args.sroi]
if args.troi:
tinds = index_map[args.troi]
else:
tinds = list(set(np.arange(label.shape[0])).difference(set(sinds)))
# Load feature matrix
if not os.path.isfile(args.features):
raise FileExistsError('Features file does not exist.')
else:
print('Loading feature data.')
try:
assert os.path.isfile(args.label)
except:
raise ('Label file does not exist.')
else:
R = re.Extractor(args.label)
regions = R.map_regions()
inds = R.indices(regions, args.sroi)
try:
assert os.path.isfile(args.similarity)
except:
raise ('Similarity matrix does not exist.')
else:
sim = loaded.load(args.similarity)
sim[np.isnan(sim)] = 0
sim[np.isinf(sim)] = 0
row_sums = np.where(np.abs(sim).sum(1) != 0)[0]
col_sums = np.where(np.abs(sim).sum(0) != 0)[0]
assert np.all(row_sums == col_sums)
sim = sim[:, row_sums][col_sums, :]
inds = inds[row_sums]
if not os.path.exists(outEvecs):
print('Computing distance matrix.')
distance = conmap.norm(sim)
def connectopyBy(subject_id, hemisphere, labeldir, conndir, nsize=5):
"""
Generate DataFrame objects for each source region. Contains the connectopy
data for the first two eigenvectors of the source region, along with the
pairwise correlation / dispersion data.
Parameters:
- - - - -
subject_id: string
Subject name
hemisphere: string
Hemisphere to process ['L', 'R']
labeldir: string
Directory where label files exist
conndir: string
Directory where connectopy maps exist
nsize: int
Mapping neighborhood size
"""
dir_out = '%sPlots/%s/' % (conndir, subject_id)
dir_evec = '%sDesikan/%s/' % (conndir, subject_id)
dir_func = '%sNeighborFunctional/%s/' % (conndir, subject_id)
dir_disp = '%sNeighborDistances/%s/' % (conndir, subject_id)
label_file = '%s%s.%s.aparc.32k_fs_LR.label.gii' % (labeldir, subject_id,
hemisphere)
R = re.Extractor(label_file)
region_map = R.map_regions()
regions = list(region_map.keys())
regions.sort()
regions = [x for x in regions if x not in ['corpuscallosum']]
col_names = ['e1', 'e2'] + regions
for i, source_region in enumerate(regions):
func_df = pd.DataFrame(columns=col_names, index=None)
disp_df = pd.DataFrame(columns=col_names, index=None)
sinds = region_map[source_region]
evec_file = '%s%s.%s.%s.2.brain.Evecs.func.gii' % (
dir_evec, subject_id, hemisphere, source_region)
evecs = loaded.load(evec_file)
func_df['e1'] = evecs[sinds, 0]
func_df['e2'] = evecs[sinds, 1]
disp_df['e1'] = evecs[sinds, 0]
disp_df['e2'] = evecs[sinds, 1]
for j, target_region in enumerate(regions):
if source_region != target_region:
func_file = '%s%s.%s.%s.2.%s.mean_knn.func.gii' % (
dir_func, subject_id, hemisphere, source_region,
target_region)
func = loaded.load(func_file)
func = func[sinds, nsize - 1]
func_df[target_region] = func
disp_file = '%s%s.%s.Distance.2.%s.func.gii' % (
dir_disp, subject_id, hemisphere, target_region)
disp = loaded.load(disp_file)
disp = disp[sinds, nsize - 1]
disp_df[target_region] = disp
else:
disp_df[target_region] = np.nan
func_df[target_region] = np.nan
out_func = '%s%s.%s.%s.Functional.csv' % (dir_out, subject_id,
hemisphere, source_region)
out_dist = '%s%s.%s.%s.Dispersion.csv' % (dir_out, subject_id,
hemisphere, source_region)
func_df.to_csv(out_func, index=False)
disp_df.to_csv(out_dist, index=False)
help='Downsample the number of files.',
required=False,
type=int,
default=None)
args = parser.parse_args()
with open(args.file_list, 'r') as f:
files = f.read().split()
np.random.shuffle(files)
if args.size:
files = files[:args.size]
if args.mask:
mask = loaded.load(args.mask)
print('Fitting MIGP with {:} components...'.format(args.number_components))
M = migp.MIGP(n_components=args.number_components,
low_pass=args.low_pass,
m_eigen=args.eigens,
s_init=args.number_subjects,
t_r=args.rep_time,
mask=mask)
M.fit(files)
components = M.components_
if args.mask:
C = np.zeros((mask.shape[0], components.shape[1]))
C[np.where(mask),:] = components)