Wolfram Language & System Documentation Center

WaveletBestBasis

computes a best basis representation in the DiscreteWaveletData object dwd.

computes a best basis representation using the cost specification cspec.

Details and Options

WaveletBestBasis[dwd] returns a DiscreteWaveletData odwd object where the optimal basis has been computed and will be used by functions such as InverseWaveletTransform, WaveletListPlot, etc.
Properties of the DiscreteWaveletData odwd can be found using odwd["prop"].
Properties related to best basis include:

	"BasisIndex"	wavelet indices used for inverse transform
	"BestBasisBlockView"	block grid view of best basis
	"BestBasisCostValues"	cost value for each wavelet coefficient
	"TreeView"	tree view of decomposition with best basis highlighted

WaveletBestBasis[dwd] is equivalent to WaveletBestBasis[dwd,"ShannonEntropy"].
Possible cspec values include:

	"ShannonEntropy"	Shannon entropy
	"LogEnergy"	log energy
	{"Norm",p}	norm like $sum_iTemplateBox[{{w, _, i}}, Abs]^p$ for and $-sum_iTemplateBox[{{w, _, i}}, Abs]^p$ for
	{"Threshold",δ}	number of elements above
	fn	apply fn to each coefficient array to get a cost value

A cost function fn must satisfy fn[{a₁,…,a_m,b₁,…,b_n}]fn[{a₁,…,a_m}]+fn[{b₁,…,b_n}] and fn[{0,…}]0.
The best basis is a complete basis for the wavelet decomposition giving the least total cost.

Examples

open all close all

Basic Examples (1)

Compute an optimal wavelet basis:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{0, 0, 1, 1}];

Wolfram Language code: best = WaveletBestBasis[dwd]

Compare default basis with best basis in a tree plot of all coefficients:

Wolfram Language code: {Labeled[dwd[{"TreeView", Left}], Text["default basis"]], Labeled[best[{"TreeView", Left}], Text["best basis"]]}

Scope (11)

Basic Uses (6)

Compute an optimal wavelet basis for vector data:

Wolfram Language code: dwd = WaveletBestBasis[DiscreteWaveletPacketTransform[{1, 1, 2, 3, 2, 2}]]

The best basis is stored in the resulting DiscreteWaveletData object:

Wolfram Language code: dwd["BasisIndex"]

Show the coefficient array corresponding to each index in the basis:

Wolfram Language code: dwd[Automatic]

Wavelet packet transforms give a DiscreteWaveletData object that includes a default basis:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{0, 0, 1, 1, 1, 2, 3, 4}];

Wolfram Language code: dwd["BasisIndex"]

The basis includes all coefficients at the highest level of refinement:

Wolfram Language code: dwd[{"TreeView", Left}]

WaveletBestBasis gives a new DiscreteWaveletData object with a different, optimal basis:

Wolfram Language code: WaveletBestBasis[dwd]["BasisIndex"]

Wolfram Language code: WaveletBestBasis[dwd][{"TreeView", Left}]

Compute best basis for packet transforms with any number of levels of refinement:

Wolfram Language code:

Table[WaveletBestBasis[DiscreteWaveletPacketTransform[{1, 2, 8, 6, 0, 7, 6, 3, 8, 3, 5, 9}, Automatic, r]]["BestBasisBlockView"], {r, 4}]

Compute wavelet basis, minimizing log-energy for an image:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[[image], CDFWavelet[], 3];

Wolfram Language code: best = WaveletBestBasis[dwd, "LogEnergy"]

Compare default basis with best basis in a hierarchical grid layout of coefficient images:

Wolfram Language code: {Labeled[WaveletImagePlot[dwd], Text@"default basis"], Labeled[WaveletImagePlot[best], Text@"best basis"]}

Compute best basis with custom cost function:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{3.3, 4.3, 0.7, 0.5, 0.6, 2.8, 2.7, 4.9}]

Choose basis with fewest coefficients lying between -1 and 1:

Wolfram Language code: cost[coeff_] := -Count[coeff, u_ /; ¬-1 < u < 1]

Wolfram Language code: best = WaveletBestBasis[dwd, cost]

Count values lying between -1 and 1 in default basis:

Wolfram Language code: Count[Last /@ dwd[Automatic], u_ /; -1 < u < 1, ∞]

Best basis:

Wolfram Language code: Count[Last /@ best[Automatic], u_ /; -1 < u < 1, ∞]

WaveletBestBasis gives the optimal basis among all possible wavelet bases:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[RandomReal[1, 32], Automatic, 5];

