function ans = recon(filename);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Hauptprogramm zur Ziffernerkennung
%
% Input 'filename'
% Output
clc; clf; close all;
%*** start "definition der Konstanten"
%*** ende "definition der Konstanten"
disp(['Verarbeite Datei ',filename,' ...']);drawnow;
BILD_ORIG=imread(filename); % Bild einlesen
BILD = not(BILD_ORIG); % Bild Invertieren
BILD = ferretbox(BILD); %
subplot(121),imshow(not(BILD));
[p,dummy] = fft_bild(BILD);
p = p(1,:);
p = p';
%*** start "Haupkomponentenanalyse"
load('transMat','transMat');
load('meanp','meanp');
load('stdp','stdp');
[pn] = trastd(p,meanp,stdp); % normierung der Daten
[p] = trapca(pn,transMat) ;
%*** ende "Hauptkomponentenanalyse"
dimension = size(p);
load Network;
y = sim(net,p);
subplot(122);plot(0:9,y,'or'); grid on;
set(gcf,'Name','Semesterarbeit 5. Semester / pg');
k = matrix_to_vektor(y);
k_think = matrix_to_vektor_neu(y);
if k >= 0
if k == 6
disp(['Ziffer als "6/9" klassifiziert']);
disp(['Qualität :',...
num2str(100/2*((y(find(y == max(y))))+1)), ...
' / 100']);
disp(['... Nachbearbeitung ...'])
[dummy,p] = fft_bild(BILD);
p = p(1,:);
p = p';
%*** start "Haupkomponentenanalyse"
load('transMatp','transMat');
load('meanpp','meanp');
load('stdpp','stdp');
[pn] = trastd(p,meanp,stdp); % normierung der Daten
[p] = trapca(pn,transMat) ;
%*** ende "Hauptkomponentenanalyse"
dimension = size(p);
load Networkp;
y = sim(net,p);
k_69 = matrix_to_vektor_neu(y);
if k_69 == 0
disp(['Ziffer : 6']);
result = 6 ;
else
disp(['Ziffer : 9'])
result = 9;
end
else
disp(['Ziffer als "',num2str(k),'" klassifiziert'])
disp(['Qualität :',...
num2str(100/2*((y(find(y == max(y))))+1)),...
' / 100']);
result = k;
end
else
disp(['---']);
disp(['Konnte "',num2str(filename), ...
'" nicht sicher klassifizieren,']);
disp(['grösste Wahrscheinlichkeit für Ziffer ',...
num2str(k_think), ' mit ', ...
num2str(100/2*((y(find(y == max(y))))+1)),...
' / 100']);
result = k_think;
end
subplot(121), title(['erkannte Ziffer : ',num2str(result)]);
function UmrandungsVektor=CTRACING(BILD);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : R. Schnegg, pg *
%* Quelle : Imageprocessing with MATLAB *
%* *
%* Version : 1.02.000 *
%* Datum : 16. Nov. 2000 *
%***********************************************************
%* History : *
%* V1.02.000, 16. Nov. 2000, pg *
%* - Debuginformationen hinzugefügt *
%* - Überschreiten des Bildrandes verhindert, da dies *
%* Abstürze zur Folge haben konnte *
%***********************************************************
% Zweck Erzeugt aus gegebenem BILD einen Konturvektor
%
% Input BILD invertiertes SW-Bild
% Output [X,Y] Matrix mit den Konturvektoren
Version = '1.02.000';
Tabelle = [1 1 1 0 -1 -1 -1 0 1 1;... % x
-1 0 1 1 1 0 -1 -1 -1 0]; % y
mode = 'n'; % 'd' = debug oder 'n' = normal
if mode == 'd'
disp(['*** DEBUG-INFO *** ']);
disp([' -> function ctracing, Version : ',Version]);
disp(['']);
end;
% Überschreiten des Bildrandes verhindern
BILD_size = size(BILD);
y_size = BILD_size(1);
x_size = BILD_size(2) + 2;
BILD = [zeros(y_size,1) BILD zeros(y_size,1)];
BILD = [zeros(1,x_size) ; ...
BILD ; ...
zeros(1,x_size)];
%Startpkt. A bestimmen
Y=0;
X_Summe=0;
Groesse=size(BILD);
if mode == 'd'
disp(['Funktion : ctracing - Grösse des Bildes : ['...
,num2str(Groesse),']']);
pause;
end
% Suchen der Y-Startkoordinate
while and(X_Summe <= 1,Y<=Groesse(1)),
Y=Y+1;
X_Summe=sum(BILD(Y,[1:1:Groesse(2)]));
end;
if mode == 'd'
disp(['Funktion : ctracing - Y-Startkoordinate : ['...
,num2str(Y),']']);
disp(['Funktion : ctracing - Anzahl Pixel (Y_Start):['...
,num2str(X_Summe),']']);
pause;
end
% Suchen der X-Startkoordinate
X_Pos=find(BILD(Y,[1:1:Groesse(2)]));
if sum(sum(X_Pos))>0, % Wenn kein Pixel vorhanden, abbrechen
Error=0;
X=X_Pos(1);
A=[Y,X]; % Startpunkt
if mode == 'd'
disp(['Funktion : ctracing - X-Startkoordinate : ['...
,num2str(X),']']);
pause;
end
true=1; false=0;
C = A; % C = aktueller Punkt
S = 8; %
% Startpunkt in Konturvektor eintragen
contour=[A;];
first= true;
% Contour-Vektor ermitteln
while or(first==true,not(sum(A==C)==2)),
counter=0;
found=false;
while and(found==false,counter < 4),
% Positionen der zu pruefenden Umgebungspunkte bestimmen
y1=C(1)+Tabelle(1,(S-1));
x1=C(2)+Tabelle(2,(S-1));
y2=C(1)+Tabelle(1,S);
x2=C(2)+Tabelle(2,S);
y3=C(1)+Tabelle(1,(S+1));
x3=C(2)+Tabelle(2,(S+1));
laenge=length(contour);
% ** & ~= letzter gefundener Punkt
if (BILD(y1,x1)==1)& not(((contour(laenge-1,1) ...
==y1))& (contour(laenge-1,2)==x1)),
C=C+rot90(Tabelle(1:2,S-1));
S=S-2;
found=true;
elseif (BILD(y2,x2)==1)¬(((contour(laenge-1,1) ...
==y2))& (contour(laenge-1,2)==x2)),
C=C+rot90(Tabelle(1:2,S));
found=true;
elseif (BILD(y3,x3))¬(((contour(laenge-1,1) ...
==y3))& (contour(laenge-1,2)==x3)),
C=C+rot90(Tabelle(1:2,S+1));
found=true;
else S=S+2;
end;
% **
if (S > 9),
S = 2;
elseif (S < 2)
S= 9;
end; % if (S>9)
counter= counter + 1;
end; % end of "while and(...
first = false;
found=false;
contour=[contour ;C];
end; % end of "while or(...
UmrandungsVektor=[contour ];
else error=1;
end; % end of 'kein Pixel vorhanden ?'
function [xsamp,ysamp]=polysamp(x,y,N);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : unbekannt, pg *
%* Quelle : "Mathematik mit MATLAB" / F.Bachmann, *
%* H.-R. Schärer und L.-S. Willimann *
%* *
%* Version : 1.00.001 *
%* Datum : 18.01.2001 *
%***********************************************************
%* History : *
%* V1.00.001, 18.01.2001, pg *
%* Die Schliessung des Polynoms sicherstellen *
%***********************************************************
% Zweck Abtasten eines Polygons an N aequidistanten
% Punkten seines Umfangs
% Input x Vektor, Abszissen der Polygonecken
% y Vektor, Ordinaten der Polygonecken
% N Skalar, Anzahl der Abtastpunkte
% Output xsamp Vektor, Abszissen der N Abtastpunkte
% ysamp Vektor, Ordinaten der N Abtastpunkte
xlen=length(x);
xx = x; yy = y;
% ** "Schliessen" des Polygons **
if x(1) ~= x(xlen)
xx=[x x(1)];
end;
if y(1) ~= y(xlen)
yy=[y y(1)];
end
% **
s=sqrt(diff(xx).^2+diff(yy).^2);
scum=[0 cumsum(s)];
stot=sum(s); % Umfang des Polygons
ds=stot/N; % Schrittweite
ssamp=0:ds:stot-ds;
xsamp = interp1(scum,xx,ssamp); % Koordinaten der N
ysamp = interp1(scum,yy,ssamp); % Abtastpunkte
function out = ferretbox(BILD);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Bildränder ohne Information abschneiden
% (Ferretbox)
%
% Input BILD invertiertes S/W-Bild
% Output invertiertes S/W-Bild ohne Ränder
% Überschreiten des Bildrandes verhindern
BILD_size = size(BILD);
y_size = BILD_size(1);
x_size = BILD_size(2) + 2;
BILD = [zeros(y_size,1) BILD zeros(y_size,1)];
BILD = [zeros(1,x_size) ; ...
BILD ; ...
zeros(1,x_size)];
BILD_size = size(BILD);
% Bestimmen der Ferretbox;
P = double(BILD);
Groesse=size(P);
% Suchen der Y-Startkoordinate
Ystart = 0;
X_Summe = 0;
while and(X_Summe <= 1,Ystart<=Groesse(1)),
Ystart=Ystart+1;
X_Summe=sum(P(Ystart,[1:1:(Groesse(2))]));
end;
% Suchen der Y-Endkoordinate
Yend = Groesse(1);
X_Summe = 0;
while and(X_Summe <= 1,Yend > 0),
Yend=Yend-1;
X_Summe=sum(P(Yend,[1:1:(Groesse(2))]));
end;
Ystart = Ystart;
Yend = Yend;
P = P';
% Suchen der X-Startkoordinate
Xstart = 0;
Y_Summe = 0;
while and(Y_Summe <= 1,Xstart<=Groesse(2)),
Xstart=Xstart+1;
Y_Summe=sum(P(Xstart,[1:1:(Groesse(1))]));
end;
% Suchen der X-Endkoordinate
Xend = Groesse(2);
Y_Summe = 0;
while and(Y_Summe <= 1,Xend > 0),
Xend=Xend-1;
Y_Summe=sum(P(Xend,[1:1:(Groesse(1))]));
end;
Xstart = Xstart;
Xend = Xend;
P = P';
P = P([Ystart:Yend],[Xstart:Xend]);
BILD = mat2gray(P);
out = BILD;
function [A,B] = fft_bild(BILD);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : Patrik Gfeller *
%* Quelle : *
%* *
%* Version : 1.00.000 *
%* Datum : 18.01.2001 *
%* *
%* Aufgerufen von : *
%* recon.m *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Ermittelt das normierte Fourierspektrum des
% Umrisses der Figur
%
% Input BILD invertiertes SW-Bild
% Output [A B] normiertes Spektrum [Amplitude Phase]
contour=ctracing(BILD); % Contour-Vektor erzeugen
l=size(contour);
y=contour(1:l(1),2);
x=contour(1:l(1),1);
c = x+j*y; % umwandeln in komplexe Funktion
c = c*-j; % Bild um 90° drehen
x = real(c);
y = imag(c);
y = y + abs(min(y)); % Bild in den ersten
x = x - abs(min(x)); % Quadranten schieben
xy_max = max([max(x) max(y)]); % Funktion normieren
x = x ./ xy_max(1);
y = y ./ xy_max(1);
c = x+j*y;
N = 32; % Anzahl Punkte des Polynoms
[x y] = polysamp(x',y',N); % Polynompunkte reduzieren
c=fft(x+j*y); % Diskrete Fouriertransformation
A=abs(c(3:length(c))/abs(c(2))); % normieren
B=angle(c(2:length(c))/abs(c(1)));
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Erzeugt und Trainiert ein BP-Netz. Das
% Training verwendet Early-stopping.
%
% Input Trainings und Validationsets
% Output 'Network.mat' trainiertes Netzwerk
% 'transMat.mat' PCA Umrechnungsmatrix
clc;
echo off;
%*** start "definition der Konstanten"
reduktion = 0.01; % Varianzen < x % bei PCA ignorieren
epoch_divider = 1 ; % Teiler für die Anzeige der Resultate
anz_samples_train = 18;
anz_samples_test = 18;
LR = 0.08 ;
learnset_fname = getstring('L-Set ',...
'c:\work\auto\merkmal.mat');
testset_fname = getstring('T-Set ', ...
'c:\work\auto\merkmal.mat');
%*** ende "definition der Konstanten"
load(learnset_fname);p = merkmal_complete;
load(testset_fname) ;ptest = merkmal_complete;
dimension = size(p);
disp([' ']);
disp(['Varianzen < ',num2str(reduktion * 100), ...
' % werden ignoriert ...']);
disp(['Dimension der Daten vor PCA : ', ...
num2str(dimension(1))]);
%*** start "Haupkomponentenanalyse"
[pn,meanp,stdp] = prestd(p); % normierung der Daten
[p,transMat] = prepca(pn,reduktion);
[pntest] = trastd(ptest,meanp,stdp); % normierung der Daten
[ptest] = trapca(pntest,transMat);
save('transMat','transMat');
%*** ende "Hauptkomponentenanalyse"
dimension = size(p);
disp(['Dimension der Daten nach PCA : ', ...
num2str(dimension(1))]);
disp([' ']);
% *** start "Netzkonfiguration einlesen"
anz_Neuronen = getnumber ...
('Anzahl Neuronen in der Eingabeschicht ',12,1,50);
anz_epochen = getnumber('Anzahl Epochen',250,1,10000);
epochs = round(anz_epochen / epoch_divider);
anz_epochen = round(anz_epochen / epochs) ;
use_old = getstring ...
('Altes Netzwerk verwenden (j/n)','j');
use_old_figure = getstring ...
('Alte Figuren verwenden (j/n)','n');
change = getstring('Change Sets ? (j/n)','n');
% *** ende "Netzkonfiguration einlesen"
if epochs == 0
epochs = 1;
end
if change == 'j'
dummy = p;
p = ptest;
ptest = dummy;
LR = LR / 100;
end
disp([' ']);
nul = zeros(10,anz_samples_train);
one = ones(10,anz_samples_train);
nul = nul - 1 ;
null = nul;null(1,:) = one(1,:);
eins = nul;eins(2,:) = one(2,:);
zwei = nul;zwei(3,:) = one(3,:);
drei = nul;drei(4,:) = one(4,:);
vier = nul;vier(5,:) = one(5,:);
fuenf = nul;fuenf(6,:) = one(6,:);
sechs = nul;sechs(7,:) = one(7,:);
sieben = nul;sieben(8,:) = one(8,:);
acht = nul;acht(9,:) = one(9,:);
neun = nul;neun(10,:) = one(10,:);
t = [null eins zwei drei vier fuenf sechs sieben ...
acht sechs];
nul = zeros(10,anz_samples_test);
one = ones(10,anz_samples_test);
nul = nul - 1 ;
null = nul;null(1,:) = one(1,:);
eins = nul;eins(2,:) = one(2,:);
zwei = nul;zwei(3,:) = one(3,:);
drei = nul;drei(4,:) = one(4,:);
vier = nul;vier(5,:) = one(5,:);
fuenf = nul;fuenf(6,:) = one(6,:);
sechs = nul;sechs(7,:) = one(7,:);
sieben = nul;sieben(8,:) = one(8,:);
acht = nul;acht(9,:) = one(9,:);
neun = nul;neun(10,:) = one(10,:);
tv = [null eins zwei drei vier fuenf sechs sieben ...
acht sechs];
% *** start "Parameter für das Netz"
PR = minmax(p); % Bereich der Eingabedaten
S = [anz_Neuronen 10]; % Anzahl Neuronen pro Schicht
TF = {'tansig',...
'tansig'}; % Transferfunktionen der Schichten
BTF = 'trainlm'; % Backprop network training function
BLF = 'learngdm'; % Backprop network training function
PF = 'mse'; % Performance function
% *** ende "Parameter für das Netz"
% Netz erstellen
if use_old == 'n'
disp(['Erstelle neues Netzwerk ...']);
net = newff(PR,S,TF,BTF,BLF,PF);
net.inputWeights{1}.initFcn = 'rands';
net.inputWeights{2}.initFcn = 'rands';
net = init(net);
else
disp(['Lade altes Netzwerk ...']);
load Network;
end
net.trainparam.lr = LR ; % learning rate 0.05;
net.trainparam.goal = 1e-20;
net.trainparam.epochs = epochs;
net.trainparam.show = 5;
current_epoche = 1;
if use_old_figure == 'n'
close all;
figure,h1 = gcf;
figure,h2 = gcf;
figure,h3 = gcf;
end;
disp(['Weiter mit Taste ...']);
pause;
% Netz trainieren
while current_epoche <= anz_epochen
VV.P = ptest ;
VV.T = tv;
figure(h1),net = train(net,p,t,[],[],VV,[]);
ytrain = sim(net,p);
y = ytrain;
y = matrix_to_vektor(y);
one = ones(1,anz_samples_train);
tgt = [0*one,1*one,2*one,3*one,4*one,5*one,6*one, ...
7*one,8*one,6*one];
one = ones(1,anz_samples_test);
tg = [0*one,1*one,2*one,3*one,4*one,5*one,6*one, ...
7*one,8*one,6*one];
figure(h2),plot(tgt,'ok');hold on;
plot(round(y),'*r');plot(y,'og');
%legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tgt-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (training) -> ', ...
num2str(anz_error/(anz_samples_train/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
ytest = sim(net,ptest);
y = ytest ;
y = matrix_to_vektor(y);
figure(h3),plot(tg,'ok');hold on;plot(round(y),'*r');
plot(y,'og');
% legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tg-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (test) -> ', ...
num2str(anz_error/(anz_samples_test/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
current_epoche = current_epoche + 1;
disp(['Epochen : ',num2str((current_epoche-1) * ...
epochs),' ... ',num2str(current_epoche * epochs)]);
drawnow;
save('Network','net');
end;
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Erzeugt und Trainiert ein BP-Netz. Das
% Training verwendet automated regularization.
%
% Input Trainings und Validationsets
% Output 'Network.mat' trainiertes Netzwerk
% 'transMat.mat' PCA Umrechnungsmatrix
%
% 'meanp.mat'
% 'stdp.mat' Parameter für die Normierung
% der Daten
clc;
%*** start "definition der Konstanten"
reduktion = 0.01; % Varianzen < x % bei PCA ignorieren
epoch_divider = 1 ; % Teiler für die Anzeige der Resultate
anz_samples_train = 18;
anz_samples_test = 18;
LR = 0.08 ;
learnset_fname = getstring('L-Set ',...
'c:\work\old\merkmal.mat');
testset_fname = getstring('T-Set ', ...
'c:\work\old\testset\merkmal.mat');
%*** ende "definition der Konstanten"
load(learnset_fname);p = merkmal_complete;
load(testset_fname) ;ptest = merkmal_complete;
dimension = size(p);
disp([' ']);
disp(['Varianzen < ',num2str(reduktion * 100), ...
' % werden ignoriert ...']);
disp(['Dimension der Daten vor PCA : ', ...
num2str(dimension(1))]);
%*** start "Haupkomponentenanalyse"
[pn,meanp,stdp] = prestd(p); % normierung der Daten
[p,transMat] = prepca(pn,reduktion);
[pntest] = trastd(ptest,meanp,stdp); % normierung der Daten
[ptest] = trapca(pntest,transMat);
save('transMat','transMat');
save('meanp','meanp');
save('stdp','stdp');
%*** ende "Hauptkomponentenanalyse"
dimension = size(p);
disp(['Dimension der Daten nach PCA : ', ...
num2str(dimension(1))]);
disp([' ']);
% *** start "Netzkonfiguration einlesen"
anz_Neuronen = getnumber ...
('Anzahl Neuronen in der Eingabeschicht ',12,1,50);
anz_epochen = getnumber('Anzahl Epochen',250,1,10000);
epochs = round(anz_epochen / epoch_divider);
anz_epochen = round(anz_epochen / epochs) ;
use_old = getstring ...
('Altes Netzwerk verwenden (j/n)','j');
use_old_figure = getstring ...
('Alte Figuren verwenden (j/n)','n');
change = getstring('Change Sets ? (j/n)','n');
% *** ende "Netzkonfiguration einlesen"
if epochs == 0
epochs = 1;
end
if change == 'j'
dummy = p;
p = ptest;
ptest = dummy;
LR = LR / 100;
end
disp([' ']);
nul = zeros(10,anz_samples_train);
one = ones(10,anz_samples_train);
nul = nul - 1 ;
null = nul;null(1,:) = one(1,:);
eins = nul;eins(2,:) = one(2,:);
zwei = nul;zwei(3,:) = one(3,:);
drei = nul;drei(4,:) = one(4,:);
vier = nul;vier(5,:) = one(5,:);
fuenf = nul;fuenf(6,:) = one(6,:);
sechs = nul;sechs(7,:) = one(7,:);
sieben = nul;sieben(8,:) = one(8,:);
acht = nul;acht(9,:) = one(9,:);
neun = nul;neun(10,:) = one(10,:);
t = [null eins zwei drei vier fuenf sechs sieben ...
acht sechs];
nul = zeros(10,anz_samples_test);
one = ones(10,anz_samples_test);
nul = nul - 1 ;
null = nul;null(1,:) = one(1,:);
eins = nul;eins(2,:) = one(2,:);
zwei = nul;zwei(3,:) = one(3,:);
drei = nul;drei(4,:) = one(4,:);
vier = nul;vier(5,:) = one(5,:);
fuenf = nul;fuenf(6,:) = one(6,:);
sechs = nul;sechs(7,:) = one(7,:);
sieben = nul;sieben(8,:) = one(8,:);
acht = nul;acht(9,:) = one(9,:);
neun = nul;neun(10,:) = one(10,:);
tv = [null eins zwei drei vier fuenf sechs sieben ...
acht sechs];
% *** start "Parameter/erstellen Netz"
PR = minmax(p); % Bereich der Eingabedaten
S = [anz_Neuronen 10]; % Anzahl Neuronen pro Schicht
TF = {'tansig',...
'tansig'}; % Transferfunktionen der Schichten
BTF = 'trainbr'; % Backprop network training function
BLF = 'learngdm'; % Backprop network training function
PF = 'mse'; % Performance function
if use_old == 'n'
disp(['Erstelle neues Netzwerk ...']);
net = newff(PR,S,TF,BTF,BLF,PF);
net.inputWeights{1}.initFcn = 'rands';
net.inputWeights{2}.initFcn = 'rands';
net = init(net);
else
disp(['Lade altes Netzwerk ...']);
load Network;
end
net.trainparam.lr = LR ;
net.trainparam.goal = 1e-20;
net.trainparam.epochs = epochs;
net.trainparam.show = 5 ;
% *** ende "Parameter/erstellen Netz"
current_epoche = 1;
if use_old_figure == 'n'
close all;
figure,h1 = gcf;
figure,h2 = gcf;
figure,h3 = gcf;
end;
disp(['Weiter mit Taste ...']);
pause;
% Netz trainieren
while current_epoche <= anz_epochen
figure(h1),net = train(net,p,t);
ytrain = sim(net,p);
y = ytrain;
y = matrix_to_vektor(y);
one = ones(1,anz_samples_train);
tgt = [0*one,1*one,2*one,3*one,4*one,5*one,6*one, ...
7*one,8*one,6*one];
one = ones(1,anz_samples_test);
tg = [0*one,1*one,2*one,3*one,4*one,5*one,6*one, ...
7*one,8*one,6*one];
figure(h2),plot(tgt,'ok');hold on;
plot(round(y),'*r');plot(y,'og');
%legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tgt-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (training) -> ', ...
num2str(anz_error/(anz_samples_train/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
ytest = sim(net,ptest);
y = ytest ;
y = matrix_to_vektor(y);
figure(h3),plot(tg,'ok');hold on;plot(round(y),'*r');
plot(y,'og');
% legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tg-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (test) -> ', ...
num2str(anz_error/(anz_samples_test/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
current_epoche = current_epoche + 1;
disp(['Epochen : ',num2str((current_epoche-1) * ...
epochs),' ... ',num2str(current_epoche * epochs)]);
drawnow;
save('Network','net');
end;
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Erzeugt und Trainiert ein BP-Netz. Das
% Training verwendet automated regularization.
%
% Input Trainings und Validationsets
% Output 'Network.mat' trainiertes Netzwerk
% 'transMat.mat' PCA Umrechnungsmatrix
%
% 'meanp.mat'
% 'stdp.mat' Parameter für die Normierung
% der Daten
clc;
%*** start "definition der Konstanten"
reduktion = 0.01; % Varianzen < x % bei PCA ignorieren
epoch_divider = 1 ; % Teiler für die Anzeige der Resultate
anz_samples_train = 18;
anz_samples_test = 18;
LR = 0.08 ;
learnset_fname = getstring('L-Set ',...
'c:\work\old\merkmalp.mat');
testset_fname = getstring('T-Set ', ...
'c:\work\old\testset\merkmalp.mat');
%*** ende "definition der Konstanten"
load(learnset_fname);p = merkmal_phase;
load(testset_fname) ;ptest = merkmal_phase;
dimension = size(p);
disp([' ']);
disp(['Varianzen < ',num2str(reduktion * 100), ...
' % werden ignoriert ...']);
disp(['Dimension der Daten vor PCA : ', ...
num2str(dimension(1))]);
%*** start "Haupkomponentenanalyse"
[pn,meanp,stdp] = prestd(p); % normierung der Daten
[p,transMat] = prepca(pn,reduktion);
[pntest] = trastd(ptest,meanp,stdp); % normierung der Daten
[ptest] = trapca(pntest,transMat);
save('transMatp','transMat');
save('meanpp','meanp');
save('stdpp','stdp');
%*** ende "Hauptkomponentenanalyse"
dimension = size(p);
disp(['Dimension der Daten nach PCA : ', ...
num2str(dimension(1))]);
disp([' ']);
% *** start "Netzkonfiguration einlesen"
anz_Neuronen = getnumber ...
('Anzahl Neuronen in der Eingabeschicht ',12,1,50);
anz_epochen = getnumber('Anzahl Epochen',250,1,10000);
epochs = round(anz_epochen / epoch_divider);
anz_epochen = round(anz_epochen / epochs) ;
use_old = getstring ...
('Altes Netzwerk verwenden (j/n)','j');
use_old_figure = getstring ...
('Alte Figuren verwenden (j/n)','n');
change = getstring('Change Sets ? (j/n)','n');
% *** ende "Netzkonfiguration einlesen"
if epochs == 0
epochs = 1;
end
if change == 'j'
dummy = p;
p = ptest;
ptest = dummy;
LR = LR / 100;
end
disp([' ']);
nul = zeros(2,anz_samples_train);
one = ones(2,anz_samples_train);
nul = nul - 1 ;
sechs = nul;sechs(1,:) = one(1,:);
neun = nul;neun(2,:) = one(2,:);
t = [sechs neun];
nul = zeros(2,anz_samples_test);
one = ones(2,anz_samples_test);
nul = nul - 1 ;
sechs = nul;sechs(1,:) = one(1,:);
neun = nul;neun (2,:) = one(2,:);
tv = [sechs neun];
% *** start "Parameter/erstellen Netz"
PR = minmax(p); % Bereich der Eingabedaten
S = [anz_Neuronen 2]; % Anzahl Neuronen pro Schicht
TF = {'tansig',...
'tansig'}; % Transferfunktionen der Schichten
BTF = 'trainbr'; % Backprop network training function
BLF = 'learngdm'; % Backprop network training function
PF = 'mse'; % Performance function
if use_old == 'n'
disp(['Erstelle neues Netzwerk ...']);
net = newff(PR,S,TF,BTF,BLF,PF);
net.inputWeights{1}.initFcn = 'rands';
net.inputWeights{2}.initFcn = 'rands';
net = init(net);
else
disp(['Lade altes Netzwerk ...']);
load Networkp;
end
net.trainparam.lr = LR ;
net.trainparam.goal = 1e-20;
net.trainparam.epochs = epochs;
net.trainparam.show = 5 ;
% *** ende "Parameter/erstellen Netz"
current_epoche = 1;
if use_old_figure == 'n'
close all;
figure,h1 = gcf;
figure,h2 = gcf;
figure,h3 = gcf;
end;
disp(['Weiter mit Taste ...']);
pause;
% Netz trainieren
while current_epoche <= anz_epochen
figure(h1),net = train(net,p,t);
ytrain = sim(net,p);
y = ytrain;
y = matrix_to_vektor(y);
one = ones(1,anz_samples_train);
tgt = [0*one,1*one];
one = ones(1,anz_samples_test);
tg = [0*one,1*one];
figure(h2),plot(tgt,'ok');hold on;
plot(round(y),'*r');plot(y,'og');
%legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tgt-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (training) -> ', ...
num2str(anz_error/(anz_samples_train/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
ytest = sim(net,ptest);
y = ytest ;
y = matrix_to_vektor(y);
figure(h3),plot(tg,'ok');hold on;plot(round(y),'*r');
plot(y,'og');
% legend('Ziel','Resultat','num. Wert',3)
error = (round(abs(tg-y)));
anz = find(error~=0);
anz_error = length(anz);
title([num2str(anz_error),' Fehler (test) -> ', ...
num2str(anz_error/(anz_samples_test/10)),' %'])
plot([0 length(y)],[0.5 ,0.5]);
plot([0 length(y)],[1.5 ,1.5]);
plot([0 length(y)],[2.5 ,2.5]);
plot([0 length(y)],[3.5 ,3.5]);
plot([0 length(y)],[4.5 ,4.5]);
plot([0 length(y)],[5.5 ,5.5]);
plot([0 length(y)],[6.5 ,6.5]);
plot([0 length(y)],[7.5 ,7.5]);
plot([0 length(y)],[8.5 ,8.5]);
plot([0 length(y)],[9.5 ,9.5]);
axis([0 length(y) 0 10]); hold off;
current_epoche = current_epoche + 1;
disp(['Epochen : ',num2str((current_epoche-1) * ...
epochs),' ... ',num2str(current_epoche * epochs)]);
drawnow;
save('Networkp','net');
end;
function answer = matrix_to_vektor(matrix);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Formatumwandlung der Netzausgabematrix zu
% einem Vektor
%
% Input matrix Ausgabe des Netzes
% Output Vektor mit den Klasse -n
groesse = size(matrix);
matrix(find(matrix<0)) = zeros(size(find(matrix<0)));
% matrix(1,:)= matrix(1,:) * (-1) ;
matrix = round(matrix);
ncounter = 2;
while ncounter <= groesse(1)
matrix(ncounter,:) = matrix(ncounter,:) * (ncounter) ;
ncounter = ncounter + 1;
end;
ncounter = 1 ;
while ncounter <= groesse(2)
if length(find(matrix(:,ncounter)>0.5)) > 1
matrix(:,ncounter) = matrix(:,ncounter) * (-1) ;
end
ncounter = ncounter + 1;
end;
answer = sum(matrix);
answer = answer -1 ;
function answer = matrix_to_vektor(matrix);
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller *
%* Quelle : --- *
%* *
%* Version : 1.00.000 *
%* Datum : 25. Jan. 2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Formatumwandlung der Netzausgabematrix zu
% einem Vektor (alternativer Algorithmus, nur
% zur Auswertung, nicht fürs Training).
%
% Input matrix Ausgabe des Netzes
% Output Vektor mit den Klasse -n
groesse = size(matrix);
answer = [];
ncounter = 1 ;
while ncounter <= groesse(2)
m = matrix(:,ncounter)';
I = find(m == max(m)) - 1;
answer = [answer I];
ncounter = ncounter + 1;
end;
%***********************************************************
%* Semesterarbeit 5. Semester *
%***********************************************************
%* Aufgabe : Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : P. Gfeller, E5b *
%* Version 1.00.000 *
%***********************************************************
%* History : *
%***********************************************************
function answer = projektion(BILD);
mode = 'n';
anzahl = 20 ;
current = 0 ;
groesse = size(BILD);
anz_pix = (groesse(1) / anzahl) * groesse(2);
y = [];x = [];
if mode == 'd'
figure;
end;
while current < anzahl
BILD_work = BILD([1+round(current*groesse(1)/anzahl):...
round((current+1)*groesse(1)/anzahl)],:);
if mode == 'd'
subplot(anzahl,1,current+1),imshow(not(BILD_work));
end;
schwarz = sum(sum(BILD_work));
ratio = schwarz / anz_pix;
y = [y ratio];
current = current + 1;
end;
if mode == 'd'
figure;
end;
current = 0;
while current < anzahl
BILD_work = BILD(:,[1+round(current*groesse(2)/anzahl):...
round((current+1)*groesse(2)/anzahl)]);
if mode == 'd'
subplot(1,anzahl,current+1),imshow(not(BILD_work));
end;
schwarz = sum(sum(BILD_work));
ratio = schwarz / anz_pix;
x = [x ratio];
current = current + 1;
end;
result = [x;y];
x = result(1,:);
y = result(2,:);
if mode == 'd'
figure;subplot(211);stem(x);hold on;subplot(212);stem(y);
end;
answer = [x';y'];
function ans = drehmoment(BILD); %*********************************************************** %* Semesterarbeit 5. Semester * %* Neuronale Netze zur Musterklassifikation * %*********************************************************** %* Autor : P. Gfeller * %* Quelle : --- * %* * %* Version : 1.00.000 * %* Datum : 25. Jan. 2001 * %*********************************************************** %* History : * %*********************************************************** % Zweck % % Input % Output m = ones(size(BILD)); m = cumsum(m); v = ones(size(BILD')); v = cumsum(v); v = v'; m = v ; q = sum(sum(m)'); p = m .* not(BILD); p = sum(sum(p)'); ans = p / q;
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : Patrik Gfeller *
%* Quelle : *
%* *
%* Version : 1.00.000 *
%* Datum : 18.01.2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Hauptkomponentenanalyse der Merkmale und
% graphische Darstellung dieses Resultates
clear all; % Alle Variablen loeschen
close all; % Alle Files schliessen
clc; % Workspace leeren
samples = 15;
load ('c:\work\auto\merkmal');
p = merkmal_complete;
% Haupkomponentenanalyse
[pn,meanp,stdp] = prestd(p); % normierung der Daten
[ptrans,transMat] = prepca(pn,0);
x = ones(size(ptrans));
x = cumsum(x);
y = ptrans;
stem(x,y);
X0 = y(1,1:samples);
X1 = y(1,samples+1:2*samples);
X2 = y(1,2*samples+1:3*samples);
X3 = y(1,3*samples+1:4*samples);
X4 = y(1,4*samples+1:5*samples);
X5 = y(1,5*samples+1:6*samples);
X6 = y(1,6*samples+1:7*samples);
X7 = y(1,7*samples+1:8*samples);
X8 = y(1,8*samples+1:9*samples);
X9 = y(1,9*samples+1:10*samples);
Y0 = y(2,1:samples);
Y1 = y(2,samples+1:2*samples);
Y2 = y(2,2*samples+1:3*samples);
Y3 = y(2,3*samples+1:4*samples);
Y4 = y(2,4*samples+1:5*samples);
Y5 = y(2,5*samples+1:6*samples);
Y6 = y(2,6*samples+1:7*samples);
Y7 = y(2,7*samples+1:8*samples);
Y8 = y(2,8*samples+1:9*samples);
Y9 = y(2,9*samples+1:10*samples);
Z0 = y(3,1:samples);
Z1 = y(3,samples+1:2*samples);
Z2 = y(3,2*samples+1:3*samples);
Z3 = y(3,3*samples+1:4*samples);
Z4 = y(3,4*samples+1:5*samples);
Z5 = y(3,5*samples+1:6*samples);
Z6 = y(3,6*samples+1:7*samples);
Z7 = y(3,7*samples+1:8*samples);
Z8 = y(3,8*samples+1:9*samples);
Z9 = y(3,9*samples+1:10*samples);
figure,plot3(X0,Y0,Z0,'ob'); hold on;
plot3(X1,Y1,Z1,'or');
plot3(X2,Y2,Z2,'og');
plot3(X3,Y3,Z3,'om');
plot3(X4,Y4,Z4,'ok');
plot3(X5,Y5,Z5,'*k');
plot3(X6,Y6,Z6,'*b');
plot3(X7,Y7,Z7,'*m');
plot3(X8,Y8,Z8,'*g');
plot3(X9,Y9,Z9,'sb');
xlabel('1. Hauptkomponente');
ylabel('2. Hauptkomponente');
zlabel('3. Hauptkomponente');
legend('0','1','2','3','4','5','6','7','8','9');
grid on;
%***********************************************************
%* Semesterarbeit 5. Semester *
%* Neuronale Netze zur Musterklassifikation *
%***********************************************************
%* Autor : Patrik Gfeller *
%* Quelle : *
%* *
%* Version : 1.00.000 *
%* Datum : 18.01.2001 *
%***********************************************************
%* History : *
%***********************************************************
% Zweck Extraktion von Merkmalen
clear all,close all,clc;
%*** Definition der Konstanten
mode = 'n'; % 'n' = normal , 'd' = debug
path = 'c:\work\old\testset\' ; % Verzeichnis der Bilder
mat_fname = 'merkmalv'; % Dateiname für Ausgabe
mat_fname_phase = 'merkmalp' ;
anzahl_sample = 18; % Anzahl Samples pro Ziffer
current_sample_init = 1; %
ziffer = 0; % Ziffer, die verarbeitet werden soll
%***
xy_complete = [];
merkmal_complete = [];
merkmal_phase = [];
while ziffer <= 9
current_sample = current_sample_init;
xy = [];
merkmal_current = [];
while current_sample <= anzahl_sample
filename = [path,num2str(ziffer),'\',...
num2str(current_sample),'.tif'];
disp(['Verarbeite Datei ',filename,' ...']);drawnow;
BILD_ORIG=imread(filename); % Bild einlesen
BILD = not(BILD_ORIG); % Bild Invertieren
BILD = ferretbox(BILD); % Bildränder löschen
[A,B] = fft_bild(BILD);
if or((ziffer==6),(ziffer==9))
merkmal_phase = [merkmal_phase B'];
end
merkmal_current_add = A' ; % Amplitudenspektrum
merkmal_current = [merkmal_current,...
merkmal_current_add];
current_sample = current_sample + 1 ;
end % end of "while current_sample < anzahl_sample"
merkmal_complete = [merkmal_complete, merkmal_current];
ziffer = ziffer + 1;
end % while ziffer <= 10
save([path,mat_fname],'merkmal_complete');
save([path,mat_fname_phase],'merkmal_phase');