Narzędzia sztucznej inteligencji - laboratorium |
Gabriel Kachel Adam Czech |
rok III INF I st., gr. 6 środa, godz. 14.40 |
Ćwiczenie 2: |
||
Ćwiczenie wykonano w dniach: 09.04, 16.04, 23.04, 07.05 oraz 14.05.2014 |
Sprawozdanie oddano dnia: 28.04.2014 |
ocena: |
1. Cel i zakres ćwiczenia
Celem ćwiczenia jest wykorzystanie warstwy neuronów z tzw. współzawodnictwem uczonych metodą Kohonena ( która jest metodą uczenia nienadzorowanego ) w zadaniu kompresji obrazu.
Ćwiczenie polega na przeprowadzeniu stratnej kompresji obrazu „barbara.tif” przy pomocy sieci neuronowej oraz porównanie obrazu przed kompresją i po kompresji.
2. Wstęp teoretyczny
Sieć Kohonena jest siecią neuronową uczoną w trybie bez nauczyciela w celu wytworzenia niskowymiarowej, zdyskretyzowanej reprezentacji przestrzeni wejściowej, sieć ta uczy się według zasady „zwycięzca bierze wszystko” - modyfikacja wag jest przeprowadzana jedynie dla neuronów zwycięskich. „Przegrani” nie podlegają żadnym zmianą, czasami symuluje się w nich proces „oduczania”, bądź „zapominania”.
Rys. 1 Sieć realizująca uczenie się przez konkurencję
Gdzie:
yj = w jx = Σ wijxi
wj - wektor wag j-tego neuronu
Wygrany:
win = max arg yj
Na początku sieć generuje losowo wartości wag. W zwycięskim neuronie wartość jego wektora wag zwiększa się w kierunku wektora wejść.
Wady sieci Kohonena to przede wszystkim: problem tzw. jednostek martwych neuronów jest więcej niż skupień, brak możliwości tworzenia hierarchii kategorii oraz mniejsza odporność na uszkodzenia.
3. Przebieg ćwiczenia
Obrazem wykorzystanym w ćwiczeniu jest „barbara.tif”
Rys. 2 Obraz „barbara.tif” wykorzystany w ćwiczeniu
Pierwszym krokiem jest podanie komend czyszczących ekran i zamykających otwarte okna matlaba
close all
clear all
Następnie wyświetlamy informacje o obrazie poleceniem:
imfinfo('barbara.tif')
czego wynikiem jest:
ans =
Filename: 'D:\Czech, Kachel\Ćwiczenie2\barbara.tif'
FileModDate: '23-kwi-2014 14:46:56'
FileSize: 264168
Format: 'tif'
FormatVersion: []
Width: 512
Height: 512
BitDepth: 8
ColorType: 'indexed'
FormatSignature: [73 73 42 0]
ByteOrder: 'little-endian'
NewSubFileType: 0
BitsPerSample: 8
Compression: 'Uncompressed'
PhotometricInterpretation: 'RGB Palette'
StripOffsets: [32x1 double]
SamplesPerPixel: 1
RowsPerStrip: 16
StripByteCounts: [32x1 double]
XResolution: 72
YResolution: 72
ResolutionUnit: 'Inch'
Colormap: [256x3 double]
PlanarConfiguration: 'Chunky'
TileWidth: []
TileLength: []
TileOffsets: []
TileByteCounts: []
Orientation: 1
FillOrder: 1
GrayResponseUnit: 0.0100
MaxSampleValue: 255
MinSampleValue: 0
Thresholding: 1
Offset: 262152
Software: 'IrfanView'
Za pomocą funkcji:
obraz=imread('barbara.tif')
figure(1)
colormap gray
imagesc(obraz,[0 255])
Obraz zostaje wczytany do zmiennej „obraz” oraz zostaje wyświetlony na ekranie komputera w skali szarości.
Definiujemy rozmiar ramki w pikselach - 4x4
nx=4;
ny=4;
Korzystają z funkcji size przepisujemy zmiennym X, Y wartości prezentujące szerokość i wysokość obrazy w pikselach:
[X, Y]= size(obraz)
Wartości zmiennych Nx, Ny czyli liczbę ramek otrzymujemy poprzez dzielenie szerokości i wysokości obrazy przez rozmiar ramki w pikselach:
Szerokość: Nx = X/nx
Wysokość: Ny = Y/nx
Wykorzystujemy funkcję mat2cell tworzymy tablice blokową A złożoną z macierzy Nx x Ny:
A=mat2cell(obraz,repmat(ny,1,Ny),repmat(nx,1,Nx));
Wyświetlamy zawartość ramki lewego górnego rogu poleceniem:
disp(A{1,1})
Czego wynikiem jest:
168 163 159 154
134 127 126 115
90 84 79 71
68 69 69 72
Na podstawie danych w tabeli A tworzymy macierz wzorców wejściowych. Najpierw utworzymy macierz zerowych elementów P, której liczba wierszy odpowiadać będzie ilości elementów w ramce, natomiast liczba wierszy reprezentować będzie ilość elementów macierzy A, a następnie przepiszemy do niej odpowiednie elementy z macierzy A.
P=zeros(nx*ny,Nx*Ny);
l=0;
for i=1:Ny
for j=1:Nx
ram=A{i,j};
ram1=reshape(ram,(nx*ny),1)
l=l+1;
P(:,l)=ram1;
end
end
Tworzenie sieci Kohonena wymaga w pierwszej kolejności określenie liczby neuronów w warstwie, następnie tworzymy zmienną eta określającą współczynnik szybkości liczenia sieci:
N=8;
eta=0.1;
Definiujemy funkcje newc i przypisujemy jej wartości.
net=newc(P,N,eta,0.001)
Wyświetlimy rozmiary i początkowe wartości elementów macierzy współczynników wagowych:
disp('Rozmiar macierzy wag: ')
disp(net.IW)
disp('Zawartość macierzy wag: ')
disp(net.IW{1})
Czego wynikiem jest:
ozmiar macierzy wag:
[8x16 double]
Zawartość macierzy wag:
Columns 1 through 7
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
128.5000 125.0000 126.5000 128.0000 128.0000 127.5000 129.5000
Columns 8 through 14
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
128.0000 125.0000 124.5000 128.0000 124.5000 128.5000 127.5000
Columns 15 through 16
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
127.5000 129.5000
Tworzymy zmienną nf określająca ilość ramek obrazu będzie prezentowanych sieci w trakcie uczenia:
nf=Nx*Ny/4;
Tworzymy wektor Fi zawierający nf losowych numerów ramek obrazu:
r=randperm(Nx*Ny);
Fi=r(1:nf);
Tworzymy macierz Pu zawierającą losowe kolumny macierzy P:
Pu=P(:,Fi);
Aby rozpocząć proces uczenia sieci, wystarczy ustawić ilość cykli treningowych i użyć funkcji train:
net.trainParam.epochs=1;
net=train(net,Pu);
Wyświetlamy wartości współczynników wagowych:
disp('Rozmiar macierzy wag1: ')
disp(net.IW)
disp('Zawartość macierzy wag1: ')
disp(net.IW{1})
Wynik:
Rozmiar macierzy wag1:
[8x16 double]
Zawartość macierzy wag1:
Columns 1 through 7
185.7621 184.2141 180.4504 174.4978 179.5489 180.0562 180.8543
50.9078 48.0184 46.8978 47.1454 45.1055 45.8675 45.3690
73.1044 69.2411 70.3907 73.4713 70.8402 71.6855 73.3336
116.6765 120.9009 123.4051 122.5929 112.9671 107.0226 103.6561
139.4633 136.5460 137.5797 140.9592 144.1601 142.8216 141.2879
157.3629 162.8141 163.0176 157.5268 157.1538 158.0164 157.9577
108.7763 97.6205 91.8587 99.2585 100.5084 99.2157 108.4516
91.6808 91.5286 90.1003 89.6840 100.4036 98.9024 95.1946
Columns 8 through 14
177.0498 179.9061 180.1106 177.9748 175.1320 184.1376 183.7125
43.7827 45.1042 42.9920 43.1462 42.7992 43.3188 43.4427
72.7445 77.5389 75.1621 75.0359 74.6297 79.9853 79.4084
107.4856 112.6006 107.4211 101.2619 101.3913 116.9665 116.1716
140.7649 145.6724 149.9745 150.8371 147.6811 142.8339 144.4812
154.8233 160.8208 156.8883 150.5935 146.5117 161.3696 162.9516
121.2314 104.1254 124.7941 139.6840 142.0144 127.0145 133.8550
93.4516 93.1099 91.4274 92.7083 93.2995 88.0281 90.0749
Columns 15 through 16
180.4084 173.6151
43.9560 43.3930
80.8553 81.9852
111.3250 105.8824
145.9001 147.4430
158.0059 150.0582
136.6007 135.0898
96.7133 98.6006
Przypisujemy macierz współczynników wagowych do zmiennej W.
W=net.IW{1};
Przeprowadzamy symulację sieci neuronowej:
a=sim(net, P)
Poleceniem vec2ind konwertujemy otrzymaną macierz do postaci wektora i zapisujemy ją w postaci tzw. książki kodów.
ac= vec2ind(a);
Wynik przeprowadzonej symulacji:
Rys. 3 Obraz trenowania neuronów
Następnym krokiem jest konwersja elementów zmiennej W oraz ac do typu całkowitego bez znaku
W=uint8(W);
ac=uint8(ac);
Poleceniem save zapisujemy do pliku obraz.mat wszystkie potrzebne informacje o obrazie poddanemu kompresji.
save obraz.mat W ac Nx Ny nx ny
Obliczamy wartość współczynnika kompresji
Kr=(Nx*Ny*nx*ny*p)/((Nx*Ny*k)+(N*nx*ny*m));
Dekompresja obrazu
Pierwszym krokiem jest podanie komend czyszczących ekran i zamykających otwarte okna matlaba
close all
clear all
Następnie wczytujemy wszystkie zapisane wcześniej zmienne potrzebne do operacji dekompresji oraz konwertujemy wczytane zmienne W i ac do typu double:
load obraz.mat
W=double(W);
ac=double(ac);
Tworzymy pustą tablicę o rozmiarach Nx na Ny
Ad=cell(Nx,Ny);
Kolejnym etapem jest wypełnienie tablicy poprzez wpisanie odpowiednich ramek w odpowiednie miejsca. Robimy to w podwójnej pętli for tak aby wypełnić każdą ramkę współczynnikami wagowymi z książki kodowej. Do obliczenia ilości kroków pętli utworzyliśmy zmienną l=0
l=0;
for i=1:Nx
for j=1:Ny
l=l+1;
nr_neuronu=ac(l);
wagi=W(nr_neuronu,:);
ramka=reshape(wagi,nx,ny);
Ad{i,j}=ramka;
end
end
Skonwertowany obraz chcąc porównać z oryginałem musimy skonwertować tablicę blokową na zwykłą macierz oraz wczytać oryginał obrazu.
obraz_d=cell2mat(Ad);
obraz=imread('barbara.tif')
Następnie tworzymy okno I wyświetlamy obrazy oba w odcieniach szarości
figure(1)
colormap gray
subplot(1,2,1);
imagesc(obraz,[0,255]);
subplot(1,2,2);
imagesc(obraz_d,[0,255]);
Wynikiem jest okno z dwoma obrazami
Rys. 4 Obraz przed i po kompresji
Wykorzystując funkcję sumsqr która zwraca sumę kwadratów wszystkich macierzy obliczamy wartość średniokwadratowego błędu kompresji MSE:
obraz=double(obraz);
MSE=sumsqr(obraz-obraz_d)/(size(obraz,1)*size(obraz,2))
Wynik MSE= 354.8001
Na koniec obliczamy wartość PSNR
PSNR=10*log10((2^8-1)^2/MSE)
Wynik PSNR= 22.6310
4. Uwagi i wnioski
Ćwiczenie miało pokazać kompresję obrazu. Jak widać na rysunku 4 obraz po kompresji jest zniekształcony i widoczne są piksele oraz znaczne zmiany. Im większe wartości współczynnika MSE tym obraz jest bardziej niewyraźny. Współczynnik PSNR czyli podobieństwa obrazów wyniósł około 22.6. Długość nauki sieci zależała głównie od rozmiaru ramek a w mniejszym stopniu od jakości obrazu.
Ćwiczenie polegające na zastosowaniu sieci Kohonena udało się wykonać w pełni. Sieć dokonała kompresji i dekompresji obrazu czyli wykonała cel ćwiczenia.
5. Wykaz literatury
Bartecki K.: Sztuczne sieci neuronowe w zastosowaniach. Zbiór ćwiczeń laboratoryjnych z wykorzystaniem przybornika Neural Network Toolbox programu Matlab. Skrypt Politechniki Opolskiej nr 289, Opole 2010.
Wykład nr 9 udostępnione przez prowadzącego.
Wikipedia.pl
10
Wyszukiwarka