Sparse Coding mit vorgeberechnetem Wörterbuch

Einführung

In diesem Lab werden wir lernen, wie man ein Signal als eine dünn besetzte Kombination von Ricker-Wellenletten mithilfe von dünn besetzten Codierungsmethoden transformiert. Der Ricker (auch bekannt als Mexikanisches Hut oder die zweite Ableitung einer Gaußschen Funktion) ist kein besonders guter Kern, um stückweise konstante Signale wie dieses zu repräsentieren. Man kann daher sehen, wie wichtig es ist, Atome unterschiedlicher Breiten hinzuzufügen, und es ist daher sinnvoll, das Wörterbuch so zu lernen, dass es am besten zu Ihrem Signaltyp passt.

Wir werden visuelle Vergleiche zwischen verschiedenen dünn besetzten Codierungsmethoden mit dem Schätzer SparseCoder durchführen. Das reichere Wörterbuch rechts ist nicht größer, sondern es wird eine stärkere Subsampling durchgeführt, um auf die gleiche Größenordnung zu bleiben.

Tipps für die VM

Nachdem der VM-Start abgeschlossen ist, klicken Sie in der oberen linken Ecke, um zur Registerkarte Notebook zu wechseln und Jupyter Notebook für die Übung zu öffnen.

Manchmal müssen Sie einige Sekunden warten, bis Jupyter Notebook vollständig geladen ist. Die Validierung von Vorgängen kann aufgrund von Einschränkungen in Jupyter Notebook nicht automatisiert werden.

Wenn Sie während des Lernens Probleme haben, können Sie Labby gerne fragen. Geben Sie nach der Sitzung Feedback, und wir werden das Problem für Sie prompt beheben.

Bibliotheken importieren

Wir beginnen mit dem Import der erforderlichen Bibliotheken.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.decomposition import SparseCoder

Definiere Ricker-Wellenlet-Funktionen

Wir werden Funktionen definieren, um einen Ricker-Wellenlet und ein Wörterbuch von Ricker-Wellenletten zu generieren.

def ricker_function(resolution, center, width):
    """Diskreter sub-samplierter Ricker (Mexikanischer Hut) -Wellenlet"""
    x = np.linspace(0, resolution - 1, resolution)
    x = (
        (2 / (np.sqrt(3 * width) * np.pi**0.25))
        * (1 - (x - center) ** 2 / width**2)
        * np.exp(-((x - center) ** 2) / (2 * width**2))
    )
    return x


def ricker_matrix(width, resolution, n_components):
    """Wörterbuch von Ricker (Mexikanischer Hut) -Wellenletten"""
    centers = np.linspace(0, resolution - 1, n_components)
    D = np.empty((n_components, resolution))
    for i, center in enumerate(centers):
        D[i] = ricker_function(resolution, center, width)
    D /= np.sqrt(np.sum(D**2, axis=1))[:, np.newaxis]
    return D

Generiere ein Signal

Wir werden ein Signal generieren und es mit Matplotlib visualisieren.

resolution = 1024
subsampling = 3  ## subsampling factor
width = 100
n_components = resolution // subsampling

## Generate a signal
y = np.linspace(0, resolution - 1, resolution)
first_quarter = y < resolution / 4
y[first_quarter] = 3.0
y[np.logical_not(first_quarter)] = -1.0

## Visualize the signal
plt.figure()
plt.plot(y)
plt.title("Original Signal")
plt.show()

Berechne ein Wellenlet-Wörterbuch

Wir werden ein Wellenlet-Wörterbuch berechnen und es mit Matplotlib visualisieren.

## Compute a wavelet dictionary
D_fixed = ricker_matrix(width=width, resolution=resolution, n_components=n_components)
D_multi = np.r_[
    tuple(
        ricker_matrix(width=w, resolution=resolution, n_components=n_components // 5)
        for w in (10, 50, 100, 500, 1000)
    )
]

## Visualize the wavelet dictionary
plt.figure(figsize=(10, 5))
for i, D in enumerate((D_fixed, D_multi)):
    plt.subplot(1, 2, i + 1)
    plt.imshow(D, cmap=plt.cm.gray, interpolation="nearest")
    plt.title("Wellenlet-Wörterbuch (%s)" % ("fester Breite" if i == 0 else "mehrere Breiten"))
    plt.axis("off")
plt.show()

Sparse Coding

Wir werden Sparse Coding auf dem Signal mit verschiedenen Methoden durchführen und die Ergebnisse visualisieren.

## List the different sparse coding methods in the following format:
## (title, transform_algorithm, transform_alpha,
##  transform_n_nozero_coefs, color)
estimators = [
    ("OMP", "omp", None, 15, "navy"),
    ("Lasso", "lasso_lars", 2, None, "turquoise"),
]
lw = 2

plt.figure(figsize=(13, 6))
for subplot, (D, title) in enumerate(
    zip((D_fixed, D_multi), ("fixed width", "multiple widths"))
):
    plt.subplot(1, 2, subplot + 1)
    plt.title("Sparse coding against %s dictionary" % title)
    plt.plot(y, lw=lw, linestyle="--", label="Original signal")
    ## Do a wavelet approximation
    for title, algo, alpha, n_nonzero, color in estimators:
        coder = SparseCoder(
            dictionary=D,
            transform_n_nonzero_coefs=n_nonzero,
            transform_alpha=alpha,
            transform_algorithm=algo,
        )
        x = coder.transform(y.reshape(1, -1))
        density = len(np.flatnonzero(x))
        x = np.ravel(np.dot(x, D))
        squared_error = np.sum((y - x) ** 2)
        plt.plot(
            x,
            color=color,
            lw=lw,
            label="%s: %s nonzero coefs,\n%.2f error" % (title, density, squared_error),
        )

    ## Soft thresholding debiasing
    coder = SparseCoder(
        dictionary=D, transform_algorithm="threshold", transform_alpha=20
    )
    x = coder.transform(y.reshape(1, -1))
    _, idx = np.where(x!= 0)
    x[0, idx], _, _, _ = np.linalg.lstsq(D[idx, :].T, y, rcond=None)
    x = np.ravel(np.dot(x, D))
    squared_error = np.sum((y - x) ** 2)
    plt.plot(
        x,
        color="darkorange",
        lw=lw,
        label="Thresholding w/ debiasing:\n%d nonzero coefs, %.2f error"
        % (len(idx), squared_error),
    )
    plt.axis("tight")
    plt.legend(shadow=False, loc="best")
plt.subplots_adjust(0.04, 0.07, 0.97, 0.90, 0.09, 0.2)
plt.show()

Zusammenfassung

In diesem Lab haben wir gelernt, wie man ein Signal als eine spärliche Kombination von Ricker-Wellenletten mit Hilfe von Sparse-Coding-Methoden und dem SparseCoder-Schätzer transformiert. Wir haben auch verschiedene Sparse-Coding-Methoden verglichen und die Ergebnisse visualisiert.