Skip to content

data.preprocs.ProcLifter

Class ยท Source

proc = mdnc.data.preprocs.ProcLifter(
    a, inds=None, parent=None
)

This is a homogeneous processor. It use the parameter a to perform such an invertible transform:

\mathbf{y}_n = \mathrm{sign} (\mathbf{x}_n) * \log (1 + a * |\mathbf{x}_n|)

This transform could strengthen the low-amplitude parts of the signal, because the data is transformed into the log domain.

Arguments

Requries

Argument Type Description
a float The parameter used for log-lifting the data.
inds int or
(int, )		 Index or indicies of variables where the user implemented methods would be broadcasted. The variables not listed in this argument would be passed to the output without any processing. If set None, methods would be broadcasted to all variables.
parent ProcAbstract Another instance derived from mdnc.data.preprocs.ProcAbstract. The output of parent.preprocess() would be used as the input of self.preprocess(). The input of self.postprocess() would be used as the input of parent.preprocess().

Methods

preprocess

y_1, y_2, ... = proc.preprocess(x_1, x_2, ...)

The preprocess function. Perform the log-lifting.

If parent exists, the input of this function comes from the output of parent.preprocess(). Otherwise, the input would comes from the input varibable directly.

Requries

Argument Type Description
(x, ) np.ndarray A sequence of variables. Each variable comes from the parent's outputs (if parent exists). The output of this method would be passed as the input of the next processor (if this processor is used as parent).

Returns

Argument Description
(y, ) A sequence of np.ndarray, the final preprocessed data.

postprocess

x_1, x_2, ... = proc.postprocess(y_1, y_2, ...)

The postprocess function. The inverse operator of the lifting.

If parent exists, the output of this function would be passed as the input of parent.postprocess(). Otherwise, the output would be returned to users directly.

Requries

Argument Type Description
(y, ) np.ndarray A sequence of variables. Each variable comes from the next processors's outputs (if parent exists). The output of this method would be passed as the input of the parent's method.

Returns

Argument Description
(x, ) A sequence of np.ndarray, the final postprocessed data.

Properties

a

proc.a

The lifting parameter \(a\).

parent

proc.parent

The parent processor of this instance. The processor is also a derived class of ProcAbstract. If the parent does not exist, would return None.

has_ind

proc.has_ind

A bool flag, showing whether this processor and its all parent processors have inds configured or initialized with _disable_inds. In this case, the arguments of preprocess() and postprocess() would not share the same operation. We call such kind of processors "Inhomogeneous processors".

Examples

The processor need to be derived. We have two ways to implement the derivation, see the following examples.

Example
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
import numpy as np
import matplotlib.pyplot as plt
import mdnc

t = np.linspace(-2 * np.pi, 2 * np.pi, 200)
proc = mdnc.data.preprocs.ProcLifter(a=10.0)
x = np.cos(np.pi * t) + 0.5 * np.cos(1.5 * np.pi * t + 0.1) + 0.2 * np.cos(2.5 * np.pi * t + 0.3) + 0.1 * np.cos(3.5 * np.pi * t + 0.7)
x_ = proc.preprocess(x)
xr = proc.postprocess(x_)

with mdnc.utils.draw.setFigure(font_size=12):
    fig, axs = plt.subplots(nrows=3, ncols=1, sharex=True, figsize=(12, 5))
    axs[0].plot(t, x_)
    axs[1].plot(t, xr)
    axs[2].plot(t, x)
    axs[0].set_ylabel('Preprocessing')
    axs[1].set_ylabel('Inversed\npreprocessing')
    axs[2].set_ylabel('Raw\ndata')
    plt.tight_layout()
    plt.show()

Last update: March 14, 2021

Comments