Machine learning¶

Principal component analysis¶

One of the most popular decomposition methods is principal component analysis (PCA). To perform PCA on your dataset, run the decomposition() method:

>>> s.decomposition()

Note that the s variable must contain either a BaseSignal class or its subclasses, which will most likely have been loaded with the load() function, e.g. s = load('my_file.hdf5'). Also, the signal must be multi-dimensional, that is s.axes_manager.navigation_size must be greater than one.

Several algorithms exist for performing PCA, and the default algorithm in HyperSpy is SVD, which uses an approach called “singular value decomposition”. This method has many options, and for more information please read the method documentation.

Scree plots¶

PCA will sort the components in the dataset in order of decreasing variance. It is often useful to estimate the dimensionality of the data by plotting the explained variance against the component index. This plot is sometimes called a scree plot and it should drop quickly, eventually becoming a slowly descending line.

The point at which the scree plot becomes linear (often referred to as the elbow) is generally judged to be a good estimation of the dimensionality of the data (or equivalently, the number of components that should be retained - see below).

To obtain a scree plot for your dataset, run the plot_explained_variance_ratio() method:

>>> ax = s.plot_explained_variance_ratio()

PCA scree plot

Note that in the figure, the first component has index 0. This is because Python uses zero based indexing i.e. the initial element of a sequence is found at index 0.

New in version 0.7.

Sometimes it can be useful to get the explained variance ratio as a spectrum, for example to plot several scree plots obtained using different data pre-treatmentd in the same figure using plot_spectra(). This can be achieved using get_explained_variance_ratio()

>>> sc = s.get_decomposition_model(components)

>>> (s - sc).plot()

Poissonian noise¶

Many decomposition methods such as PCA assume that the noise of the data follows a Gaussian distribution. In cases where your data is instead corrupted by Poisson noise, HyperSpy can “normalize” the data by performing a scaling operation, which can greatly enhance the result.

To perform Poissonian noise normalization:

More details about the scaling procedure can be found in [Keenan2004].

Robust principal component analysis¶

PCA is known to be very sensitive to the presence of outliers in data. These outliers can be the result of missing or dead pixels, X-ray spikes, or very low count data. If one assumes a dataset to consist of a low-rank component L corrupted by a sparse error component S, then Robust PCA (RPCA) can be used to recover the low-rank component for subsequent processing [Candes2011].

The default RPCA algorithm is GoDec [Zhou2011]. In HyperSpy it returns the factors and loadings of L, and can be accessed with the following code. You must set the “output_dimension” when using RPCA.

>>> s.decomposition(algorithm='RPCA_GoDec',
                    output_dimension=3)

HyperSpy also implements an online algorithm for RPCA developed by Feng et al. [Feng2013]. This minimizes memory usage, making it suitable for large datasets, and can often be faster than the default algorithm.

>>> s.decomposition(algorithm='ORPCA',
                    output_dimension=3)

The online RPCA implementation sets several default parameters that are usually suitable for most datasets. However, to improve the convergence you can “train” the algorithm with the first few samples of your dataset. For example, the following code will train ORPCA using the first 32 samples of the data.

>>> s.decomposition(algorithm='ORPCA',
                    output_dimension=3
                    training_samples=32)

Finally, online RPCA includes two alternative methods to the default solver, which can again improve the convergence and speed of the algorithm. The first is block-coordinate descent (BCD), and the second is based on stochastic gradient descent (SGD), which takes an additional parameter to set the learning rate.

>>> s.decomposition(algorithm='ORPCA',
                    output_dimension=3
                    method='BCD',
                    training_samples=32)

>>> s.decomposition(algorithm='ORPCA',
                    output_dimension=3
                    method='SGD',
                    learning_rate=1.1,
                    training_samples=32)

Non-negative matrix factorization¶

Another popular decomposition method is non-negative matrix factorization (NMF), which can be accessed in HyperSpy with:

>>> s.decomposition(algorithm='nmf')

Unlike PCA, NMF forces the components to be strictly non-negative, which can aid the physical interpretation of components for count data such as images, EELS or EDS.

Saving in the main file¶

If you save the dataset on which you’ve performed machine learning analysis in the HDF5 format (the default in HyperSpy) (see Saving data to files), the result of the analysis is also saved in the same file automatically, and it is loaded along with the rest of the data when you next open the file.

Saving to an external file¶

Alternatively, you can save the results of the current machine learning analysis to a separate file with the save() method:

Save the result of the analysis
>>> s.learning_results.save('my_results')

Load back the results
>>> s.learning_results.load('my_results.npz')

Exporting in different formats¶

It is also possible to export the results of machine learning to any format supported by HyperSpy with:

• export_decomposition_results() or
• export_bss_results().

These methods accept many arguments to customise the way in which the data is exported, so please consult the method documentation. The options include the choice of file format, the prefixes for loadings and factors, saving figures instead of data and more.