def setUp(self):
s = Spectrum(np.array([1.0, 2, 4, 7, 12, 7, 4, 2, 1]))
m = s.create_model()
self.model = m
self.A = 38.022476979172588
self.sigma = 1.4764966133859543
self.centre = 4.0000000002462945
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.components.Gaussian.A.value = 13
m.components.Gaussian.name = 'something'
self.m = m
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
if self.metadata.Signal.signal_type == 'EDS':
print('The microscope type is not set. Use '
'set_signal_type(\'EDS_TEM\') '
'or set_signal_type(\'EDS_SEM\')')
self.metadata.Signal.binned = True
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.components.Gaussian.A.value = 13
m.components.Gaussian.name = 'something'
self.m = m
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
if self.metadata.Signal.signal_type == 'EDS':
print(
'The microscope type is not set. Use '
'set_signal_type(\'EDS_TEM\') or set_signal_type(\'EDS_SEM\')')
self.metadata.Signal.binned = True
def setUp(self):
s = Spectrum(np.array([1.0, 2, 4, 7, 12, 7, 4, 2, 1]))
m = s.create_model()
self.model = m
self.A = 38.022476979172588
self.sigma = 1.4764966133859543
self.centre = 4.0000000002462945
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
if self.metadata.Signal.signal_type == 'EDS':
warnings.warn('The microscope type is not set. Use '
'set_signal_type(\'EDS_TEM\') '
'or set_signal_type(\'EDS_SEM\')')
self.metadata.Signal.binned = True
self._xray_markers = {}
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
# Attributes defaults
self.subshells = set()
self.elements = set()
self.edges = list()
if hasattr(self.mapped_parameters, 'Sample') and \
hasattr(self.mapped_parameters.Sample, 'elements'):
print('Elemental composition read from file')
self.add_elements(self.mapped_parameters.Sample.elements)
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
# Attributes defaults
self.subshells = set()
self.elements = set()
self.edges = list()
if hasattr(self.mapped_parameters, 'Sample') and \
hasattr(self.mapped_parameters.Sample, 'elements'):
print('Elemental composition read from file')
self.add_elements(self.mapped_parameters.Sample.elements)
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
# Attributes defaults
self.subshells = set()
self.elements = set()
self.edges = list()
if hasattr(self.metadata, 'Sample') and \
hasattr(self.metadata.Sample, 'elements'):
print('Elemental composition read from file')
self.add_elements(self.metadata.Sample.elements)
self.metadata.Signal.binned = True
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
# Attributes defaults
self.subshells = set()
self.elements = set()
self.edges = list()
if hasattr(self.metadata, 'Sample') and \
hasattr(self.metadata.Sample, 'elements'):
print('Elemental composition read from file')
self.add_elements(self.metadata.Sample.elements)
self.metadata.Signal.binned = True
def setUp(self):
s = Spectrum(np.array([1.0, 2, 4, 7, 12, 7, 4, 2, 1]))
m = s.create_model()
m._low_loss = (s + 3.0).deepcopy()
self.model = m
self.s = s
m.append(Gaussian())
m.append(Gaussian())
m.append(ScalableFixedPattern(s * 0.3))
m[0].A.twin = m[1].A
m.fit()
def setUp(self):
s = Spectrum(np.array([1.0, 2, 4, 7, 12, 7, 4, 2, 1]))
m = s.create_model()
m.low_loss = (s + 3.0).deepcopy()
self.model = m
self.s = s
m.append(Gaussian())
m.append(Gaussian())
m.append(ScalableFixedPattern(s * 0.3))
m[0].A.twin = m[1].A
m.fit()
def setUp(self):
g = Gaussian()
g.A.value = 10000.0
g.centre.value = 5000.0
g.sigma.value = 500.0
axis = np.arange(10000)
s = Spectrum(g.function(axis))
m = s.create_model()
self.model = m
self.g = g
self.axis = axis
self.rtol = 0.00
def setUp(self):
g = Gaussian()
g.A.value = 10000.0
g.centre.value = 5000.0
g.sigma.value = 500.0
axis = np.arange(10000)
s = Spectrum(g.function(axis))
m = s.create_model()
self.model = m
self.g = g
self.axis = axis
self.rtol = 0.00
def setUp(self):
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
s = Spectrum(np.arange(10))
m = s.create_model()
m.append(g1)
m.append(g2)
m.append(g3)
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.model = m
def setUp(self):
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
s = Spectrum(np.arange(1000).reshape(10, 10, 10))
m = s.create_model()
m.append(g1)
m.append(g2)
m.append(g3)
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.model = m
def get_explained_variance_ratio(self):
"""Return the explained variation ratio of the PCA components as a
Spectrum.
Returns
-------
s : Spectrum
Explained variation ratio.
See Also:
---------
`plot_explained_variance_ration`, `decomposition`,
`get_decomposition_loadings`,
`get_decomposition_factors`.
"""
from hyperspy._signals.spectrum import Spectrum
target = self.learning_results
if target.explained_variance_ratio is None:
raise AttributeError("The explained_variance_ratio attribute is "
"`None`, did you forget to perform a PCA "
"decomposition?")
s = Spectrum(target.explained_variance_ratio)
s.metadata.General.title = self.metadata.General.title + \
"\nPCA Scree Plot"
s.axes_manager[-1].name = 'Principal component index'
s.axes_manager[-1].units = ''
return s
def setUp(self):
x = np.arange(0,50,0.01)
s = Spectrum(np.vstack((np.cos(x), np.sin(x))))
s.axes_manager.signal_axes[0].scale = 0.01
self.peak_positions0 = np.arange(8) *2 * np.pi
self.peak_positions1 = np.arange(8) *2 * np.pi + np.pi/2
self.spectrum = s
def _estimate_gain(ns, cs,
weighted=False,
higher_than=None,
plot_results=False,
binning=0,
pol_order=1):
if binning > 0:
factor = 2 ** binning
remainder = np.mod(ns.shape[1], factor)
if remainder != 0:
ns = ns[:, remainder:]
cs = cs[:, remainder:]
new_shape = (ns.shape[0], ns.shape[1] / factor)
ns = rebin(ns, new_shape)
cs = rebin(cs, new_shape)
noise = ns - cs
variance = np.var(noise, 0)
average = np.mean(cs, 0).squeeze()
# Select only the values higher_than for the calculation
if higher_than is not None:
sorting_index_array = np.argsort(average)
average_sorted = average[sorting_index_array]
average_higher_than = average_sorted > higher_than
variance_sorted = variance.squeeze()[sorting_index_array]
variance2fit = variance_sorted[average_higher_than]
average2fit = average_sorted[average_higher_than]
else:
variance2fit = variance
average2fit = average
fit = np.polyfit(average2fit, variance2fit, pol_order)
if weighted is True:
from hyperspy._signals.spectrum import Spectrum
from hyperspy.models.model1D import Model1D
from hyperspy.components import Line
s = Spectrum(variance2fit)
s.axes_manager.signal_axes[0].axis = average2fit
m = Model1D(s)
l = Line()
l.a.value = fit[1]
l.b.value = fit[0]
m.append(l)
m.fit(weights=True)
fit[0] = l.b.value
fit[1] = l.a.value
if plot_results is True:
plt.figure()
plt.scatter(average.squeeze(), variance.squeeze())
plt.xlabel('Counts')
plt.ylabel('Variance')
plt.plot(average2fit, np.polyval(fit, average2fit), color='red')
results = {'fit': fit, 'variance': variance.squeeze(),
'counts': average.squeeze()}
return results
def setUp(self):
gs1 = Gaussian()
gs1.A.value = 10000.0
gs1.centre.value = 5000.0
gs1.sigma.value = 500.0
gs2 = Gaussian()
gs2.A.value = 60000.0
gs2.centre.value = 2000.0
gs2.sigma.value = 300.0
gs3 = Gaussian()
gs3.A.value = 20000.0
gs3.centre.value = 6000.0
gs3.sigma.value = 100.0
axis = np.arange(10000)
total_signal = (gs1.function(axis) +
gs2.function(axis) +
gs3.function(axis))
s = Spectrum(total_signal)
m = s.create_model()
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
m.append(g1)
m.append(g2)
m.append(g3)
self.model = m
self.gs1 = gs1
self.gs2 = gs2
self.gs3 = gs3
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.axis = axis
self.rtol = 0.01
def setUp(self):
gs1 = Gaussian()
gs1.A.value = 10000.0
gs1.centre.value = 5000.0
gs1.sigma.value = 500.0
gs2 = Gaussian()
gs2.A.value = 60000.0
gs2.centre.value = 2000.0
gs2.sigma.value = 300.0
gs3 = Gaussian()
gs3.A.value = 20000.0
gs3.centre.value = 6000.0
gs3.sigma.value = 100.0
axis = np.arange(10000)
total_signal = (gs1.function(axis) + gs2.function(axis) +
gs3.function(axis))
s = Spectrum(total_signal)
m = s.create_model()
g1 = Gaussian()
g2 = Gaussian()
g3 = Gaussian()
m.append(g1)
m.append(g2)
m.append(g3)
self.model = m
self.gs1 = gs1
self.gs2 = gs2
self.gs3 = gs3
self.g1 = g1
self.g2 = g2
self.g3 = g3
self.axis = axis
self.rtol = 0.01
def setUp(self):
s = Spectrum(np.zeros((10,100)))
self.scale = 0.1
self.offset = -2
eaxis = s.axes_manager.signal_axes[0]
eaxis.scale = self.scale
eaxis.offset = self.offset
self.izlp = eaxis.value2index(0)
self.bg = 2
self.ishifts = np.array([0, 4, 2, -2, 5, -2, -5, -9, -9, -8])
self.new_offset = self.offset - self.ishifts.min() * self.scale
s.data[np.arange(10), self.ishifts + self.izlp] = 10
s.data += self.bg
self.spectrum = s
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
if self.mapped_parameters.signal_type == 'EDS':
print('The microscope type is not set. Use '
'set_signal_type(\'EDS_TEM\') or set_signal_type(\'EDS_SEM\')')
def setUp(self):
s = Spectrum(np.empty(1))
m = create_model(s)
self.model = m
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
self.metadata.Signal.binned = False
def blind_source_separation(self,
number_of_components=None,
algorithm='sklearn_fastica',
diff_order=1,
diff_axes=None,
factors=None,
comp_list=None,
mask=None,
on_loadings=False,
pretreatment=None,
**kwargs):
"""Blind source separation (BSS) on the result on the
decomposition.
Available algorithms: FastICA, JADE, CuBICA, and TDSEP
Parameters
----------
number_of_components : int
number of principal components to pass to the BSS algorithm
algorithm : {FastICA, JADE, CuBICA, TDSEP}
diff_order : int
Sometimes it is convenient to perform the BSS on the derivative of
the signal. If diff_order is 0, the signal is not differentiated.
diff_axes : None or list of ints or strings
If None, when `diff_order` is greater than 1 and `signal_dimension`
(`navigation_dimension`) when `on_loadings` is False (True) is
greater than 1, the differences are calculated across all
signal (navigation) axes. Otherwise the axes can be specified in
a list.
factors : Signal or numpy array.
Factors to decompose. If None, the BSS is performed on the
factors of a previous decomposition. If a Signal instance the
navigation dimension must be 1 and the size greater than 1. If a
numpy array (deprecated) the factors are stored in a 2d array
stacked over the last axis.
comp_list : boolen numpy array
choose the components to use by the boolean list. It permits
to choose non contiguous components.
mask : bool numpy array or Signal instance.
If not None, the signal locations marked as True are masked. The
mask shape must be equal to the signal shape
(navigation shape) when `on_loadings` is False (True).
on_loadings : bool
If True, perform the BSS on the loadings of a previous
decomposition. If False, performs it on the factors.
pretreatment: dict
**kwargs : extra key word arguments
Any keyword arguments are passed to the BSS algorithm.
"""
from hyperspy.signal import Signal
from hyperspy._signals.spectrum import Spectrum
lr = self.learning_results
if factors is None:
if not hasattr(lr, 'factors') or lr.factors is None:
raise AttributeError(
'A decomposition must be performed before blind '
'source seperation or factors must be provided.')
else:
if on_loadings:
factors = self.get_decomposition_loadings()
else:
factors = self.get_decomposition_factors()
# Check factors
if not isinstance(factors, Signal):
if isinstance(factors, np.ndarray):
warnings.warn(
"factors as numpy arrays will raise an error in "
"HyperSpy 0.9 and newer. From them on only passing "
"factors as HyperSpy Signal instances will be "
"supported.", DeprecationWarning)
# We proceed supposing that the factors are spectra stacked
# over the last dimension to reproduce the deprecated
# behaviour.
# TODO: Don't forget to change `factors` docstring when
# removing this.
factors = Spectrum(factors.T)
else:
# Change next error message when removing the
# DeprecationWarning
raise ValueError(
"`factors` must be either a Signal instance or a "
"numpy array but an object of type %s was provided." %
type(factors))
# Check factor dimensions
if factors.axes_manager.navigation_dimension != 1:
raise ValueError("`factors` must have navigation dimension"
"equal one, but the navigation dimension "
"of the given factors is %i." %
factors.axes_manager.navigation_dimension)
elif factors.axes_manager.navigation_size < 2:
raise ValueError("`factors` must have navigation size"
"greater than one, but the navigation "
"size of the given factors is %i." %
factors.axes_manager.navigation_size)
# Check mask dimensions
if mask is not None:
ref_shape, space = (factors.axes_manager.signal_shape,
"navigation" if on_loadings else "signal")
if isinstance(mask, np.ndarray):
warnings.warn(
"Bare numpy array masks are deprecated and will be removed"
" in next HyperSpy 0.9.", DeprecationWarning)
ref_shape = ref_shape[::-1]
if mask.shape != ref_shape:
raise ValueError(
"The `mask` shape is not equal to the %s shape."
"Mask shape: %s\tSignal shape in array: %s" %
(space, str(mask.shape), str(ref_shape)))
else:
if on_loadings:
mask = self._get_navigation_signal(data=mask)
else:
mask = self._get_signal_signal(data=mask)
elif isinstance(mask, Signal):
if mask.axes_manager.signal_shape != ref_shape:
raise ValueError(
"The `mask` signal shape is not equal to the %s shape."
" Mask shape: %s\t%s shape:%s" %
(space, str(mask.axes_manager.signal_shape), space,
str(ref_shape)))
# Note that we don't check the factor's signal dimension. This is on
# purpose as an user may like to apply pretreaments that change their
# dimensionality.
# The diff_axes are given for the main signal. We need to compute
# the correct diff_axes for the factors.
# Get diff_axes index in axes manager
if diff_axes is not None:
diff_axes = [
1 + axis.index_in_axes_manager
for axis in [self.axes_manager[axis] for axis in diff_axes]
]
if not on_loadings:
diff_axes = [
index - self.axes_manager.navigation_dimension
for index in diff_axes
]
# Select components to separate
if number_of_components is not None:
comp_list = range(number_of_components)
elif comp_list is not None:
number_of_components = len(comp_list)
else:
if lr.output_dimension is not None:
number_of_components = lr.output_dimension
comp_list = range(number_of_components)
else:
raise ValueError(
"No `number_of_components` or `comp_list` provided.")
factors = stack([factors.inav[i] for i in comp_list])
# Apply differences pre-processing if requested.
if diff_order > 0:
factors = get_derivative(factors,
diff_axes=diff_axes,
diff_order=diff_order)
if mask is not None:
# The following is a little trick to dilate the mask as
# required when operation on the differences. It exploits the
# fact that np.diff autimatically "dilates" nans. The trick has
# a memory penalty which should be low compare to the total
# memory required for the core application in most cases.
mask_diff_axes = ([iaxis - 1 for iaxis in diff_axes]
if diff_axes is not None else None)
mask.change_dtype("float")
mask.data[mask.data == 1] = np.nan
mask = get_derivative(mask,
diff_axes=mask_diff_axes,
diff_order=diff_order)
mask.data[np.isnan(mask.data)] = 1
mask.change_dtype("bool")
# Unfold in case the signal_dimension > 1
factors.unfold()
if mask is not None:
mask.unfold()
factors = factors.data.T[~mask.data]
else:
factors = factors.data.T
# Center and scale the data
factors, invsqcovmat = centering_and_whitening(factors)
# Perform actual BSS
if algorithm == 'orthomax':
_, unmixing_matrix = orthomax(factors, **kwargs)
unmixing_matrix = unmixing_matrix.T
elif algorithm == 'sklearn_fastica':
if not import_sklearn.sklearn_installed:
raise ImportError(
"The optional package scikit learn is not installed "
"and it is required for this feature.")
if 'tol' not in kwargs:
kwargs['tol'] = 1e-10
lr.bss_node = import_sklearn.FastICA(**kwargs)
lr.bss_node.whiten = False
lr.bss_node.fit(factors)
try:
unmixing_matrix = lr.bss_node.unmixing_matrix_
except AttributeError:
# unmixing_matrix was renamed to components
unmixing_matrix = lr.bss_node.components_
else:
if mdp_installed is False:
raise ImportError('MDP is not installed. Nothing done')
temp_function = getattr(mdp.nodes, algorithm + "Node")
lr.bss_node = temp_function(**kwargs)
lr.bss_node.train(factors)
unmixing_matrix = lr.bss_node.get_recmatrix()
w = np.dot(unmixing_matrix, invsqcovmat)
if lr.explained_variance is not None:
# The output of ICA is not sorted in any way what makes it
# difficult to compare results from different unmixings. The
# following code is an experimental attempt to sort them in a
# more predictable way
sorting_indices = np.argsort(
np.dot(lr.explained_variance[:number_of_components],
np.abs(w.T)))[::-1]
w[:] = w[sorting_indices, :]
lr.unmixing_matrix = w
lr.on_loadings = on_loadings
self._unmix_components()
self._auto_reverse_bss_component(lr)
lr.bss_algorithm = algorithm
def __init__(self, *args, **kwards):
Spectrum.__init__(self, *args, **kwards)
if self.mapped_parameters.signal_type == 'EDS':
print(
'The microscope type is not set. Use '
'set_signal_type(\'EDS_TEM\') or set_signal_type(\'EDS_SEM\')')
def blind_source_separation(self,
number_of_components=None,
algorithm='sklearn_fastica',
diff_order=1,
diff_axes=None,
factors=None,
comp_list=None,
mask=None,
on_loadings=False,
pretreatment=None,
**kwargs):
"""Blind source separation (BSS) on the result on the
decomposition.
Available algorithms: FastICA, JADE, CuBICA, and TDSEP
Parameters
----------
number_of_components : int
number of principal components to pass to the BSS algorithm
algorithm : {FastICA, JADE, CuBICA, TDSEP}
diff_order : int
Sometimes it is convenient to perform the BSS on the derivative of
the signal. If diff_order is 0, the signal is not differentiated.
diff_axes : None or list of ints or strings
If None, when `diff_order` is greater than 1 and `signal_dimension`
(`navigation_dimension`) when `on_loadings` is False (True) is
greater than 1, the differences are calculated across all
signal (navigation) axes. Otherwise the axes can be specified in
a list.
factors : Signal or numpy array.
Factors to decompose. If None, the BSS is performed on the
factors of a previous decomposition. If a Signal instance the
navigation dimension must be 1 and the size greater than 1. If a
numpy array (deprecated) the factors are stored in a 2d array
stacked over the last axis.
comp_list : boolen numpy array
choose the components to use by the boolean list. It permits
to choose non contiguous components.
mask : bool numpy array or Signal instance.
If not None, the signal locations marked as True are masked. The
mask shape must be equal to the signal shape
(navigation shape) when `on_loadings` is False (True).
on_loadings : bool
If True, perform the BSS on the loadings of a previous
decomposition. If False, performs it on the factors.
pretreatment: dict
**kwargs : extra key word arguments
Any keyword arguments are passed to the BSS algorithm.
"""
from hyperspy.signal import Signal
from hyperspy._signals.spectrum import Spectrum
lr = self.learning_results
if factors is None:
if not hasattr(lr, 'factors') or lr.factors is None:
raise AttributeError(
'A decomposition must be performed before blind '
'source seperation or factors must be provided.')
else:
if on_loadings:
factors = self.get_decomposition_loadings()
else:
factors = self.get_decomposition_factors()
# Check factors
if not isinstance(factors, Signal):
if isinstance(factors, np.ndarray):
warnings.warn(
"factors as numpy arrays will raise an error in "
"HyperSpy 0.9 and newer. From them on only passing "
"factors as HyperSpy Signal instances will be "
"supported.",
DeprecationWarning)
# We proceed supposing that the factors are spectra stacked
# over the last dimension to reproduce the deprecated
# behaviour.
# TODO: Don't forget to change `factors` docstring when
# removing this.
factors = Spectrum(factors.T)
else:
# Change next error message when removing the
# DeprecationWarning
raise ValueError(
"`factors` must be either a Signal instance or a "
"numpy array but an object of type %s was provided." %
type(factors))
# Check factor dimensions
if factors.axes_manager.navigation_dimension != 1:
raise ValueError("`factors` must have navigation dimension"
"equal one, but the navigation dimension "
"of the given factors is %i." %
factors.axes_manager.navigation_dimension
)
elif factors.axes_manager.navigation_size < 2:
raise ValueError("`factors` must have navigation size"
"greater than one, but the navigation "
"size of the given factors is %i." %
factors.axes_manager.navigation_size)
# Check mask dimensions
if mask is not None:
ref_shape, space = (factors.axes_manager.signal_shape,
"navigation" if on_loadings else "signal")
if isinstance(mask, np.ndarray):
warnings.warn(
"Bare numpy array masks are deprecated and will be removed"
" in next HyperSpy 0.9.",
DeprecationWarning)
ref_shape = ref_shape[::-1]
if mask.shape != ref_shape:
raise ValueError(
"The `mask` shape is not equal to the %s shape."
"Mask shape: %s\tSignal shape in array: %s" %
(space, str(mask.shape), str(ref_shape)))
else:
if on_loadings:
mask = self._get_navigation_signal(data=mask)
else:
mask = self._get_signal_signal(data=mask)
elif isinstance(mask, Signal):
if mask.axes_manager.signal_shape != ref_shape:
raise ValueError(
"The `mask` signal shape is not equal to the %s shape."
" Mask shape: %s\t%s shape:%s" %
(space,
str(mask.axes_manager.signal_shape),
space,
str(ref_shape)))
# Note that we don't check the factor's signal dimension. This is on
# purpose as an user may like to apply pretreaments that change their
# dimensionality.
# The diff_axes are given for the main signal. We need to compute
# the correct diff_axes for the factors.
# Get diff_axes index in axes manager
if diff_axes is not None:
diff_axes = [1 + axis.index_in_axes_manager for axis in
[self.axes_manager[axis] for axis in diff_axes]]
if not on_loadings:
diff_axes = [index - self.axes_manager.navigation_dimension
for index in diff_axes]
# Select components to separate
if number_of_components is not None:
comp_list = range(number_of_components)
elif comp_list is not None:
number_of_components = len(comp_list)
else:
if lr.output_dimension is not None:
number_of_components = lr.output_dimension
comp_list = range(number_of_components)
else:
raise ValueError(
"No `number_of_components` or `comp_list` provided.")
factors = stack([factors.inav[i] for i in comp_list])
# Apply differences pre-processing if requested.
if diff_order > 0:
factors = get_derivative(factors,
diff_axes=diff_axes,
diff_order=diff_order)
if mask is not None:
# The following is a little trick to dilate the mask as
# required when operation on the differences. It exploits the
# fact that np.diff autimatically "dilates" nans. The trick has
# a memory penalty which should be low compare to the total
# memory required for the core application in most cases.
mask_diff_axes = (
[iaxis - 1 for iaxis in diff_axes]
if diff_axes is not None
else None)
mask.change_dtype("float")
mask.data[mask.data == 1] = np.nan
mask = get_derivative(mask,
diff_axes=mask_diff_axes,
diff_order=diff_order)
mask.data[np.isnan(mask.data)] = 1
mask.change_dtype("bool")
# Unfold in case the signal_dimension > 1
factors.unfold()
if mask is not None:
mask.unfold()
factors = factors.data.T[~mask.data]
else:
factors = factors.data.T
# Center and scale the data
factors, invsqcovmat = centering_and_whitening(factors)
# Perform actual BSS
if algorithm == 'orthomax':
_, unmixing_matrix = orthomax(factors, **kwargs)
unmixing_matrix = unmixing_matrix.T
elif algorithm == 'sklearn_fastica':
if not import_sklearn.sklearn_installed:
raise ImportError(
"The optional package scikit learn is not installed "
"and it is required for this feature.")
if 'tol' not in kwargs:
kwargs['tol'] = 1e-10
lr.bss_node = import_sklearn.FastICA(
**kwargs)
lr.bss_node.whiten = False
lr.bss_node.fit(factors)
try:
unmixing_matrix = lr.bss_node.unmixing_matrix_
except AttributeError:
# unmixing_matrix was renamed to components
unmixing_matrix = lr.bss_node.components_
else:
if mdp_installed is False:
raise ImportError(
'MDP is not installed. Nothing done')
temp_function = getattr(mdp.nodes, algorithm + "Node")
lr.bss_node = temp_function(**kwargs)
lr.bss_node.train(factors)
unmixing_matrix = lr.bss_node.get_recmatrix()
w = np.dot(unmixing_matrix, invsqcovmat)
if lr.explained_variance is not None:
# The output of ICA is not sorted in any way what makes it
# difficult to compare results from different unmixings. The
# following code is an experimental attempt to sort them in a
# more predictable way
sorting_indices = np.argsort(np.dot(
lr.explained_variance[:number_of_components],
np.abs(w.T)))[::-1]
w[:] = w[sorting_indices, :]
lr.unmixing_matrix = w
lr.on_loadings = on_loadings
self._unmix_components()
self._auto_reverse_bss_component(lr)
lr.bss_algorithm = algorithm
def blind_source_separation(self,
number_of_components=None,
algorithm='sklearn_fastica',
diff_order=1,
factors=None,
comp_list=None,
mask=None,
on_loadings=False,
pretreatment=None,
**kwargs):
"""Blind source separation (BSS) on the result on the
decomposition.
Available algorithms: FastICA, JADE, CuBICA, and TDSEP
Parameters
----------
number_of_components : int
number of principal components to pass to the BSS algorithm
algorithm : {FastICA, JADE, CuBICA, TDSEP}
diff_order : int
Sometimes it is convenient to perform the BSS on the derivative
of the signal. If diff_order is 0, the signal is not differentiated.
factors : numpy.array
Factors to decompose. If None, the BSS is performed on the result
of a previous decomposition.
comp_list : boolen numpy array
choose the components to use by the boolean list. It permits
to choose non contiguous components.
mask : numpy boolean array with the same dimension as the signal
If not None, the signal locations marked as True (masked) will
not be passed to the BSS algorithm.
on_loadings : bool
If True, perform the BSS on the loadings of a previous
decomposition. If False, performs it on the factors.
pretreatment: dict
**kwargs : extra key word arguments
Any keyword arguments are passed to the BSS algorithm.
"""
target=self.learning_results
if not hasattr(target, 'factors') or target.factors==None:
raise AttributeError(
'A decomposition must be performed before blind '
'source seperation or factors must be provided.')
else:
if factors is None:
if on_loadings:
factors = target.loadings
else:
factors = target.factors
bool_index = np.zeros((factors.shape[0]), dtype = 'bool')
if number_of_components is not None:
bool_index[:number_of_components] = True
else:
if target.output_dimension is not None:
number_of_components = target.output_dimension
bool_index[:number_of_components] = True
if comp_list is not None:
for ifactors in comp_list:
bool_index[ifactors] = True
number_of_components = len(comp_list)
factors = factors[:,bool_index]
if pretreatment is not None:
from hyperspy._signals.spectrum import Spectrum
sfactors = Spectrum(factors.T)
if pretreatment['algorithm'] == 'savitzky_golay':
sfactors.smooth_savitzky_golay(
number_of_points=pretreatment[
'number_of_points'],
polynomial_order=pretreatment[
'polynomial_order'],
differential_order = diff_order)
if pretreatment['algorithm'] == 'tv':
sfactors.smooth_tv(
smoothing_parameter= pretreatment[
'smoothing_parameter'],
differential_order = diff_order)
factors = sfactors.data.T
if pretreatment['algorithm'] == 'butter':
b, a = sp.signal.butter(pretreatment['order'],
pretreatment['cutoff'], pretreatment['type'])
for i in range(factors.shape[1]):
factors[:,i] = sp.signal.filtfilt(b,a,
factors[:,i])
elif diff_order > 0:
factors = np.diff(factors, diff_order, axis=0)
if mask is not None:
factors = factors[~mask]
# first center and scale the data
factors,invsqcovmat = centering_and_whitening(factors)
if algorithm == 'orthomax':
_, unmixing_matrix = orthomax(factors, **kwargs)
unmixing_matrix = unmixing_matrix.T
elif algorithm == 'sklearn_fastica':
#if sklearn_installed is False:
#raise ImportError(
#'sklearn is not installed. Nothing done')
if 'tol' not in kwargs:
kwargs['tol'] = 1e-10
target.bss_node = FastICA(
**kwargs)
target.bss_node.whiten = False
target.bss_node.fit(factors)
unmixing_matrix = target.bss_node.unmixing_matrix_
else:
if mdp_installed is False:
raise ImportError(
'MDP is not installed. Nothing done')
to_exec = 'target.bss_node=mdp.nodes.%sNode(' % algorithm
for key, value in kwargs.iteritems():
to_exec += '%s=%s,' % (key, value)
to_exec += ')'
exec(to_exec)
target.bss_node.train(factors)
unmixing_matrix = target.bss_node.get_recmatrix()
target.unmixing_matrix = np.dot(unmixing_matrix,invsqcovmat)
self._unmix_factors(target)
self._unmix_loadings(target)
self._auto_reverse_bss_component(target)
target.bss_algorithm = algorithm
def get_factors_as_spectrum(self):
from hyperspy._signals.spectrum import Spectrum
return Spectrum(self.learning_results.factors.T.copy())
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.fit()
self.m = m
def setUp(self):
s = Spectrum(range(100))
m = s.create_model()
m.append(Gaussian())
m.fit()
self.m = m
def setUp(self):
s = Spectrum(np.arange(40).reshape((2,20)))
s.axes_manager.signal_axes[0].scale = 0.1
s[:,8:12] = 0
self.s = s
def setUp(self):
self.s = Spectrum(np.arange(10))
self.s.axes_manager[0].scale = 0.2