def fooofmodel():
import sys
import numpy as np
from scipy.io import loadmat, savemat
from fooof import FOOOFGroup
import matplotlib.pyplot as plt
data = loadmat('ModelPowSpctraForFOOOF.mat')
# Unpack data from dictionary, and squeeze numpy arrays
freqs = np.squeeze(data['fx']).astype('float')
psds = np.squeeze(data['avgpwr']).astype('float')
# ^Note: this also explicitly enforces type as float (type casts to float64, instead of float32)
# This is not strictly necessary for fitting, but is for saving out as json from FOOOF, if you want to do that
# Transpose power spectra, to have the expected orientation for FOOOF
#psds = psds.T
fg = FOOOFGroup(peak_threshold=7,
peak_width_limits=[3, 14]) #, aperiodic_mode='knee'
#fg.report(freqs, psds, [1, 290])
#fg.fit(freqs,psds,[0.2,290])
fg.fit(freqs, psds, [1, 290])
fg.plot()
fg.save_report('modelfits')
slp = fg.get_params('aperiodic_params', 'exponent')
off = fg.get_params('aperiodic_params', 'offset')
r = fg.get_params('r_squared')
savemat('slp.mat', {'slp': slp})
savemat('off.mat', {'off': off})
savemat('r.mat', {'r': r})
return
def indiv_fooofcode():
import sys
import numpy as np
from scipy.io import loadmat, savemat
from fooof import FOOOFGroup
import matplotlib.pyplot as plt
patientcount = 16
alloffset = []
allr2 = []
allexps = []
allcfs = []
for k in range(1,patientcount+1):
matfile = 'indiv_' + str(k) + '.mat'
data = loadmat(matfile)
# Unpack data from dictionary, and squeeze numpy arrays
freqs = np.squeeze(data['indiv_frq']).astype('float')
psds = np.squeeze(data['indiv_pow']).astype('float')
# ^Note: this also explicitly enforces type as float (type casts to float64, instead of float32)
# This is not strictly necessary for fitting, but is for saving out as json from FOOOF, if you want to do that
fg = FOOOFGroup(peak_threshold=7,peak_width_limits=[3, 14])#, aperiodic_mode='knee'
#fg.report(freqs, psds, [30, 300])
#fg.fit(freqs,psds,[float(sys.argv[1]),float(sys.argv[2])])
fg.fit(freqs,psds,[float(sys.argv[1]),float(sys.argv[2])])
fg.plot()
reportname = str(k) + '_indiv result'
fg.save_report(reportname)
#print(fg.group_results)
r2 = fg.get_params('r_squared')
allr2.append(r2)
exps = fg.get_params('aperiodic_params', 'exponent')
allexps.append(exps)
centerfrq = fg.get_params('peak_params','CF')
allcfs.append(centerfrq)
offset = fg.get_params('aperiodic_params','offset')
alloffset.append(offset)
#knee = fg.get_params('aperiodic_params','knee')
#savemat('knee_allpeeps.mat', {'knee' : knee})
#NOW OUTSIDE OF BIG FORLOOP!
#concat everythin.
savemat('all_offset.mat',{'all_offset' : alloffset})
savemat('all_r2.mat', {'all_r2' : allr2})
savemat('all_exps.mat', {'all_exps' : allexps})
savemat('all_cfs.mat',{'all_cfs' : allcfs}) #these are cell arrays! I didn't even mean for them to be but heck yea useful
def fooofy(components, spectra, freq_range):
"""
A FOOOF Function, gets exponent parameters
"""
fg = FOOOFGroup(max_n_peaks=0, aperiodic_mode='fixed', verbose = False) #initialize FOOOF object
#print(spectra.shape, components.shape) #Use this line if things go weird
fg.fit(components, spectra, freq_range) # THIS IS WHERE YOU SAY WHICH FREQ RANGE TO FIT
m_array = fg.get_params('aperiodic_params', 'exponent')
r2_array = fg.get_params('r_squared') #correlation between components (freqs or PCs) and spectra (powers or eigvals)
#fg.r_squared_
return m_array, r2_array
def return_fg_fits(fg_file, fg_folder):
"""
Return fitted parameters from FOOOFGroup, in the following order:
aperiodic, peaks, error, r-squared.
"""
fg = FOOOFGroup()
fg.load(fg_file, fg_folder)
aps = fg.get_params('aperiodic_params') # get aperiodic parameters
# need to resave the old fooof files for this loading to work
#pks = fg.get_params('peak_params')
pks = []
err = fg.get_params('error')
r2s = fg.get_params('r_squared')
return aps, pks, err, r2s
def foof2mat_model():
import sys
from scipy.io import loadmat, savemat
import sklearn
from scipy import io
import scipy
import numpy as np
from fooof import FOOOF
import neurodsp
import matplotlib.pyplot as plt
import pacpy
import h5py
import matplotlib
from matplotlib import lines
import math
from neurodsp import spectral
# FOOOF imports: get FOOOF & FOOOFGroup objects
from fooof import FOOOFGroup
dat = hdf5storage.loadmat(str(sys.argv[1]))
frq_ax = np.linspace(0, 500, 5001) #dat["fx"][0]
pwr_spectra = dat['avgpwr'] #dat["powall"]
#pwr_spectra=x['x']
# Initialize a FOOOFGroup object - it accepts all the same settings as FOOOF
fg = FOOOFGroup(peak_threshold=7,
peak_width_limits=[3, 14]) #, aperiodic_mode='knee'
frange = (1, 290)
# Fit a group of power spectra with the .fit() method# Fit a
# The key difference (compared to FOOOF) is that it takes a 2D array of spectra
# This matrix should have the shape of [n_spectra, n_freqs]
fg.fit(frq_ax, pwr_spectra, frange)
slp = fg.get_params('aperiodic_params', 'exponent')
off = fg.get_params('aperiodic_params', 'offset')
r = fg.get_params('r_squared')
savemat('slp.mat', {'slp': slp})
savemat('off.mat', {'off': off})
savemat('r.mat', {'r': r})
return
def fooofy(components, spectra, x_range, group=True):
"""
fit FOOOF model on given spectrum and return params
components: frequencies or PC dimensions
spectra: PSDs or variance explained
x_range: range for x axis of spectrum to fit
group: whether to use FOOOFGroup or not
"""
if group:
fg = FOOOFGroup(max_n_peaks=0, aperiodic_mode='fixed', verbose=False) #initialize FOOOF object
else:
fg = FOOOF(max_n_peaks=0, aperiodic_mode='fixed', verbose=False) #initialize FOOOF object
#print(spectra.shape, components.shape) #Use this line if things go weird
fg.fit(components, spectra, x_range)
exponents = fg.get_params('aperiodic_params', 'exponent')
errors = fg.get_params('error') # MAE
offsets = fg.get_params('aperiodic_params', 'offset')
return exponents, errors, offsets
def fooof_perps():
import sys
import numpy as np
from scipy.io import loadmat, savemat
from fooof import FOOOFGroup
import matplotlib.pyplot as plt
data = loadmat('perps_proper.mat')
# Unpack data from dictionary, and squeeze numpy arrays
freqs = np.squeeze(data['fx_regular']).astype('float')
psds = np.squeeze(data['powa_regular']).astype('float')
# ^Note: this also explicitly enforces type as float (type casts to float64, instead of float32)
# This is not strictly necessary for fitting, but is for saving out as json from FOOOF, if you want to do that
# Transpose power spectra, to have the expected orientation for FOOOF
#psds = psds.T
fg = FOOOFGroup(peak_threshold=4,peak_width_limits=[3, 14])#, aperiodic_mode='knee'
#fg.report(freqs, psds, [1, 290])
#fg.fit(freqs,psds,[0.2,290])
fg.fit(freqs,psds,[float(sys.argv[1]),float(sys.argv[2])])
fg.plot()
fg.save_report('perps')
#print(fg.group_results)
r2 = fg.get_params('r_squared')
savemat('p_r2.mat', {'p_r2' : r2})
exps = fg.get_params('aperiodic_params', 'exponent')
centerfrq = fg.get_params('peak_params','CF')
peakheight = fg.get_params('peak_params','PW')
savemat('p_exps.mat', {'p_exps' : exps})
savemat('p_cfs.mat', {'p_cfs' : centerfrq})
savemat('p_peakheight.mat',{'p_peakheight' : peakheight})
offset = fg.get_params('aperiodic_params','offset')
savemat('p_offs.mat', {'p_offs' : offset})
def compute_intsc(ts, numtps, srate, freq_range=(2, 50)):
"""
Compute intrinsic neural timescale
"""
# figure out tr in seconds
tr = 1 / srate
# grab electrode names
colnames2use = ts.columns
colnames2use = colnames2use.to_list()
# normalize (divide all elements of the timeseries by the first value in the timeseries)
ts = np.array(ts)
for col_index, ts2use in enumerate(ts.T):
ts[:, col_index] = np.divide(ts2use, ts2use[0])
# compute spectrum via FFT
f_axis = np.fft.fftfreq(numtps, tr)[:int(np.floor(numtps / 2))]
psds = (np.abs(sp.fft(ts, axis=0))**2)[:len(f_axis)]
# fit FOOOF & get knee parameter & convert to timescale
fooof = FOOOFGroup(aperiodic_mode='knee', max_n_peaks=0, verbose=False)
fooof.fit(freqs=f_axis, power_spectra=psds.T, freq_range=freq_range)
fit_knee = fooof.get_params('aperiodic_params', 'knee')
fit_exp = fooof.get_params('aperiodic_params', 'exponent')
knee_freq, taus = convert_knee_val(fit_knee, fit_exp)
# convert timescale into ms
taus = taus * 1000
# convert taus into a data frame
taus_df = pd.DataFrame(taus.tolist(),
index=colnames2use,
columns=["intsc"])
taus_df = taus_df.T
return (taus_df)
# This is not strictly necessary for fitting, but is for saving out as json from FOOOF, if you want to do that
fg = FOOOFGroup(peak_threshold=15,
peak_width_limits=[3.0, 14.0
]) #, aperiodic_mode='knee'
#fg.report(freqs, psds, [1, 290])
#fg.fit(freqs,psds,[0.2,290])
fg.fit(freqs, psds,
[i, j]) #this was all i could think of... ;_;
#fg.plot()
#reportname = str(k) + '_indiv result'
#fg.save_report(reportname)
#print(fg.group_results)
exps = fg.get_params('aperiodic_params', 'exponent')
allexps.append(exps)
offset = fg.get_params('aperiodic_params', 'offset')
alloffset.append(offset)
#ok, so for each range, we have 16 sets ofx exponents and 16 sets of y offsets.
exp_r2 = 0
off_r2 = 0
for w in range(0, 19):
#print(w)
expy = allexps[w]
offy = alloffset[w]
slope, intercept, exp_r, p_value, std_err = stats.linregress(
dp[0, w], expy)
exp_r2 += exp_r**2
slope, intercept, off_r, p_value, std_err = stats.linregress(
#
# This method works the same as in the :class:`~fooof.FOOOF` object, and lets you extract
# specific results by specifying a field, as a string, and (optionally) a specific column
# to extract.
#
# Since the :class:`~fooof.FOOOFGroup` object collects results from across multiple model fits,
# you should always use :func:`~fooof.FOOOFGroup.get_params` to access model parameters.
# The results attributes introduced with the FOOOF object (such as `aperiodic_params_` or
# `peak_params_`) do not store results across the group, as they are defined for individual
# model fits (and used internally as such by the FOOOFGroup object).
#
###################################################################################################
# Extract aperiodic parameters
aps = fg.get_params('aperiodic_params')
exps = fg.get_params('aperiodic_params', 'exponent')
# Extract peak parameters
peaks = fg.get_params('peak_params')
cfs = fg.get_params('peak_params', 'CF')
# Extract goodness-of-fit metrics
errors = fg.get_params('error')
r2s = fg.get_params('r_squared')
###################################################################################################
# The full list of parameters you can extract is available in the documentation of `get_params`
print(fg.get_params.__doc__)
# In the :class:`~fooof.FOOOFGroup` report we can get a sense of the overall performance
# by looking at the information about the goodness of fit metrics, and also things like
# the distribution of peaks.
#
# However, while these metrics can help identify if fits are, on average, going well (or not)
# they don't necessarily indicate the source of any problems.
#
# To do so, we will typically still want to visualize some example fits, to see
# what is happening. To do so, next we will find which fits have the most error,
# and select these fits from the :class:`~fooof.FOOOFGroup` object to visualize.
#
###################################################################################################
# Find the index of the worst model fit from the group
worst_fit_ind = np.argmax(fg.get_params('error'))
# Extract this model fit from the group
fm = fg.get_fooof(worst_fit_ind, regenerate=True)
###################################################################################################
# Check results and visualize the extracted model
fm.print_results()
fm.plot()
###################################################################################################
#
# You can also loop through all the results in a :class:`~fooof.FOOOFGroup`, extracting
# all fits that meet some criterion that makes them worth checking.
#
###################################################################################################
# Compare the peak fits of alpha peaks between groups
plot_peak_fits([g1_alphas, g2_alphas], labels=labels, colors=colors)
###################################################################################################
# Aperiodic Components
# --------------------
#
# Next, let's have a look at the aperiodic components.
#
###################################################################################################
# Extract the aperiodic parameters for each group
aps1 = fg1.get_params('aperiodic_params')
aps2 = fg2.get_params('aperiodic_params')
###################################################################################################
# Plotting Aperiodic Parameters
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# The :func:`~.plot_aperiodic_params` function takes in
# aperiodic parameters, and visualizes them, as:
#
# - Offset on the x-axis
# - Exponent on the y-axis
#
###################################################################################################
###################################################################################################
# Fit the 3D matrix of power spectra
fgs = fit_fooof_group_3d(fg, fs, spectra)
###################################################################################################
# This returns a list of FOOOFGRoup objects
print(fgs)
###################################################################################################
# Compare the aperiodic exponent results across conditions
for ind, fg in enumerate(fgs):
print("Aperiodic exponent for condition {} is {:1.4f}".format(
ind, np.mean(fg.get_params('aperiodic_params', 'exponent'))))
###################################################################################################
# combine_fooofs
# --------------
#
# Depending what the organization of the data is, you might also want to collapse
# FOOOF models dimensions that have been fit.
#
#
# To do so, you can use the :func:`combine_fooofs` function, which takes
# a list of FOOOF or FOOOFGroup objects, and combines them together into
# a single FOOOFGroup object (assuming the settings and data definitions
# are consistent to do so).
###################################################################################################
axes[ind].set_title('biggest ' + label + ' peak', {'fontsize': 16})
###################################################################################################
# Plotting Aperiodic Topographies
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#
# Next up, let's plot the topography of the aperiodic exponent.
#
# To do so, we can simply extract the aperiodic parameters from our power spectrum models,
# and plot them.
#
###################################################################################################
# Extract aperiodic exponent values
exps = fg.get_params('aperiodic_params', 'exponent')
###################################################################################################
# Plot the topography of aperiodic exponents
plot_topomap(exps, raw.info, cmap=cm.viridis, contours=0)
###################################################################################################
#
# In the topography above, we can see that there is a fair amount of variation
# across the scalp in terms of aperiodic exponent value, and there seems to be some
# spatial structure to it.
#
# To visualize how much the exponent values vary, we can again plot some example power
# spectra, in this case extracting those with the highest and lower exponent values.
#
aperiodic_params=param_sampler([[20, 2], [35, 1.5]]),
gaussian_params=param_sampler([[], [10, 0.5, 2]]))
###################################################################################################
# Fit FOOOF models across the group of simulated power spectra
fg = FOOOFGroup(peak_width_limits=[1, 8],
min_peak_height=0.05,
max_n_peaks=6,
verbose=False)
fg.fit(freqs, spectra)
###################################################################################################
# Get all alpha oscillations from a FOOOFGroup object
alphas = get_band_peak_group(fg.get_params('peak_params'), alpha_band, len(fg))
###################################################################################################
# Check out some of the alpha data
print(alphas[0:5, :])
###################################################################################################
#
# Note that the design of :func:`get_band_peak_group` is such that it will retain
# information regarding which oscillation came from with model fit.
#
# To do so, it's output is organized such that each row corresponds to a specific
# model fit, such that the matrix returned is size [n_fits, 3].
#
# For this to work, at most 1 peak is extracted for each model fit within the specified band.