Padasip

https://matousc89.github.io/padasip/
Admin
Padasip is a Python library for adaptive signal processing tasks including filtering, prediction,...
Tokens:46,829
Snippets:430
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Minimal Working Example

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/nlmf.html

An example demonstrating how to use the FilterNLMF for data filtering.

```APIDOC
## Minimal Working Example

### Description

This example shows how to generate synthetic data, identify it using the NLMF filter, and visualize the results.

### Code

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 0.3*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterNLMF(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```
```

--------------------------------

### Minimal PCA Application Example

Source: https://matousc89.github.io/padasip/sources/preprocess/pca.html

Demonstrates a minimal working example of PCA. Generates random data, applies PCA to reduce dimensions, and shows the resulting dataset structure. Requires numpy and padasip.

```python
import numpy as np
import padasip as pa

np.random.seed(100)
x = np.random.uniform(1, 10, (100, 3))
new_x = pa.preprocess.PCA(x, 2)
```

--------------------------------

### Minimal Working Example of PCA

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/pca.html

Demonstrates a minimal working example of PCA. It generates random data, applies PCA to reduce its dimensionality, and shows how to obtain the eigenvalues for component selection.

```python
import numpy as np
import padasip as pa

np.random.seed(100)
x = np.random.uniform(1, 10, (100, 3))
new_x = pa.preprocess.PCA(x, 2)
```

```python
import numpy as np
import padasip as pa

np.random.seed(100)
x = np.random.uniform(1, 10, (100, 3))
print pa.preprocess.PCA_components(x)
```

--------------------------------

### Usage Example for Standardization

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/standardize_back.html

This is a simple usage example demonstrating how to standardize a series using the `pa.standardize` function, which is the inverse operation of `standardize_back`.

```python
x = pa.standardize(xs, offset=a, scale=b)
```

--------------------------------

### Minimal Working Example for Standardization

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/standardize.html

Demonstrates how to standardize data using numpy and padasip. Shows the effect of standardization on the mean and standard deviation of a random numpy array.

```python
import numpy as np
import padasip as pa
x = np.random.random(1000)
x.mean()
0.49755420774866677
x.std()
0.29015765297767376
xs = pa.standardize(x)
xs.mean()
1.4123424652012772e-16
xs.std()
0.99999999999999989
```

--------------------------------

### Minimal Working Example of ESE

Source: https://matousc89.github.io/padasip/_modules/padasip/detection/ese.html

Demonstrates how ESE can highlight a perturbation in data using the NLMS adaptive filter. The example includes data creation, perturbation insertion, adaptive filter training, ESE estimation, and plotting the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# data creation
n = 5
N = 5000
x = np.random.normal(0, 1, (N, n))
d = np.sum(x, axis=1) + np.random.normal(0, 0.1, N)

# fake perturbation insertion
d[2500] += 2.

# creation of learning model (adaptive filter)
f = pa.filters.FilterNLMS(n, mu=1., w=np.ones(n))
y, e, w = f.run(d, x)

# estimation of ESE with weights from learning model
ese = pa.detection.ESE(w)

# ese plot
plt.plot(ese)
plt.show()
```

--------------------------------

### Direct Approach Usage

Source: https://matousc89.github.io/padasip/sources/detection/le.html

Example of using the Learning Entropy algorithm with the direct approach.

```APIDOC
## Direct Approach Example

### Usage
```python
le = pa.detection.learning_entropy(w, m=30, order=1)
```

### Parameters
- **w**: Matrix of the adaptive parameters (changing in time, every row should represent one time index).
- **m**: Window size.
- **order**: LE order.
```

--------------------------------

### Minimal Working Example of FilterVSLMS_Mathews

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/vslms_mathews.html

Shows a complete example of using the FilterVSLMS_Mathews for adaptive filtering. It includes data generation, filter instantiation, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4))  # input matrix
v = np.random.normal(0, 0.1, N)  # noise
d = 2 * x[:, 0] + 0.1 * x[:, 1] - 4 * x[:, 2] + 0.5 * x[:, 3] + v  # target

