Vývojová Dokumentácia Program Som Vyvýjal V Prostredí Delphi

vývojová dokumentácia ===================== program som vyvýjal v prostredí delphi 7. neurónová sieť bola navrhnutá, vytvorená a vytrénov

Vývojová dokumentácia
=====================
Program som vyvýjal v prostredí Delphi 7. Neurónová sieť bola
navrhnutá, vytvorená a vytrénovaná v programe SNNS. Následne som
vytvoril jednoduchú neurónovú sieť v delphi, v ktorej som použil váhy
z už vyučenej siete. V samotnom programe bolo potrebné vyriešiť
niekoľko problémov.
1.
vyhľadanie výrazných bodov v obrázku
2.
zredukovať počet možných kombinácií vstupov pre neurónovú sieť
3.
z vybraných bodov vyrobiť vstup pre neurónovú sieť
4.
implementovať už vytrénovanú sieť
Základná trieda v programe je trieda Tobrazok, ktorá obsahuje všetky
metódy a premenné potrebné na spracovanie vstupov. Podrobnejšie
popíšem procedúry, ktoré sú algoritmicky zložitejšie, ostatné robia
len manuálnu prácu a nie je potrebné ich komentovať. Ukážka kódu :
Tobrazok=class
bmpcko:Tbitmap; //obsahuje načítanú bitmapu obrázku
cesta:string; //určuje cestu k obrázku
body:boody; //výrazné body v obrázku
zle:tuko; //zlé možnosti, generované pre učenie siete
mapa:array[0..31, 0..23] of map; //mapa bodov v 2D poli, kôli
jednoduchšiemu prechádzaní v cykloch
vybrane_body:pole; //pole bodov, ktoré sú vybrané buď manuálne, apre
potreby učenia, alebo detekované neurónovou sieťou pri detekcii
pocet_vybranych:byte; //počet vybraných bodov
pocet_bodov:byte; //počet všetkých výrazných bodov
je_tam:boolean; // po detekcii sa tam uloží pravdivostná hodnota podľa
toho, ako dopadla detekcia
procedure najdi_body; //nájde výrazné body v obrázku
procedure nacitaj(fil:string); //načíta obrázok zo súboru
procedure nakresli(platno:Tcanvas); //nakreslí obrázok na určený
canvas
procedure nakresli_bod(farba:Tcolor; bod:Tpoint; platno:Tcanvas;
cislo:byte); //nakreslí konkrétny bod, farebne sa rozlišuje, či to je
bod výrazný, detekovaný, alebo zlá možnosť
function pridaj_bod(x,y:integer;platno:Tcanvas):byte; //pridanie bodu
pri určovaní dobrých možností pre potreby učenia siete
procedure vycisti(platno:Tcanvas); // vykreslí len výrazné body
end;
Vyhľadanie výrazných bodov
Na vyhľadávanie som zvolil jednoduchý algoritmus, ktorý rozdelí
obrázok na menšie celky 10 x 10 pixelov. V týchto celkoch sa určí
priemerná tmavosť všetkých bodov a ak je táto väčšia ako určená
hranica, je považovaný stred tejto oblasti ako výrazný bod. Takýmto
postupom však program nájde veľké množstvo bodov, ktoré sú prebytočné.
Z toho dôvody je aplikované sito na body, ktoré v oblastiach
prehustených bodmi vyberá iba niektoré z nich. Vyhľadávanie bodov
zabezpečuje procedúra objektu Tobrazok najdi_body.
procedure Tobrazok.najdi_body;
var
a,b,c,d:byte; //pomocne premenne potrebne pre cykly
e:integer; //do tejto premennej sa vypocita intenzita tmavosti regionu
farba:Tcolor; //pouziva sa na ulozenie farby spracovavaneho pixelu
begin
for a:=0 to sirka do // prechadza v cykle cely obrazok po 10
pixelovych regionoch
for b:=0 to vyska do
begin
mapa[a,b]:=false; //vynulovanie mapy
e:=0; // vynulovanie
for c:=1 to 10 do //prechadzanie konkretneho regionu
for d:=1 to 10 do
begin
farba:=bmpcko.Canvas.Pixels[(a*10)+c, (b*10)+d]; //zistenie farby
aktualneho pixelu
e:=e+GetRValue(farba); //ziskanie tmavosti pixelu podla jednej z
farbnych zloziek, nakolko su vstupy cierno-biele, nezalezi na tom,
ktora farba to bude
end; / koniec cyklu prechadzajuceho regionom
e:=round(e/100); // zistenie priemernej tmavosti regionu
if e hranica, budeme ho povazovat za vyrazny bod
end; // koniec cyklu prechadzajuceho celou mapou
//redukcia vyraznych bodov
for a:=0 to sirka do
for b:=0 to vyska do
begin
if (a if (a<(sirka-2)) and mapa[a,b] and mapa[a+2,b] and mapa[a+3,b] then
mapa[a+2,b]:=false;
if (b if (b<(vyska-2)) and mapa[a,b] and mapa[a,b+2] and mapa[a,b+3] then
mapa[a,b+3]:=false;
if (a mapa[a+1,b+1]:=false;
if (a0)and mapa[a,b] and mapa[a+1,b-1] then
mapa[a+1,b-1]:=false;
end;
//tento kusok kodu prechadza celou mapou a redukuje vyrazne body,
ktore su zbytocne nahusto. Prejde mapu vo vodorovnom a zvislom smere a
z kazdych za sebou nasledujucich vyraznych bodov v jednom smere
vyberie iba jeden
end; //koniec procedury najdi_body
Redukovanie vybraných kombinácií
Neurónová sieť by pre správnu detekciu mala overiť všetky kombinácie
všetkých jedenástic bodov z obrázku. To je ale pri 50 vybraných bodoch
približne 3*1016, čo je príliš veľa možností na to, aby bolo overenie
schopné v reálnom čase. Z toho dôvody bolo potrebné vytvoriť
algoritmus, ktorý vyberá iba také možnosti, pri ktorých je
pravdepodobné že sa v nich postava nachádza. Ak sa takáto možnosť
nenájde žiadna, je nepravdepodobné, že sa v obrázku nachádza postava.
Vyhľadávanie vhodných kombinácií funguje takto. Ako prvý je hľadaný
bod, ktorý reprezentuje hlavu. Tento bod sa hľadá iba v hornej tretine
obrázku, nakoľko tam je najpravdepodobnejší výskyt hlavy. Od tohto
bodu sa potom odvíja hľadanie ďalších bodov, ktoré sú vyberané podľa
možnej vzdialenosti od hlavy. A teda krk môže byť maximálne dva body
nadol od hlavy a dva body napravo i naľavo. Takýmto vymedzením vznikne
sektor, v ktorom sa bod reprezentujúci krk nachádza. Ak sa v tomto
sektore bod nenachádza nepokračuje sa ďalej v hľadaní, ale zvolí sa
iný bod, ktorý by mohol predstavovať hlavu. Ak sa tam bod nachádza,
pokračuje sa ďalej v hľadaní lakťov, od ktorých sa odvíja hľadanie
dlaní. Takýmto spôsobom pokračuje algoritmus, až kým nenájde všetky
body, ktoré môžu predstavovať človeka. Vzdialenosti jednotlivých
bodov, a teda veľkosti sektorov a ich poloha k predošlému bodu som
určil experimentálne na testovacích dátach. Tento algoritmus zredukuje
počet možností a pri jeho testovaní vyberal od 500 do 900 tisíc
možností. to je dosť málo na to, aby bol počítač schopný overenia v
priebehu niekoľkých sekúnd. V programe je tento algoritmus
implementovaný pomocou jednotlivých procedúr, ktoré sa volajú postupne
a v cykloch preverujú sektory zodpovedajúce jednotlivým častiam tela.
Procedúry pracujú s globálnymi premennými. Ukážka zdrojového kódu :
procedure hlava;
var k,j:byte;
begin
for k:=1 to 30 do //prechádzanie celej šírky mapy obrázku
for j:=0 to 5 do //prejdenie hornej štvrtiny mapy
if mapa[k,j].je then
begin
moznost[0]:=mapa[k,j].index; //zapísanie indexu bodu, ktorý bol
vybraný do globálneho poľa
hlava_bod.x:=k; //zapísanie polohy vybraného body do globálnej
premennej
hlava_bod.Y:=j;
krk; // volanie procedúry krk
if mam then break;
end;
end;
procedure krk;
var k,j:byte;
xmin,xmax,ymin,ymax:byte;
begin
if hlava_bod.X-2<0 then xmin:=0 //overenie, či sektor odvýjajúci svoju
polohu od polohy hlavy nepresahuje rozsah mapy obrázku
else
xmin:=hlava_bod.X-2; //vymedzenie sektory pre krk v x-ovej osi
if hlava_bod.X+2>31 then xmax:=31 else xmax:=hlava_bod.X+2;
ymin:=hlava_bod.y+1; //vymedzenie sektory pre krk v y-ovej osi
ymax:=hlava_bod.y+3; // o presiahnutí cez okraj mapy zatiaľ nie je
potrebné uvažovať, kôli tomu, hlava bola vybraná len z hornej štvrtiny
obrázku
for k:=xmin to xmax do
for j:=ymin to ymax do
if mapa[k,j].je then
begin
moznost[1]:=mapa[k,j].index;
krk_bod.x:=k;
krk_bod.y:=j;
stred;
if mam then break;
end;
end; //krk
procedúra krk volá následne procedúru stred, ktorá po nájdení stredu
tela nájde ľavý lakeť, od neho sa odvíja hľadanie ľavej dlane atď.
Tento algoritmus názorne demonštruje animácia. Najprv sa farebne
zvýrazní sektor, v ktorom sa vyhľadáva bod a zároveň aj jeden z bodov,
ktorý bol v momentálnej časti cyklu vybraný. Ďalej sa vysvieti ďalší
sektor s bodom atď.
Vyrobiť vstup pre neurónovú sieť
Pre neurónovú sieť som zvolil 32 vstupov, ktoré sú vypočítané z
pozícií vybraných bodov a ich posunutým dvojiciam v druhom obrázku.
Prvých 10 vstupných hodnôt tvoria vzdialenosti medzi jednotlivými
bodmi v prvom z dvojice obrázkov. Ďalších 11 vstupov predstavujú
veľkosti vektorov. Každý vektor určuje posun konkrétneho bodu v druhom
obrázku vzhľadom na prvý obrázok. Posledných 11 vstupov predstavuje
smer týchto vektorov. Na výpočet som použil jednoduché vzorce
analytickej geometrie.
Neurónová sieť
Neurónovú sieť som vyučil v programe SNNS a váhy jednotlivých neurónov
som importoval do siete, ktorú som implementoval v mojom programe.
Vytvoril som triedu Tneuronka, ktorá pozostáva z niekoľkých polí,
obsahujúcich objekty typu Tneuron. Tieto polia predstavujú jednotlivé
vrstvy neurónovej siete. Ďalej obsahuje procedúru spocitaj, ktorá
prepočíta dané vstupy a prejde jednotlivými vrstvami. Okomentovaný
zdrojový kód povie viac. :
type
Tvstup =array[1..32] of real; //vstup pre neurónovú sieť
Tvahy = array[1..40] of real; //váhy jednotlivých neurónov
Tneuron=class
private
vstup:real;
vystup:real;
public
function vrat_vystup:real;
procedure vloz(vst:real);
end;
Tneuronka=class
protected
vstupna:array[1..32] of Tneuron; // vstupná vrstva
prva:array[1..40] of Tneuron; //prvá skrytá vrstva
druha:array[1..40] of Tneuron; //druhá skrytá vrstva
vystupny:Tneuron; //výstupný neurón
wahy1:array[1..32] of Tvahy; //váhy medzi vstupnou a prvou skrytou
vrstvou
wahy2:array[1..40] of Tvahy; //váhy medzi prvou a druhou skrytou
vrstvou
wahy3:Tvahy; // váhy medzi druhou skrytou vrstvou a výstupným neurónom
public
constructor Create(Subor: string);
procedure spocitaj(vs:Tvstup);
function vrat_vystup:real;
end;
implementation
function Tneuron.vrat_vystup:real;
begin
result:=vstup;
end;
procedure Tneuron.vloz(vst:real);
begin
vstup:=vst;
end;
constructor TNeuronka.Create(Subor: string);
var i,j:integer;
f,g:textfile;
begin
assignfile(f,subor); // konštruktor načíta váhy zo súboru, ktorý mu
bol poslaný ako parameter, súbor bol vytvorený v programe SNNS a
následne upravený pre lepšie spracovanie
reset(f);
for i:=1 to 32 do
begin
readln(f);
for j:=1 to 40 do
read(f,wahy1[i,j]);
readln(f);
readln(f);
end;
for i:=1 to 40 do
begin
readln(f);
for j:=1 to 40 do
read(f,wahy2[i,j]);
readln(f);
readln(f);
end;
for j:=1 to 40 do
begin
readln(f);
readln(f,wahy3[j]);
readln(f);
end;
closefile(f);
for i:=1 to 32 do vstupna[i]:=Tneuron.create; // vytvorenie neurónov
vo vrstvách
for i:=1 to 40 do prva[i]:=Tneuron.create;
for i:=1 to 40 do druha[i]:=Tneuron.create;
vystupny:=Tneuron.Create;
end;
function Tneuronka.vrat_vystup:real;
begin
result:=vystupny.vrat_vystup;
end;
procedure Tneuronka.spocitaj(vs:Tvstup);
var i,j:integer;
vysledok:real;
begin
for i:=1 to 32 do
vstupna[i].vloz(vs[i]); // vloženie vstupov do vstupnej vrstvy
for i:=1 to 40 do //prepočítanie hodnôt zo vstupnej do prvej skrytej
vrstvy
begin
vysledok:=0;
for j:=1 to 32 do
vysledok:=vysledok+ vstupna[i].vrat_vystup*wahy1[j,i];
prva[i].vloz(vysledok);
end;
for i:=1 to 40 do //prepočítanie hodnôt z prvej skrytej do druhej
skrytej vrstvy
begin
vysledok:=0;
for j:=1 to 40 do
vysledok:=vysledok+ prva[i].vrat_vystup*wahy2[j,i];
druha[i].vloz(vysledok);
end;
vysledok:=0;
for i:=1 to 40 do //prepočítanie hodnôt z druhej skrytej vrstvy do
výstupného neurónu
vysledok:=vysledok+ druha[i].vrat_vystup*wahy3[i];
vystupny.vloz(vysledok);
end;
end.