def content(self):
""" Return report data if already in memory, otherwise read from fs.
Content is assumed to be a dictionary with conditions as keys
and reports as values """
if self._content:
return self._content
template = self.name + '_' + r'([a-zA-Z1-9_]+)\.json'
for fname in os.listdir(self._path):
match = re.match(template, fname)
if match:
try:
key = str(match.group(1))
except Exception as exc:
raise Exception("Unknown file name format.")
if 'conditions' in self._params:
if key not in [str(elem) for elem
in self._params['conditions']]:
continue
logging.getLogger('ui_logger').debug(
'Reading FOOOF file: ' + str(fname))
fg = FOOOFGroup()
fg.load(fname, self._path)
self._content[key] = fg
return self._content
def create_report(subject, params):
""" Collect parameters from the dialog and creates an FOOOFReport item
"""
report_name = params['name']
spectrum_name = params['spectrum_name']
peak_width_low = params['peak_width_low']
peak_width_high = params['peak_width_high']
peak_threshold = params['peak_threshold']
max_n_peaks = params['max_n_peaks']
aperiodic_mode = params['aperiodic_mode']
minfreq = params['minfreq']
maxfreq = params['maxfreq']
spectrum = subject.spectrum.get(spectrum_name)
peak_width_limits = [peak_width_low, peak_width_high]
peak_threshold = peak_threshold
max_n_peaks = max_n_peaks
aperiodic_mode = aperiodic_mode
freq_range = [minfreq, maxfreq]
# As meggie spectrum items can contain data for multiple conditions,
# reports are also created for all those conditions, and dict is used.
report_content = {}
for key, data in spectrum.content.items():
fg = FOOOFGroup(peak_width_limits=peak_width_limits,
peak_threshold=peak_threshold,
max_n_peaks=max_n_peaks,
aperiodic_mode=aperiodic_mode,
verbose=False)
fg.fit(spectrum.freqs, data, freq_range)
logging.getLogger('ui_logger').info('FOOOF results for ' +
subject.name + ', ' +
'condition: ' + key)
# Log the textual report
logging.getLogger('ui_logger').info(
gen_results_fg_str(fg, concise=True))
report_content[key] = fg
params['conditions'] = list(spectrum.content.keys())
params['ch_names'] = spectrum.ch_names
fooof_directory = subject.fooof_report_directory
# Create a container item that meggie understands,
# and which holds the report data
report = FOOOFReport(report_name, fooof_directory, params, report_content)
# save report data to fs
report.save_content()
# and add the report item to subject
subject.add(report, 'fooof_report')
def test_plot_fg(tfg, skip_if_no_mpl):
plot_fg(tfg)
# Test error if no data available to plot
tfg = FOOOFGroup()
with raises(NoModelError):
tfg.plot()
def get_tfg():
"""Get a FOOOFGroup object, with some fit power spectra, for testing."""
n_spectra = 2
xs, ys = gen_group_power_spectra(n_spectra, *default_group_params())
tfg = FOOOFGroup()
tfg.fit(xs, ys)
return tfg
def test_fg_report(skip_if_no_mpl):
"""Check that running the top level model method runs."""
n_spectra = 2
xs, ys = gen_group_power_spectra(n_spectra, *default_group_params())
tfg = FOOOFGroup()
tfg.report(xs, ys)
assert tfg
def main():
# Initialize a FOOOFGroup object to use
fg = FOOOFGroup()
# Create dictionary to store results
exponent_results = np.zeros(shape=[N_SUBJECTS, NUM_BLOCKS, N_CHANNELS, 2])
results = {}
for band_name in BANDS.labels:
results[band_name] = np.zeros(
shape=[N_SUBJECTS, NUM_BLOCKS, N_CHANNELS, N_FEATS])
for sub_index, subj_num in enumerate(SUBJ_NUMS):
print('Current Subject Results: ' + str(subj_num))
# load rest results data
for block in range(0, NUM_BLOCKS):
subj_file = str(subj_num) + "fooof_group_results" + str(
block) + ".json"
full_path = pjoin(RES_PATH, subj_file)
print(full_path)
if Path(full_path).is_file():
fg.load(file_name=subj_file, file_path=RES_PATH)
if not fg.group_results:
print('Current Subject Results: ' + str(subj_num) +
' block: ' + str(block) + ' failed to load.')
else:
print('Current Subject Results: ' + str(subj_num) +
' block: ' + str(block) + ' successfully loaded.')
for ind, res in enumerate(fg):
exponent_results[sub_index, block,
ind, :] = res.aperiodic_params
for band_label, band_range in BANDS:
results[band_label][sub_index, block, ind, :] = \
get_band_peak(res.peak_params, band_range, True)
# Save out processed results
with open(pjoin(PATHS.results_path, GROUP + '_' + STATE + '_exp.pkl'),
'wb') as exp_output:
pickle.dump(exponent_results, exp_output)
with open(pjoin(PATHS.results_path, GROUP + '_' + STATE + '_results.pkl'),
'wb') as output:
pickle.dump(results, output)
print("File Saved.")
def test_plot_fg(tfg, skip_if_no_mpl):
plot_fg(tfg,
save_fig=True,
file_path=TEST_PLOTS_PATH,
file_name='test_plot_fg.png')
# Test error if no data available to plot
tfg = FOOOFGroup()
with raises(NoModelError):
tfg.plot()
def test_fg_fit_par():
"""Test FOOOFGroup fit, running in parallel."""
n_spectra = 2
xs, ys = gen_group_power_spectra(n_spectra, *default_group_params())
tfg = FOOOFGroup()
tfg.fit(xs, ys, n_jobs=2)
out = tfg.get_results()
assert out
assert len(out) == n_spectra
assert isinstance(out[0], FOOOFResult)
assert np.all(out[1].background_params)
def combine_fooofs(fooofs):
"""Combine a group of FOOOF and/or FOOOFGroup objects into a single FOOOFGroup object.
Parameters
----------
fooofs : list of FOOOF objects
FOOOF objects to be concatenated into a FOOOFGroup.
Returns
-------
fg : FOOOFGroup object
Resultant FOOOFGroup object created from input FOOOFs.
"""
# Compare settings
if not compare_info(fooofs, 'settings') or not compare_info(
fooofs, 'data_info'):
raise ValueError("These objects have incompatible settings or data," \
"and so cannot be combined.")
# Initialize FOOOFGroup object, with settings derived from input objects
fg = FOOOFGroup(*fooofs[0].get_settings(), verbose=fooofs[0].verbose)
# Use a temporary store to collect spectra, because we only add them if consistently present
temp_power_spectra = np.empty([0, len(fooofs[0].freqs)])
# Add FOOOF results from each FOOOF object to group
for f_obj in fooofs:
# Add FOOOFGroup object
if isinstance(f_obj, FOOOFGroup):
fg.group_results.extend(f_obj.group_results)
if f_obj.power_spectra is not None:
temp_power_spectra = np.vstack(
[temp_power_spectra, f_obj.power_spectra])
# Add FOOOF object
else:
fg.group_results.append(f_obj.get_results())
if f_obj.power_spectrum is not None:
temp_power_spectra = np.vstack(
[temp_power_spectra, f_obj.power_spectrum])
# If the number of collected power spectra is consistent, then add them to object
if len(fg) == temp_power_spectra.shape[0]:
fg.power_spectra = temp_power_spectra
# Add data information information
fg.add_data_info(fooofs[0].get_data_info())
return fg
def test_fg():
"""Check FOOOFGroup object initializes properly."""
# Note: doesn't assert fg itself, as it return false when group_results are empty
# This is due to the __len__ used in FOOOFGroup
fg = FOOOFGroup()
assert True
def fit_fooof(freqs, powers, freq_range, init_kwargs, n_jobs):
"""A generalized FOOOF fit function to handle 1d, 2d, or 3d arrays.
Parameters
----------
powers : 1d, 2d, or 3d array
Power values for a single spectrum, or group of power spectra.
Power values are stored internally in log10 scale.
freqs : 1d array
Frequency values for the power spectra.
freq_range : list of [float, float]
Frequency range of the power spectra, as [lowest_freq, highest_freq].
init_kwargs : dict
FOOOF object initialization kwargs.
n_jobs : int
Specificy the number of jobs to run in parrallel for 2d or 3d arrays.
Returns
-------
model : FOOOF, FOOOFGroup, or list of FOOOFGroup objects.
A FOOOF object that has been fit. A 1d array will return a FOOOF objects, a 2d array will
return a FOOOFGroup object, and a 3d array will return a list of FOOOFGroup objects.
"""
if powers.ndim == 1:
# Fit a 1d array
model = FOOOF(**init_kwargs)
model.fit(freqs, powers, freq_range=freq_range)
elif powers.ndim == 2:
# Fit a 2d array
model = FOOOFGroup(**init_kwargs)
model.fit(freqs, powers, freq_range=freq_range, n_jobs=n_jobs)
elif powers.ndim == 3:
# Fit a 3d array
model = FOOOFGroup(**init_kwargs)
model = fit_fooof_3d(model, freqs, powers, n_jobs=n_jobs)
else:
raise ValueError(
'The power_spectrum argument must specify a 1d, 2d, or 3d array.')
return model
def fit_fooof(epochs):
# Estimate the PSD in the pre-stimulus window
spectrum, freqs = psd_welch(epochs, tmin=-.5, tmax=0,
fmin=2, fmax=30, n_fft=126,
average='median',
n_per_seg=100, n_overlap=50)
spectrum = np.mean(spectrum, axis=0)
# Run FOOF
fm = FOOOFGroup(peak_width_limits=(4.0, 12.0),
aperiodic_mode='fixed',
peak_threshold=1)
# Set the frequency range to fit the model
freq_range = [2, 30]
# Fit the FOOOF model
fm.fit(freqs, spectrum, freq_range)
return fm.copy()
def main():
#Create dictionary to store results
slope_results = np.zeros(shape=[n_subjects, num_blocks, n_channels, 2])
results = {}
for band_name in bands.keys():
results[band_name] = np.zeros(shape=[n_subjects, num_blocks, n_channels, n_feats])
# START LOOP
# DATASET: PBA
for sub_index, sub_num in enumerate(subj_dat_num):
print('Current Subject Results: ' + str(sub_num))
# load rest results data
for block in range(0, num_blocks):
subj_file = str(sub_num) + "fooof_group_results" + str(block) + ".json"
fg = FOOOFGroup()
full_path = os.path.join(results_path, subj_file)
path_check = Path(full_path)
if path_check.is_file():
fg.load(file_name=subj_file, file_path=results_path)
if not fg.group_results:
print('Current Subject Results: ' + str(sub_num) + " block:" + str(block) + " failed to load")
else:
print('Current Subject Results: ' + str(sub_num) + " block" + str(block) + " successfully loaded")
for ind, res in enumerate(fg):
slope_results[sub_index, block, ind, :] = res.background_params
for band_label, band_range in bands.items():
results[band_label][sub_index, block, ind, :] = get_band_peak(res.peak_params, band_range, True)
# Save out matrices
# Update to save out files using DATASET and STATE
slope_output = open('..\\data\\analysis\\' + DATASET + "_" + STATE + "_slope_results.pkl" ,'wb')
pickle.dump(slope_results, slope_output)
slope_output.close()
output = open('..\\data\\analysis\\' + DATASET + "_" + STATE + "_results.pkl" ,'wb')
pickle.dump(results, output)
output.close()
print("File SAVED")
def test_fit_fooof_3d(tfg):
n_spectra = 2
xs, ys = gen_group_power_spectra(n_spectra, *default_group_params())
ys = np.stack([ys, ys], axis=0)
tfg = FOOOFGroup()
fgs = fit_fooof_3d(tfg, xs, ys)
assert len(fgs) == 2
for fg in fgs:
assert fg
def fooof_channel_rejection(eeg, psds, freqs, f_low, f_high, participant,
session_name):
from scipy.stats import bayes_mvs
n_bads = 0
fooof_group = FOOOFGroup(max_n_peaks=6,
min_peak_amplitude=0.1,
peak_width_limits=[1, 12],
background_mode='knee')
fooof_group.fit(freqs, psds, freq_range=[f_low, f_high / 2], n_jobs=-1)
fooof_group_fig = fooof_group.plot(save_fig=True,
file_name='FOOOF_group_' + participant +
'_' + session_name,
file_path=data_dir + '/results/')
bg_slope = fooof_group.get_all_data('background_params', col='slope')
mean_cntr, var_cntr, std_cntr = bayes_mvs(bg_slope, alpha=0.9)
lower_slope = mean_cntr[1][0] - std_cntr[1][1]
upper_slope = mean_cntr[1][1] + std_cntr[1][1]
print('upper and lower slope range (mean, std)', lower_slope, upper_slope,
np.mean(bg_slope), np.std(bg_slope))
for channel_idx, slope in enumerate(bg_slope):
if slope < lower_slope or slope > upper_slope:
eeg.info['bads'].append(eeg.ch_names[channel_idx])
n_bads += 1
eeg.interpolate_bads(reset_bads=True)
return eeg, n_bads
def test_average_fg(tfg, tbands):
nfm = average_fg(tfg, tbands)
assert nfm
# Test bad average method error
with raises(ValueError):
average_fg(tfg, tbands, avg_method='BAD')
# Test no data available error
ntfg = FOOOFGroup()
with raises(NoModelError):
average_fg(ntfg, tbands)
def _load_fgs(data_path, folder, side, load):
"""Helper to load FOOOFGroups."""
# Load the FOOOF analyses of the average
pre, early, late = FOOOFGroup(), FOOOFGroup(), FOOOFGroup()
pre.load('Group_' + load + '_' + side + '_Pre', pjoin(data_path, folder))
early.load('Group_' + load + '_' + side + '_Early', pjoin(data_path, folder))
late.load('Group_' + load + '_' + side + '_Late', pjoin(data_path, folder))
return pre, early, late
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 test_fit_fooof_3d(tfg):
n_groups = 2
n_spectra = 3
xs, ys = gen_group_power_spectra(n_spectra, *default_group_params())
ys = np.stack([ys] * n_groups, axis=0)
spectra_shape = np.shape(ys)
tfg = FOOOFGroup()
fgs = fit_fooof_3d(tfg, xs, ys)
assert len(fgs) == n_groups == spectra_shape[0]
for fg in fgs:
assert fg
assert len(fg) == n_spectra
assert fg.power_spectra.shape == spectra_shape[1:]
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 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, 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 foof2mat():
import sys
import hdf5storage
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, 1000, 10001) #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(max_n_peaks=6, peak_threshold=4)
frange = (30, 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_all_data('background_params', 'slope')
off = fg.get_all_data('background_params', 'intercept')
r = fg.get_all_data('r_squared')
scipy.io.savemat('slp.mat', {'slp': slp})
scipy.io.savemat('off.mat', {'off': off})
scipy.io.savemat('r.mat', {'r': r})
return
def test_fg_load():
"""Test load into FOOOFGroup. Note: loads files from test_core_io."""
set_file_name = 'test_fooof_group_set'
res_file_name = 'test_fooof_group_res'
file_path = pkg.resource_filename(__name__, 'test_files')
tfg = FOOOFGroup()
tfg.load(set_file_name, file_path)
assert tfg
tfg.load(res_file_name, file_path)
assert tfg
def combine_fooofs(fooofs):
"""Combine a group of FOOOF and/or FOOOFGroup objects into a single FOOOFGroup object.
Parameters
----------
fooofs : list of FOOOF objects
FOOOF objects to be concatenated into a FOOOFGroup.
Returns
-------
fg : FOOOFGroup object
Resultant FOOOFGroup object created from input FOOOFs.
"""
# Compare settings
if not compare_settings(fooofs) or not compare_data_info(fooofs):
raise ValueError("These objects have incompatible settings or data," \
"and so cannot be combined.")
# Initialize FOOOFGroup object, with settings derived from input objects
# Note: FOOOFGroup imported here to avoid an import circularity if imported at the top
from fooof import FOOOFGroup
fg = FOOOFGroup(**get_settings(fooofs[0]), verbose=fooofs[0].verbose)
fg.power_spectra = np.empty([0, len(fooofs[0].freqs)])
# Add FOOOF results from each FOOOF object to group
for f_obj in fooofs:
# Add FOOOFGroup object
if isinstance(f_obj, FOOOFGroup):
fg.group_results.extend(f_obj.group_results)
fg.power_spectra = np.vstack(
[fg.power_spectra, f_obj.power_spectra])
# Add FOOOF object
else:
fg.group_results.append(f_obj.get_results())
fg.power_spectra = np.vstack(
[fg.power_spectra, f_obj.power_spectrum])
# Add data information information
for data_info in get_obj_desc()['freq_info']:
setattr(fg, data_info, getattr(fooofs[0], data_info))
fg.freqs = gen_freqs(fg.freq_range, fg.freq_res)
return fg
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)
psds) #this lowers the frequency of loading .mat's, anyway..
for i in range(1, 290, 50):
for j in range(1, 290, 50):
allexps = []
alloffset = []
if not (j > (i + 2)):
pass
else:
for k in range(1, patientcount + 1):
freqs = freq_nparray[k - 1]
psds = psds_nparray[k - 1]
# ^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=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)
first_half = np.mean(dat['pxx'][:, :,
0:int(np.floor(sorted.size / 3))],
axis=2)
second_half = np.mean(
dat['pxx'][:, :,
int(np.floor(sorted.size / 3)) + 1:sorted.size -
int(np.floor(sorted.size / 3))],
axis=2)
third_half = np.mean(
dat['pxx'][:, :,
sorted.size - int(np.floor(sorted.size / 3)) + 1:],
axis=2)
fm = FOOOFGroup(peak_width_limits=[1, 8],
min_peak_height=0.05,
max_n_peaks=6)
fm._maxfev = 30000
freq_range = [3, 40]
freqs = np.squeeze(dat['fxx'])
aperiodic = np.zeros([2, np.shape(dat['pxx'])[1], 2])
fm.fit(freqs, np.transpose(first_half), freq_range)
fm.save(
'/home/tpfeffer/pp/proc/src/pp_hh_task_fooof_result_lo_s%d_b%d_v%d'
% (isubj, iblock, v),
save_results=True,
save_settings=False,
save_data=True)
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
dat = {}
dat['fxx'] = tmp['outp'][0]['fxx'][0]
dat['pxx'] = tmp['outp'][0]['pxx'][0]
except:
print("Error: File not found!")
continue
print('Processing S%d B%d M%d ...' % (isubj, iblock, m))
freqs = np.squeeze(dat['fxx'])
aper = np.empty([2, dat['pxx'].shape[1]])
only_gauss = np.zeros([dat['pxx'].shape[0], dat['pxx'].shape[1]])
full_gauss = np.zeros([dat['pxx'].shape[0], dat['pxx'].shape[1]])
fm = FOOOFGroup(peak_width_limits=[1, 8],
min_peak_height=0.05,
max_n_peaks=6)
fm._maxfev = 30000
freq_range = [3, 40]
fm.fit(freqs, np.transpose(dat['pxx']), freq_range)
tmp = fm.get_results()
for isens in range(0, dat['pxx'].shape[1]):
aper[:, isens] = tmp[isens].aperiodic_params
F = fm.freqs
for isens in range(0, dat['pxx'].shape[1]):
for i in range(0, len(tmp[isens].gaussian_params)):
c = tmp[isens].gaussian_params[i][0]
w = tmp[isens].gaussian_params[i][2]