# identification
f = pa.filters.FilterVSLMS_Mathews(n=4, mu=0.1, ro=0.001, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15, 9))
plt.subplot(211);
plt.title("Adaptation");
plt.xlabel("samples - k")
plt.plot(d, "b", label="d - target")
plt.plot(y, "g", label="y - output");
plt.legend()
plt.subplot(212);
plt.title("Filter error");
plt.xlabel("samples - k")
plt.plot(10 * np.log10(e ** 2), "r", label="e - error [dB]");
plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Create and run an LMS filter with measured data

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/lms.html

This example demonstrates how to initialize an LMS filter with specified parameters, process target and input data, and visualize the adaptation and error results. It's suitable for offline analysis of recorded data.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterLMS(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Minimal Working Example for FilterAP

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/ap.html

Demonstrates how to use the FilterAP class to filter measured data. It includes data generation, filter initialization, running the filter, and visualizing the adaptation and error.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterAP(n=4, order=5, mu=0.5, ifc=0.001, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Full Working Example: NLMS Channel Identification

Source: https://matousc89.github.io/padasip/_modules/padasip/filters.html

A complete example demonstrating the use of the NLMS adaptive filter for channel identification. It includes data generation, filter adaptation, and visualization of the target signal, filter output, and error.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.AdaptiveFilter(model="NLMS", n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

## show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Minimal Working Example

Source: https://matousc89.github.io/padasip/sources/detection/le.html

Demonstrates how the multiscale approach LE can highlight the position of a perturbation inserted in data, using the Normalized Least-mean-square (NLMS) adaptive filter.

```APIDOC
```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# data creation
n = 5
N = 2000
x = np.random.normal(0, 1, (N, n))
d = np.sum(x, axis=1) + np.random.normal(0, 0.1, N)

# perturbation insertion
d[1000] += 2.

# creation of learning model (adaptive filter)
f = pa.filters.FilterNLMS(n, mu=1., w=np.ones(n))
y, e, w = f.run(d, x)

# estimation of LE with weights from learning model
le = pa.detection.learning_entropy(w, m=30, order=2, alpha=[8., 9., 10., 11., 12., 13.])

# LE plot
plt.plot(le)
plt.show()
```
```

--------------------------------

### Minimal Working Example for VSLMS_Benveniste Filter

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/vslms_benveniste.html

Demonstrates how to use the FilterVSLMS_Benveniste for adaptive filtering with measured data. It includes data generation, filter instantiation, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4))  # input matrix
v = np.random.normal(0, 0.1, N)  # noise
d = 2 * x[:, 0] + 0.1 * x[:, 1] - 4 * x[:, 2] + 0.5 * x[:, 3] + v  # target

# identification
f = pa.filters.FilterVSLMS_Benveniste(n=4, mu=0.1, ro=0.0002, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15, 9))
plt.subplot(211);
plt.title("Adaptation");
plt.xlabel("samples - k")
plt.plot(d, "b", label="d - target")
plt.plot(y, "g", label="y - output");
plt.legend()
plt.subplot(212);
plt.title("Filter error");
plt.xlabel("samples - k")
plt.plot(10 * np.log10(e ** 2), "r", label="e - error [dB]");
plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Minimal Working Example for Multiscale LE

Source: https://matousc89.github.io/padasip/_modules/padasip/detection/le.html

Demonstrates the multiscale approach of Learning Entropy to highlight a perturbation in data. It uses a NLMS adaptive filter and visualizes the LE output.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# data creation
n = 5
N = 2000
x = np.random.normal(0, 1, (N, n))
d = np.sum(x, axis=1) + np.random.normal(0, 0.1, N)

# perturbation insertion
d[1000] += 2.

# creation of learning model (adaptive filter)
f = pa.filters.FilterNLMS(n, mu=1., w=np.ones(n))
y, e, w = f.run(d, x)

# estimation of LE with weights from learning model
le = pa.detection.learning_entropy(w, m=30, order=2, alpha=[8., 9., 10., 11., 12., 13.])