Wolfram Language code: best = WaveletBestBasis[dwd]

Recursively enumerate all possible wavelet bases for levels of refinement:

Wolfram Language code:

b[n_, i___] := Prepend[Flatten[Outer[Join, b[n, i, 0], b[n, i, 1], 1], 1], {{i}}]
b[n_, i___] := {{{i}}} /; Length[{i}] == n

Show the 5 possible wavelet bases for 2 levels of refinement:

Wolfram Language code: Framed /@ b[2]

The number of possible bases grows extremely quickly as a function of refinement level:

Wolfram Language code: ListLogPlot[Table[Length[b[n]], {n, 5}], Joined -> True, PlotMarkers -> Automatic]

Cost value of optimal basis:

Wolfram Language code: Total[best["BasisIndex"] /. best["BestBasisCostValues"]]

Distribution of cost values of a random sample of 1000 bases:

Wolfram Language code: Histogram[Map[Total, RandomSample[b[5], 1000] /. best["BestBasisCostValues"]]]

Cost Functions (5)

Apply cost functions to coefficients with fixed total energy:

Wolfram Language code: w = {Sqrt[e], Sqrt[1 - e]};

Plot cost as a function of first component energy for "ShannonEntropy":

Wolfram Language code: Plot[Total[-w^2Log[w^2]], {e, 0, 1}]

"LogEnergy":

Wolfram Language code: Plot[Total[Log[w^2]], {e, 0, 1}]

{"Norm",p}:

Wolfram Language code: Table[Plot[Total[If[0 < p < 2, Abs[w]^p, -Abs[w]^p]], {e, 0, 1}, PlotLabel -> p], {p, {0.5, 1.5, 3}}]

{"Threshold",δ}:

Wolfram Language code:

Table[Plot[Total[Boole[Thread[Abs[w] > δ]]], {e, 0, 1}, PlotLabel -> δ, Exclusions -> None, PlotRange -> {0, 2}], {δ, {0.3, 0.6, 0.9}}]

In general, each cost function can lead to a different best basis:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{3.8, 6.5, 0.8, 8.3, 9.5, 5.7, 6., 1.3, 5.2, 7.5, 1., 9.4, 7.8, 6.3, 8.8, 9.8}];

Wolfram Language code:

Table[Labeled[WaveletBestBasis[dwd, cf]["BestBasisBlockView"], Text@cf], {cf, {"ShannonEntropy", {"Norm", 1}, {"Norm", 3}, "LogEnergy", {"Threshold", 0.5}, {"Threshold", 2}}}]

Plot distribution of energy among best basis coefficient values for each cost function:

Wolfram Language code:

Table[ListLogPlot[Sort[Flatten[Last /@ WaveletBestBasis[dwd, cf][Automatic]]^2], PlotLabel -> cf, Filling -> Axis, PlotRange -> {0.0001, 1000}], {cf, {"ShannonEntropy", {"Norm", 1}, {"Norm", 3}, "LogEnergy", {"Threshold", 0.5}, {"Threshold", 2}}}]

Different cost functions often lead to similar best bases:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[RandomReal[10, 16]];

Wolfram Language code:

Table[Labeled[WaveletBestBasis[dwd, c]["BestBasisBlockView"], Text@c], {c, {"ShannonEntropy", {"Norm", 1}, {"Norm", 3}, "LogEnergy", {"Threshold", 0.5}, {"Threshold", 2}}}]

Define a custom cost function that favors coefficients that are nearer to integers:

Wolfram Language code: int[w_] := Norm[w - Round[w], 2] ^ 2

Best basis for list data using custom cost function:

Wolfram Language code: d = RandomReal[3, 16];

Wolfram Language code: dwd = WaveletBestBasis[DiscreteWaveletPacketTransform[d, Automatic, 4], int]

The computed cost value for the {} coefficient is the custom cost value of the original data:

Wolfram Language code: {int[d], {} /. dwd["BestBasisCostValues"]}

Cost value of the best basis coefficients:

Wolfram Language code: Total[dwd["BasisIndex"] /. dwd["BestBasisCostValues"]]

The best basis coefficients are clustered around integers:

Wolfram Language code: ListPlot[Sort@Flatten[dwd["BasisIndex"] /. Normal[dwd]], PlotRange -> All]

Reproduce the built-in cost functions as custom ones:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[RandomReal[10, 16]]

"ShannonEntropy":

Wolfram Language code: shannon[w_] := Piecewise[{{-w^2Log[w^2], w ≠ 0}}]

