MATLAB heeft de functie svd aan boord om numeriek de singulierewaardenontbinding te bepalen. Met svds kun je de grootste 6 singuliere waarden berekenen (of andere gespecificeerde singuliere waarden). Eerst rekenen we het voorbeeld uit de lestekst na:

>> A = [2 0; 0 -3]
A =
     2     0
     0    -3
>> [U,S,V] = svd(A)  % matrices uit singulierewaardenontbinding
U =
     0     1
     1     0
S =
     3     0
     0     2
V =
     0     1
    -1     0
>> U*S*V' - A   % check
ans =
     0     0
     0     0
>> svds(A)      % grootste singuliere waarden
ans =
     3
     2

Het volgende voorbeeld van een singuliere matrix illustreert het verschil tussen exact en numeriek rekenen. \[\begin{aligned}\matrix{1 & -1\\ -1 & 1} &= \matrix{-\frac{1}{2}\sqrt{2} & \frac{1}{2}\sqrt{2} \\ \frac{1}{2}\sqrt{2} & \frac{1}{2}\sqrt{2}}\matrix{2 & 0\\ 0 & 0}\matrix{-\frac{1}{2}\sqrt{2} & \frac{1}{2}\sqrt{2} \\ -\frac{1}{2}\sqrt{2} & -\frac{1}{2}\sqrt{2}}\\ \\ &=\frac{1}{2}\sqrt{2} \matrix{-1 & 1\\ 1 & 1}\matrix{2 & 0\\ 0 & 0}\matrix{-1 & 1\\ -1 & -1}\frac{1}{2}\sqrt{2} \end{aligned} \]

>> B = [1 -1; -1 1]
B =
     1    -1
    -1     1
>> [U,S,V] = svd(B)    % singulierewaardendecompositie 
U =
   -0.7071    0.7071
    0.7071    0.7071
S =
    2.0000         0
         0    0.0000
V =
   -0.7071   -0.7071
    0.7071   -0.7071
>> U*S*V' - B          % check
ans =
   1.0e-15 *
   -0.3331    0.4441
         0   -0.2220
>> round(ans)          % afronden
ans =
     0     0
     0     0
>> svds(B)             % grootste singuliere waarden
ans =
2.0000
0.0000

Nu een voorbeeld van beeldcompressie aan de hand van een patroon bestaande uit witte en zwarte hokjes op een \(9\times 9\) rooster. We specificeren de figuur met een matrix bestaande uit nullen (voor witte hokjes) en enen (voor zwarte hokjes): \[M = \matrix{ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 0\\ 0 & 1 & 0 & 1 & 1 &1 & 0 & 1 & 0 \\ 1 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 1\\ 0 & 1 & 0 & 1 & 1 &1 & 0 & 1 & 0 \\ 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 0\\ 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 \\ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0}\] In MATLAB kunnen we dit patroon visualiseren.

>> M = [
0 0 0 0 1 0 0 0 0;
0 0 0 1 0 1 0 0 0;
0 0 1 0 0 0 1 0 0;
0 1 0 1 1 1 0 1 0;
1 0 0 1 0 1 0 0 1;
0 1 0 1 1 1 0 1 0;
0 0 1 0 0 0 1 0 0;
0 0 0 1 0 1 0 0 0;
0 0 0 0 1 0 0 0 0];            % patroon
>> colormap([1 1 1; 0 0 0]);   % specificeer 2 kleuren: wit en zwart
>> image(M .* 255);            % patroon als zwart-wit figuur

Stel nu dat we iemand dit patroon willen sturen. Dan kunnen we de matrix \(M\) sturen, oftewel 81 getallen nul en één. Maar met de singulierewaardenontbinding kun je minder getallen sturen, terwijl het plaatje toch gereconstrueerd kan worden.

De eigenwaarden van de matrix \(M\) zijn in stijgende volgorde als volgt:

>> sort(eig(M))
ans =
   -2.0000
   -0.9032
   -0.0000
   -0.0000
   -0.0000
    0.0000
    1.1939
    2.0000
    3.7093

Dus zijn de singuliere waarden van \(M\) in dalende volgorde, afgerond op 1 decimaal, gelijk aan \(3.7\), \(2.0\), \(1.2\), \(0.9\) en \(0\).

>> svds(M)
ans =
    3.7093
    2.0000
    2.0000
    1.1939
    0.9032
    0.0000

We benaderen \(M\) nu met de eerste termen van de singulierewaardenontbinding. Maar in plaats van de numerieke waarden van de ontbinding te gebruiken voor beeldweergave ronden we matrixelementen af op gehele getallen \(0\) en \(1\) om het patroon te reconstrueren.

Stel dat we alleen de hoogste singuliere waarde \(3.7\) gebruiken. Dan lijkt het plaatje al wat op de oorspronkelijke figuur:

>> [U,S,V] = svd(M);
>> M1 = round(U(:,1)*S(1,1)*V(:,1)'); 
>> image(M1 .* 255)

Hiervoor hoeven we dus maar \(1+2\times 9 = 19\) numerieke waarden op te sturen, namelijk de singuliere waarde en de twee vectoren \(\vec{u}_1\) en \(\vec{v}_1\) .

Als we ook de singuliere waarde \(2\) gebruiken, dan krijgen we de oorspronkelijke figuur terug.

>> M3 = round(U(:,1:3)*S(1:3,1:3)*V(:,1:3)');
>> image(M3 .* 255)

Nu volstaat het opsturen van \(3+6\times 9 = 57\) numerieke waarden, namelijk \(3\) eigenwaarden en \(2\times 3= 6\) vectoren. Dit lijkt niet zo veel minder dan \(81\), het gaat toch al om een reductie van ongeveer \(30\%\)

\(\phantom{xx}\)

De winst is spectaculairder bij het sturen van grotere digitale beelden, bijvoorbeeld op de in computer vision veel gebruikte foto van \(512\times 512\) pixels.

We lezen de foto in, berekenen de singulierewaardenontbinding van de bijpassende (\(512\times 512\))-matrix met grijswaarden, en benaderen de originele foto met 8, 16, 32, 64, en 128 termen uit de ontbinding.

>> im = imread('E:/ANS/Lena512.bmp');
>> img = im2double(im);
>> size(img)
ans =
   512   512
>> imshow(img)
>> [U,S,V] = svd(img);
>> img8= U(:,1:8)*S(1:8,1:8)*V(:,1:8)';
>> imshow(img8)
>> img16= U(:,1:16)*S(1:16,1:16)*V(:,1:16)';
>> imshow(img16)
>> img32= U(:,1:32)*S(1:32,1:32)*V(:,1:32)';
>> imshow(img32)
>> img64= U(:,1:64)*S(1:64,1:64)*V(:,1:64)';
>> imshow(img64)
>> img128= U(:,1:128)*S(1:128,1:128)*V(:,1:128)';
>> imshow(img128)

Hieronder zie je de beelden voor verschillende waarden van het aantal termen \(k\) die uit de singulierewaardenontbinding gehaald worden. Duidelijk is dat je minder informatie nodig hebt om toch een foto te hebben die op het zicht weinig afwijkt van het origineel (bij \(k=64\) is de compressiefactor ongeveer \(\frac{1}{4}\)). Bij kleurenfoto's is de winst zelfs groter.

\(k=8\)	\(k=16\)
\(k=32\)	\(k=64\)
\(k=128\)	origineel: \(k=512\)