def get_fooof(self, ind, regenerate=True):
"""Get a FOOOF object for a specified model fit.
Parameters
----------
ind : int
The index of the FOOOFResults in FOOOFGroup.group_results to load.
regenerate : bool, optional, default: False
Whether to regenerate the model fits from the given fit parameters.
Returns
-------
fm : FOOOF
The FOOOFResults data loaded into a FOOOF object.
"""
# Initialize a FOOOF object, with same settings as current FOOOFGroup
fm = FOOOF(*self.get_settings(), verbose=self.verbose)
# Add data for specified single power spectrum, if available
# The power spectrum is inverted back to linear, as it is re-logged when added to FOOOF
if self.has_data:
fm.add_data(self.freqs, np.power(10, self.power_spectra[ind]))
# If no power spectrum data available, copy over data information & regenerate freqs
else:
fm.add_meta_data(self.get_meta_data())
# Add results for specified power spectrum, regenerating full fit if requested
fm.add_results(self.group_results[ind])
if regenerate:
fm._regenerate_model()
return fm
def load_fooof(file_name, file_path=None, regenerate=True):
"""Load a FOOOF file into a FOOOF object.
Parameters
----------
file_name : str or FileObject
File to load the data from.
file_path : str or None, optional
Path to directory to load from. If None, loads from current directory.
regenerate : bool, optional, default: True
Whether to regenerate the model fit from the loaded data, if data is available.
Returns
-------
fm : FOOOF
Object with the loaded data.
"""
# Initialize a FOOOF object (imported locally to avoid circular imports)
from fooof.objs import FOOOF
fm = FOOOF()
# Load data into object
fm.load(file_name, file_path, regenerate)
return fm
def __init__(self, *args, **kwargs):
"""Initialize object with desired settings."""
FOOOF.__init__(self, *args, **kwargs)
self.power_spectra = None
self._reset_group_results()
def get_tfm():
"""Get a FOOOF object, with a fit power spectrum, for testing."""
freq_range = [3, 50]
ap_params = [50, 2]
gaussian_params = [10, 0.5, 2, 20, 0.3, 4]
xs, ys = gen_power_spectrum(freq_range, ap_params, gaussian_params)
tfm = FOOOF(verbose=False)
tfm.fit(xs, ys)
return tfm
def average_fg(fg, bands, avg_method='mean', regenerate=True):
"""Average across model fits in a FOOOFGroup object.
Parameters
----------
fg : FOOOFGroup
Object with model fit results to average across.
bands : Bands
Bands object that defines the frequency bands to collapse peaks across.
avg : {'mean', 'median'}
Averaging function to use.
regenerate : bool, optional, default: True
Whether to regenerate the model for the averaged parameters.
Returns
-------
fm : FOOOF
Object containing the average model results.
Raises
------
ValueError
If the requested averaging method is not understood.
NoModelError
If there are no model fit results available to average across.
"""
if avg_method not in ['mean', 'median']:
raise ValueError("Requested average method not understood.")
if not fg.has_model:
raise NoModelError(
"No model fit results are available, can not proceed.")
if avg_method == 'mean':
avg_func = np.nanmean
elif avg_method == 'median':
avg_func = np.nanmedian
# Aperiodic parameters: extract & average
ap_params = avg_func(fg.get_params('aperiodic_params'), 0)
# Periodic parameters: extract & average
peak_params = []
gauss_params = []
for band_def in bands.definitions:
peaks = get_band_peak_fg(fg, band_def, attribute='peak_params')
gauss = get_band_peak_fg(fg, band_def, attribute='gaussian_params')
# Check if there are any extracted peaks - if not, don't add
# Note that we only check peaks, but gauss should be the same
if not np.all(np.isnan(peaks)):
peak_params.append(avg_func(peaks, 0))
gauss_params.append(avg_func(gauss, 0))
peak_params = np.array(peak_params)
gauss_params = np.array(gauss_params)
# Goodness of fit measures: extract & average
r2 = avg_func(fg.get_params('r_squared'))
error = avg_func(fg.get_params('error'))
# Collect all results together, to be added to FOOOF object
results = FOOOFResults(ap_params, peak_params, r2, error, gauss_params)
# Create the new FOOOF object, with settings, data info & results
fm = FOOOF()
fm.add_settings(fg.get_settings())
fm.add_meta_data(fg.get_meta_data())
fm.add_results(results)
# Generate the average model from the parameters
if regenerate:
fm._regenerate_model()
return fm