Wolfram Language code:

{WaveletBestBasis[dwd, v  Total@Map[shannon, v]]["BestBasisBlockView"], WaveletBestBasis[dwd, "ShannonEntropy"]["BestBasisBlockView"]}

"LogEnergy":

Wolfram Language code: loge[w_] := Piecewise[{{Log[w^2], w ≠ 0}}]

Wolfram Language code:

{WaveletBestBasis[dwd, v  Total@Map[loge, v]]["BestBasisBlockView"], WaveletBestBasis[dwd, "LogEnergy"]["BestBasisBlockView"]}

"Norm":

Wolfram Language code: pwnorm[w_, p_] := Piecewise[{{Norm[w, p] ^ p, 0 < p < 2}, {-Norm[w, p] ^ p, p ≥ 2}}]

Wolfram Language code: {WaveletBestBasis[dwd, pwnorm[#, 3]&]["BestBasisBlockView"], WaveletBestBasis[dwd, {"Norm", 3}]["BestBasisBlockView"]}

"Threshold":

Wolfram Language code: thr[w_, δ_] := Count[w, u_ /; Abs[u] > δ]

Wolfram Language code: {WaveletBestBasis[dwd, thr[#, 1]&]["BestBasisBlockView"], WaveletBestBasis[dwd, {"Threshold", 1}]["BestBasisBlockView"]}

Generalizations & Extensions (2)

Explicitly specify the full wavelet basis:

Wolfram Language code: dwd = WaveletBestBasis[DiscreteWaveletPacketTransform[{1, 2, 3, 5}], {{1}, {0, 1}, {0, 0}}]

The specified basis is taken to be the best basis:

Wolfram Language code: dwd["BestBasisBlockView"]

Select a basis containing the specified wavelet indexes:

Wolfram Language code: dwd = WaveletBestBasis[DiscreteWaveletPacketTransform[Range[8]], {{1}, {0, 0, 0}}]

The smallest full basis containing the specified indexes is chosen:

Wolfram Language code: dwd[{"TreeView", Left}]

Applications (3)

Compression (3)

Use WaveletBestBasis to choose a wavelet basis for threshold-based data compression:

Wolfram Language code: data = Table[Sin[x + x ^ 2], {x, 0, 10, 0.01}];

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[data, DaubechiesWavelet[4], 4]]

Use a hard threshold of 0.1:

Wolfram Language code: dwd = WaveletThreshold[%, {"Hard", 0.1}]

Count nonzero values in thresholded coefficients as a measure of compression:

Wolfram Language code: Count[Last /@ dwd[Automatic], Except[0.], ∞]

Compare with compression by thresholding original data:

Wolfram Language code: Count[Chop[data, 0.2], Except[0], ∞]

Plot original and reconstructed data:

Wolfram Language code: {ListLinePlot[data], ListLinePlot[InverseWaveletTransform[dwd]]}

Compare threshold-based compression for various threshold values :

Wolfram Language code: data = Table[Sin[x + x ^ 2], {x, 0, 10, 0.01}];

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[data, DaubechiesWavelet[], 4];

Use the same threshold value for best basis selection and thresholding:

Wolfram Language code: dwds = Table[WaveletThreshold[WaveletBestBasis[dwd, {"Threshold", δ}], {"Hard", δ}], {δ, {0.05, 0.1, 0.2, 0.5}}]

Show reconstructed data along with the number of nonzero values as a measure of compression:

Wolfram Language code:

Table[ListLinePlot[InverseWaveletTransform[d], PlotLabel -> Row[{"non-zero values: ", Count[Last /@ d[Automatic], Except[0.], ∞]}]], {d, dwds}]

Length of uncompressed original data:

Wolfram Language code: Length[data]

Simple lossy image compression for various threshold values :

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[[image], CDFWavelet[], 3];

Wolfram Language code: dwds = Table[WaveletThreshold[WaveletBestBasis[dwd, {"Threshold", δ}], {"Hard", δ}], {δ, {0.02, 0.05, 0.2, 0.5}}]

Show reconstructed data along with the number of nonzero values as a measure of compression:

Wolfram Language code:

Table[Labeled[InverseWaveletTransform[d], Text["non-zero values: " <> ToString[Count[Last /@ d[Automatic], Except[0.], ∞]]]], {d, dwds}]

Total number of pixel values in all channels of original image:

Wolfram Language code: ImageChannels[[image]] * Apply[Times, ImageDimensions[[image]]]

Properties & Relations (4)

The best basis coefficients typically contain fewer, larger nonzero values than the original data:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{0, 0, 1, 1}];

Wolfram Language code: best = WaveletBestBasis[dwd];

Compare default basis for wavelet packet transforms with best basis:

Wolfram Language code: dwd[Automatic]

Wolfram Language code: best[Automatic]

Compare with the basis for non-packet wavelet transforms:

Wolfram Language code: DiscreteWaveletTransform[{0, 0, 1, 1}][Automatic]

Non-packet transforms give a DiscreteWaveletData object with a permanently fixed basis:

Wolfram Language code: dwd = DiscreteWaveletTransform[{0, 0, 1, 1, 1, 2, 3, 4}];

Wolfram Language code: dwd["BasisIndex"]

The basis includes the detail coefficients {…,1} and the last coarse coefficient {…,0}:

Wolfram Language code: dwd["TreeView"]

The result of WaveletBestBasis[dwd] has exactly the same wavelet coefficients as dwd:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[{0, 0, 1, 1, 1, 2, 3, 4}];

Wolfram Language code: Normal[WaveletBestBasis[dwd]] === Normal[dwd]

Only the wavelet basis is different:

Wolfram Language code: WaveletBestBasis[dwd]["BasisIndex"] === dwd["BasisIndex"]

The {} coefficient of "BestBasisCostValues" is the cost value of the original data:

Wolfram Language code: dwd = WaveletBestBasis[DiscreteWaveletPacketTransform[{1, 2, 1, 1.1}], "LogEnergy"];

Wolfram Language code: {} /. dwd["BestBasisCostValues"]

Directly compute log-energy from the data:

Wolfram Language code: Total[Log[{1, 2, 1, 1.1} ^ 2]]

The log-energy of the best basis is lower than that of the data:

Wolfram Language code: Total[dwd["BasisIndex"] /. dwd["BestBasisCostValues"]]

Possible Issues (5)

DiscreteWaveletTransform does not compute the full tree of wavelet coefficients:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletTransform[{0, 0, 1, 1}]]

Wolfram Language code: DiscreteWaveletTransform[{0, 0, 1, 1}]["TreeView"]

Use DiscreteWaveletPacketTransform to get the full tree:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, 1}]]