# LE plot
plt.plot(le)
plt.show()
```

--------------------------------

### Real-time Filtering Example for FilterAP

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/ap.html

Illustrates how to filter data measured in real-time using the FilterAP class. It simulates online measurement functions and updates the filter iteratively.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# these two function supplement your online measurment
def measure_x():
    # it produces input vector of size 3
    x = np.random.random(3)
    return x

def measure_d(x):
    # meausure system output
    d = 2*x[0] + 1*x[1] - 1.5*x[2]
    return d

N = 100
log_d = np.zeros(N)
log_y = np.zeros(N)
filt = pa.filters.FilterAP(3, mu=1.)
for k in range(N):
    # measure input
    x = measure_x()
    # predict new value
    y = filt.predict(x)
    # do the important stuff with prediction output
    pass
    # measure output
    d = measure_d(x)
    # update filter
    filt.adapt(d, x)
    # log values
    log_d[k] = d
    log_y[k] = y

### show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(log_d,"b", label="d - target")
plt.plot(log_y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10((log_d-log_y)**2),"r", label="e - error [dB]")
plt.legend(); plt.tight_layout(); plt.show()
```

--------------------------------

### Determine Number of Principal Components

Source: https://matousc89.github.io/padasip/sources/preprocess/pca.html

This example shows how to check the eigenvalues of principal components to help decide on the optimal number of components to use. Requires numpy and padasip.

```python
import numpy as np
import padasip as pa

np.random.seed(100)
x = np.random.uniform(1, 10, (100, 3))
print pa.preprocess.PCA_components(x)
```

--------------------------------

### Run Llncosh Filter on Measured Data

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/llncosh.html

This example demonstrates how to use the FilterLlncosh to adaptively filter measured data. It includes data generation, filter initialization, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4))  # input matrix
v = np.random.normal(0, 0.1, N)  # noise
d = 2 * x[:, 0] + 0.1 * x[:, 1] - 4 * x[:, 2] + 0.5 * x[:, 3] + v  # target

# identification
f = pa.filters.FilterLlncosh(n=4, mu=0.1, lambd=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15, 9))
plt.subplot(211);
plt.title("Adaptation");
plt.xlabel("samples - k")
plt.plot(d, "b", label="d - target")
plt.plot(y, "g", label="y - output");
plt.legend()
plt.subplot(212);
plt.title("Filter error");
plt.xlabel("samples - k")
plt.plot(10 * np.log10(e ** 2), "r", label="e - error [dB]");
plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Minimal Working Example of ELBND

Source: https://matousc89.github.io/padasip/_modules/padasip/detection/elbnd.html

Demonstrates how ELBND highlights perturbations in data using an NLMS adaptive filter. The perturbation is manually inserted into the data.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# data creation
n = 5
N = 2000
x = np.random.normal(0, 1, (N, n))
d = np.sum(x, axis=1) + np.random.normal(0, 0.1, N)

# perturbation insertion
d[1000] += 2.

# creation of learning model (adaptive filter)
f = pa.filters.FilterNLMS(n, mu=1., w=np.ones(n))
y, e, w = f.run(d, x)

# estimation of LE with weights from learning model
elbnd = pa.detection.ELBND(w, e, function="max")

# ELBND plot
plt.plot(elbnd)
plt.show()
```

--------------------------------

### Multiscale Approach Usage

Source: https://matousc89.github.io/padasip/sources/detection/le.html

Example of using the Learning Entropy algorithm with the multiscale approach, specifying sensitivities.

```APIDOC
## Multiscale Approach Example

### Usage
```python
le = pa.detection.learning_entropy(w, m=30, order=1, alpha=[8., 9., 10., 11., 12., 13.])
```

### Parameters
- **w**: Matrix of the adaptive parameters (changing in time, every row should represent one time index).
- **m**: Window size.
- **order**: LE order.
- **alpha**: Vector of sensitivities.
```

--------------------------------

### Run LMF Filter with Data - padasip

Source: https://matousc89.github.io/padasip/sources/filters/lmf.html

Applies the LMF filter to measured data. This example generates synthetic input data 'x', noise 'v', and target signal 'd', then initializes and runs the LMF filter. Results including the output signal 'y', error 'e', and filter weights 'w' are returned. Visualization of adaptation and error is included.

```python
# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterLMF(n=4, mu=0.01, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### NLMS Filter Example (Real-time)

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/nlms.html

Illustrates using the FilterNLMS for real-time data filtering.

```APIDOC
## Real-time NLMS Filtering Example

### Description
This example demonstrates how to filter data measured in real-time using the `FilterNLMS` class.

### Code
```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# these two function supplement your online measurment
def measure_x():
    # it produces input vector of size 3
    x = np.random.random(3)
    return x

def measure_d(x):
    # meausure system output
    d = 2*x[0] + 1*x[1] - 1.5*x[2]
    return d

N = 100
log_d = np.zeros(N)
log_y = np.zeros(N)
filt = pa.filters.FilterNLMS(3, mu=1.)
for k in range(N):
    # measure input
    x = measure_x()
    # predict new value
    y = filt.predict(x)
    # do the important stuff with prediction output
    pass
    # measure output
    d = measure_d(x)
    # update filter
    filt.adapt(d, x)
    # log values
    log_d[k] = d
    log_y[k] = y

### show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(log_d,"b", label="d - target")
plt.plot(log_y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10((log_d-log_y)**2),"r", label="e - error [dB]")
plt.legend(); plt.tight_layout(); plt.show()
```
```

--------------------------------

### NLMF Filter Example

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/nlmf.html

Demonstrates filtering measured data using the NLMF filter. Requires numpy and matplotlib for data generation and visualization.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 0.3*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterNLMF(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Run NSSLMS Filter on Measured Data

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/nsslms.html

This example demonstrates how to use the FilterNSSLMS to adaptively filter measured data. It includes data generation, filter initialization, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 0.3*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterNSSLMS(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### OCNLMS System Identification Example - padasip

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/ocnlms.html

Demonstrates system identification using the OCNLMS filter with generated data. The memory size is set during filter construction. Results show the adaptation process and filter error in dB.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) + 121 # input matrix with offset
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification, memory is set to 100 samples
f = pa.filters.FilterOCNLMS(n=4, mu=0.1, w="random", mem=100)
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### NLMS Filter Example (Offline)

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/nlms.html

Demonstrates how to use the FilterNLMS for offline data filtering.

```APIDOC
## Offline NLMS Filtering Example

### Description
This example shows how to filter measured data using the `FilterNLMS` class in an offline scenario.

### Code
```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterNLMS(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```
```

--------------------------------

### Import Detection Tools in Padasip

Source: https://matousc89.github.io/padasip/_modules/padasip/detection.html

Imports necessary classes for detection tasks. ESE is conditionally imported and raises an ImportError if SciPy is not installed.

```python
from padasip.detection.le import learning_entropy
from padasip.detection.elbnd import ELBND


[docs]
def ese_not_imported(*args, **kwargs):
    """
    Raise error if ESE is called without scipy installed.
    """
    raise ImportError('You have to install scipy package in order to use ESE.')

try:
    from padasip.detection.ese import ESE
except ImportError:
    ESE = ese_not_imported
```

--------------------------------

### Run SSLMS Filter on Measured Data

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/sslms.html

Filters measured data using the SSLMS algorithm. This example demonstrates data generation, filter initialization, running the filter, and visualizing the adaptation and error.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 0.3*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterSSLMS(n=4, mu=0.01, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Filter data in real-time using LMS

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/lms.html

This example illustrates how to use the LMS filter for real-time data processing. It simulates online measurements of input and target signals, predicts output, and adapts the filter iteratively. The results are logged and visualized.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# these two function supplement your online measurment
def measure_x():
    # it produces input vector of size 3
    x = np.random.random(3)
    return x

def measure_d(x):
    # meausure system output
    d = 2*x[0] + 1*x[1] - 1.5*x[2]
    return d

N = 100
log_d = np.zeros(N)
log_y = np.zeros(N)
filt = pa.filters.FilterLMS(3, mu=1.)
for k in range(N):
    # measure input
    x = measure_x()
    # predict new value
    y = filt.predict(x)
    # do the important stuff with prediction output
    pass
    # measure output
    d = measure_d(x)
    # update filter
    filt.adapt(d, x)
    # log values
    log_d[k] = d
    log_y[k] = y

### show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(log_d,"b", label="d - target")
plt.plot(log_y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10((log_d-log_y)**2),"r", label="e - error [dB]")
plt.legend(); plt.tight_layout(); plt.show()
```

--------------------------------

### Calculate LDA discriminants and print eigenvalues

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/lda.html

This example demonstrates how to calculate the eigenvalues of the scatter matrix using `LDA_discriminants`. It also shows how to set a random seed for reproducibility and prints the resulting eigenvalues, which help in deciding the number of features to keep.

```python
import numpy as np
import padasip as pa

np.random.seed(100) # constant seed to keep the results consistent

N = 150 # number of samples
classes = np.array(["1", "a", 3]) # names of classes
cols = 4 # number of features (columns in dataset)

x = np.random.random((N, cols)) # random data
labels = np.random.choice(classes, size=N) # random labels

print pa.preprocess.LDA_discriminants(x, labels)
```

--------------------------------

### Reduce dataset features to 2 columns using LDA

Source: https://matousc89.github.io/padasip/sources/preprocess/lda.html

This example shows how to reduce the number of features in a dataset to 2 using the LDA function after determining the optimal number of columns from eigenvalues.

```python
import numpy as np
import padasip as pa

np.random.seed(100) # constant seed to keep the results consistent

N = 150 # number of samples
classes = np.array(["1", "a", 3]) # names of classes
cols = 4 # number of features (columns in dataset)

x = np.random.random((N, cols)) # random data
labels = np.random.choice(classes, size=N) # random labels

new_x = pa.preprocess.LDA(x, labels, n=2)
```

--------------------------------

### RLS Filter with Measured Data

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/rls.html

Filter measured data using the RLS algorithm. This example demonstrates data generation, filter initialization, running the filter, and visualizing the adaptation and error.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterRLS(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Reduce features to 2 using LDA and verify shapes

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/lda.html

This example shows how to reduce the number of features in a dataset to 2 using the `LDA` function. It also includes code to print the shapes of the original and the new dataset to confirm the dimensionality reduction.

```python
import numpy as np
import padasip as pa

np.random.seed(100) # constant seed to keep the results consistent

N = 150 # number of samples
classes = np.array(["1", "a", 3]) # names of classes
cols = 4 # number of features (columns in dataset)

x = np.random.random((N, cols)) # random data
labels = np.random.choice(classes, size=N) # random labels

new_x = pa.preprocess.LDA(x, labels, n=2)

to check if the size of new data-set is really correct we can print the shapes
as follows

>>> print "Shape of original dataset: {}".format(x.shape)
Shape of original dataset: (150, 4)
>>> print "Shape of new dataset: {}".format(new_x.shape)
Shape of new dataset: (150, 2)
```

--------------------------------

### OCNLMS Filter Example

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/ocnlms.html

Example of system identification using the OCNLMS filter with a specified memory size.

```APIDOC
## OCNLMS Filter Example

### Description
This example demonstrates how to use the `FilterOCNLMS` for system identification from measured data, including setting the memory size.

### Code
```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) + 121 # input matrix with offset
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification, memory is set to 100 samples
f = pa.filters.FilterOCNLMS(n=4, mu=0.1, w="random", mem=100)
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```
```

--------------------------------

### Initialize Learning Entropy (Direct Approach)

Source: https://matousc89.github.io/padasip/_modules/padasip/detection/le.html

Initialize the Learning Entropy algorithm using the direct approach. This method evaluates LE for each sample based on the difference between the current weight increment and the average of absolute increments within a window.

```python
le = pa.detection.learning_entropy(w, m=30, order=1)
```

--------------------------------

### Create and run LMF filter

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/lmf.html

Demonstrates how to create an LMF filter with specified parameters and run it on input data to obtain output, error, and filter weights. Includes visualization of adaptation and error.

```python
import padasip as pa
import numpy as np
import matplotlib.pyplot as plt

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterLMF(n=4, mu=0.01, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### VSLMS Ang Filter Minimal Working Example

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/vslms_ang.html

This example demonstrates how to use the FilterVSLMS_Ang class to filter measured data. It includes data generation, filter initialization, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4))  # input matrix
v = np.random.normal(0, 0.1, N)  # noise
d = 2 * x[:, 0] + 0.1 * x[:, 1] - 4 * x[:, 2] + 0.5 * x[:, 3] + v  # target

# identification
f = pa.filters.FilterVSLMS_Ang(n=4, mu=0.1, ro=0.0002, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15, 9))
plt.subplot(211);
plt.title("Adaptation");
plt.xlabel("samples - k")
plt.plot(d, "b", label="d - target")
plt.plot(y, "g", label="y - output");
plt.legend()
plt.subplot(212);
plt.title("Filter error");
plt.xlabel("samples - k")
plt.plot(10 * np.log10(e ** 2), "r", label="e - error [dB]");
plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Create and Run GNGD Filter

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/gngd.html

Demonstrates how to create a GNGD filter and apply it to measured data for system identification. It includes data generation, filter initialization, running the filter, and visualizing the results.

```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 4*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterGNGD(n=4, mu=0.1, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```

--------------------------------

### Initialize Learning Entropy (Multiscale Approach)

Source: https://matousc89.github.io/padasip/_modules/padasip/detection/le.html

Initialize the Learning Entropy algorithm using the multiscale approach. This method involves a summation over weights, considering detection sensitivities (alpha) to evaluate LE.

```python
le = pa.detection.learning_entropy(w, m=30, order=1, alpha=[8., 9., 10., 11., 12., 13.])
```

--------------------------------

### Create Input Matrix from History (Python)

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/input_from_history.html

Demonstrates how to generate an input matrix for adaptive filters using historical data. Specify the number of past samples to include in each row.

```python
import numpy as np
import padasip as pa
a = np.arange(1, 7, 1)
a
array([1, 2, 3, 4, 5, 6])
pa.input_from_history(a,3)
array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])
```

--------------------------------

### FilterSSLMS Initialization and Usage

Source: https://matousc89.github.io/padasip/_modules/padasip/filters/sslms.html

Demonstrates how to initialize and use the FilterSSLMS class for adaptive filtering. It includes data generation, filter instantiation, running the filter, and visualizing the results.

```APIDOC
## FilterSSLMS

### Description
This class represents an adaptive SSLMS filter.

### Method Signature
```python
pa.filters.FilterSSLMS(n, mu=0.1, w='zeros', **kwargs)
```

### Parameters
*   **n** (int) - The size (number of taps) of the filter.
*   **mu** (float, optional) - The learning rate (step size). Defaults to 0.1.
*   **w** (str or numpy.ndarray, optional) - Initial weights. Can be 'zeros', 'random', or a numpy array. Defaults to 'zeros'.
*   **kwargs** - Additional keyword arguments passed to the base class.

### Example
```python
import numpy as np
import matplotlib.pylab as plt
import padasip as pa

# creation of data
N = 500
x = np.random.normal(0, 1, (N, 4)) # input matrix
v = np.random.normal(0, 0.1, N) # noise
d = 2*x[:,0] + 0.1*x[:,1] - 0.3*x[:,2] + 0.5*x[:,3] + v # target

# identification
f = pa.filters.FilterSSLMS(n=4, mu=0.01, w="random")
y, e, w = f.run(d, x)

# show results
plt.figure(figsize=(15,9))
plt.subplot(211);plt.title("Adaptation");plt.xlabel("samples - k")
plt.plot(d,"b", label="d - target")
plt.plot(y,"g", label="y - output");plt.legend()
plt.subplot(212);plt.title("Filter error");plt.xlabel("samples - k")
plt.plot(10*np.log10(e**2),"r", label="e - error [dB]");plt.legend()
plt.tight_layout()
plt.show()
```
```

--------------------------------

### Get ordered eigenvalues of principal components

Source: https://matousc89.github.io/padasip/_modules/padasip/preprocess/pca.html

Calculates and returns the ordered eigenvalues of the principal components for the input data `x`. This is useful for determining the number of components to retain.

```python
eigenvalues = pa.preprocess.PCA_components(x)
```
Tokens:
Raw