Wolfram Language code: DiscreteWaveletPacketTransform[{0, 0, 1, 1}]["TreeView"]

The cost function must be additive with respect to Join:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, 1}], -Norm[#, 3]&]

The specified function is not additive:

Wolfram Language code: Norm[{1}, 3] + Norm[{2}, 3] == Norm[{1, 2}, 3]

Modify the cost function to be additive:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, 1}], -Norm[#, 3] ^ 3&]

The cost function must be zero for zero-valued coefficients:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, 1}], Total[Exp[Abs[#]]]&]

Modify the cost function to be compatible:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, 1}], Total[Exp[Abs[#]] - 1]&]

The best basis algorithm requires numeric coefficients:

Wolfram Language code: WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, n}]]

Use specific numerical values:

Wolfram Language code: Table[WaveletBestBasis[DiscreteWaveletPacketTransform[{0, 0, 1, n}]], {n, {0.5, 1, 1.5, 2}}]

An explicit basis specification wind needs to be consistent:

Wolfram Language code: dwd = DiscreteWaveletPacketTransform[RandomReal[1, 4]];

Wolfram Language code: WaveletBestBasis[dwd, {{1}, {1, 0}}]

A basis cannot include both {1} and {1,0} since {1,0} can be computed from {1}:

Wolfram Language code: dwd["TreeView"]

Select a basis using a consistent wind specification:

Wolfram Language code: {WaveletBestBasis[dwd, {{1}}]["TreeView"], WaveletBestBasis[dwd, {{1, 0}}]["TreeView"]}

Top

More Learning

Tech Support

Wolfram Solutions

Wolfram Solutions For Education

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

WaveletBestBasis

Details and Options

Examples

Basic Examples (1)

Scope (11)

Basic Uses (6)

Cost Functions (5)

Generalizations & Extensions (2)

Applications (3)

Compression (3)

Properties & Relations (4)

Possible Issues (5)

Text

CMS

APA

BibTeX

BibLaTeX

WaveletBestBasis

Details and Options

Examples

Basic Examples (1)

Scope (11)

Basic Uses (6)

Cost Functions (5)

Generalizations & Extensions (2)

Applications (3)

Compression (3)

Properties & Relations (4)

Possible Issues (5)

See Also

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX