DAY BY DAY zu Simulations- u. Regelungstechnik 2 für 5-MT, WS 2023/24
(EN google-translate)
(PL google-translate)
AKTUELL, Stand 12.01.24:
Der E-Test zu Simulations- und Regelungstechnik 5-MT findet ab 10:00Uhr am Donnerstag den 18.01.2024 im Mechatroniklabor D.2.08 statt.
Übersicht
|
Beim Kurs Regelungstechnik 2 kommen zu den im ersten Kurs behandelten klassinschen Verfahren der Regelungstechnik Optimierungsverfahren (statisch / kleinste Quadrate Methode, dynamisch / modifiziertes Gradientenverfahren) hinzu, sowie Beispiele aus dem Bereich Softcomputing (Evolutionäre Algorithmen, Fuzzy-Regelung, mit Einschränkungen Neuronale Netze). Die im ersten Kurs behandelten Verfahren bilden eine Art Referenz im Hintergrund, gegen die die neuen Verfahren getestet und diskutiert werden. Deshalb sollen die alten Inhalte in den ersten Stunden auch erst einmal wieder wach gerufen werden.
Die Inhalte der vorangehenden Vorlesung können hier nachgeschlagen werden:
04_SoSe2023/02_RTS_day_by_day
Chronologisches Verzeichnis der im Verlauf des Semesters behandelten Themen
|
LV#1 Mittwoch 22.11.2023
1. Rückblick
Rückmeldung zu den Praktika -- Wie hat sich die Sicht auf Beruf und Studium verändert?
Wiederholung der Inhalte aus Regelungstechnik 1
|
zu 1.: Scilab (ode, csim)
allgemein: 37_Scilab
ode (Beispiel): 54_Kinetik/01_Newton/04_ODE
csim (Beispiel): 62_Regelungssysteme/01_day_by_day
zu 2.: Laplacetransformation
Theorie: 62_Regelungssysteme/04_Laplace
Regeln: 62_Regelungssysteme/04_Laplace/03_PRegler
zu 3.: Auslegungsmethoden nach Ziegler und Nichols
62_Regelungssysteme/07_Einstellregeln
Methode 1: 62_Regelungssysteme/07_Einstellregeln/02_Methode1
Methode 2: 62_Regelungssysteme/07_Einstellregeln/03_Methode2
zu 4. Eigenwertberechnung
s. Tafel im Unterricht
zu 5. Polvorgabe
62_Regelungssysteme/08_Polvorgabe
zu 6. Zustandsregler
Theorie Zustandsregler mit Beobachter und Blockbezeichnungen A,B,C,D: 62_Regelungssysteme/09_Beobachter
Übungen zu Laplace als Wiederholung
Übung 1 -- Wandeln Sie jeweils um in den Zeit- bzw. Laplacebereich
1a)
$ \ddot x + 3 \dot x + x = 4 u $
Formel 0-1: Transformieren Sie die lineare Differentialgleichung in den Laplacebereich.
1b)
$ X s^3 + X s - 4 U s^2 = U $
Formel 0-2: Transformieren Sie in den Zeitbereich.
1c)
$ G\left(s\right) = \frac {s^2+1}{s^3+s} $
Formel 0-3: Transformieren Sie in den Zeitbereich. Eingang sei U & Ausgang sei X.
1d)
$ G\left(s\right) = \frac {s^2+1}{s^3+s} $
Formel 0-4: Transformieren Sie in den Zeitbereich. Eingang sei U & Ausgang sei X.
1e) Nachfolgend sind die Laplace-Transformierten einer Regelstrecke G(s) und eines Reglers R(s) dargestellt.
|
$ G\left(s\right) = \frac {1}{s^2+5s} $
Formel 0-5: Regelstrecke
$ R\left(s\right) = \frac {1}{s} + 5 + s $
Formel 0-6: Regler
Übung 2 -- Umsetzung regelungstechnischer Systeme mit Scilab
Nehmen Sie sich erneut das System von 1e) vor.
2a)
|
2b)
|
2c)
Verdeutlichen Sie sich durch Zeichnen eines Blockschaltbildes:
|
|
50_Simulationstechnik/05_Parameterindentifikation/01_KleinsteQuadrate/01_Linearregression
50_Simulationstechnik/05_Parameterindentifikation/01_KleinsteQuadrate
50_Simulationstechnik/05_Parameterindentifikation/01_KleinsteQuadrate/02_Beispiel
Allgemeines zu Optimierungsverfahren
50_Simulationstechnik/06_Optimierung
B = [ 1 0
1 16
1 25 ];
d = [ -100
-70
-50];
A = B'*B
b = B'*d
// Ac+b=0
// c = inv(A)*(-b)
c=inv(A)*(-b)
//...oder direkt mit der Scilab-Funktion lsq:
cc=lsq(B,-d)
Code 0-1: Aufgabe aus dem Unterricht mit Scilab gelöst.
Übung
VoltCm = [ 2.5 20
2.0 30
1.5 40
1.05 60
0.75 90
0.5 130
0.45 150
];
// Aufgabe:
// a) Messwerte möglichst gut durch quadratische Funktion annähern
// b) Messwerte möglichst gut durch kubische Funktion annähern
// Verläufe aus a) , b) und den Messwerten übereinander als Plot darstellen
// a) und b) sind mit Scilab mittels kleinster Quadrate-Methode zu lösen.
Code 0-2: Näherung der Meßwerte zu einem Entfernungssensor über Funktionen
Quelle / Datenblatt des Sensors: https://www.sparkfun.com/datasheets/Sensors/Infrared/gp2y0a02yk_e.pdf
LV#2 Donnerstag 23.11.2023
ACHTUNG: ab 30.11. beginnt die LV Donnerstags immer um 12:20 im Raum D.5.13!
Themen:
|
1. Besprechung der gestrigen Übung zur Kleinsten Quadrate Methode
y=[20; 30; 40; 60; 90; 130; 150] //Entfernungen in cm x=[2.5; 2; 1.5; 1.05; 0.75; 0.5; 0.45 ] //gemessenen Spannungen am Sensor //Ansatzfunktion: // y = c0 + c1*x + c2*x^2 // B = [1, xi , xi.*xi] zs = size(x); zeilen = zs(1); B = [ones(zeilen,1),x,(x.*x)] //B= [1,2.5,6.25; 1,2,4; 1,1.5,2.25; 1,1.05,1.025; 1,0.75,0.5629; 1,0.5,0.25; 1,0.45,0.2025] d=-y; A=B'*B b =B'*d c=inv(A)*(-b) // oder cc=lsq(B, -d) plot(x,y,'* ') //Plot der Messpunkte xx = 0.3:0.1:2.5; yy = c(1) + c(2).*xx + c(3).*xx.*xx; yy2 = cc(1) + cc(2).*xx + cc(3).*xx.*xx; plot(xx,yy,'red'); //Lösung mit Matrizen plot(xx,yy2,'blu--');//Lösung mit lsq (identisches Ergebnis)
Code 0-3: Studentische Lösung
Bild 0-1: Plot der Lösung.
x=[0,1,2] y=[2,3,4] //Ansatzfunktion: y = c0 + c1*2^x B = [ones(3,1),(2^x)'] d = -y' A=B'*B b=B'*d c=inv(A)*(-b) plot(x,y,'* ') xx = -1:0.1:5; yy = c(1)+c(2)*(2^xx); plot(xx,yy);
Code 0-4: Kleines Beispiel mit transzendenter Ansatzfunktion, statt Polynom.
Bild 0-2: Plot dazu.
3. Heuristiken
"Heuristik ... bezeichnet Methoden, die mit begrenztem Wissen (unvollständigen Informationen) und wenig Zeit dennoch zu wahrscheinlichen Aussagen oder praktikablen Lösungen kommen.
"
Quelle: https://de.wikipedia.org/wiki/Heuristik, Aufruf 23.11.2023.
62_Regelungssysteme/05_Regleroptimierung/02_Heuristiken
62_Regelungssysteme/05_Regleroptimierung/01_Guetefunktion
4. Gradientenverfahren
62_Regelungssysteme/05_Regleroptimierung/04_Gradientenverfahren
62_Regelungssysteme/05_Regleroptimierung/05_ModifizierteG
function F = fehlerfunktion(u)
x = u(1);
y = u(2);
F = x^3-4*x+y^3-16*y
endfunction
ustart = [1,1];
uopt = [2/sqrt(3),4/sqrt(3) ]
Fstart = fehlerfunktion(ustart)
Fopt = fehlerfunktion(uopt)
alfa = 0.01;
schritte = 1000
u=ustart;
Fakt=fehlerfunktion(u)
for i=1:schritte
r = floor(grand(2, 1, "unf", 0, 2.999999999))-1;
uneu = u + alfa*(r');
Fneu = fehlerfunktion(uneu);
if Fneu<Fakt
Fakt = Fneu;
u=uneu;
end
end
disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))
Code 0-5: Implementierung eines modifizierten Gradientenverfahrens bei bekannter Fehlerfunktion F.
//Alfa steuern
function F = fehlerfunktion(u)
x = u(1);
y = u(2);
F = x^3-4*x+y^3-16*y
endfunction
ustart = [1,1];
uopt = [2/sqrt(3),4/sqrt(3) ]
Fstart = fehlerfunktion(ustart)
Fopt = fehlerfunktion(uopt)
alfa = 0.1;
alfaunterschwelle=0.003;
schritte = 100
u=ustart;
Fakt=fehlerfunktion(u)
//for i=1:schritte
while alfa>alfaunterschwelle
r = floor(grand(2, 1, "unf", 0, 2.999999999))-1;
uneu = u + alfa*(r');
Fneu = fehlerfunktion(uneu);
if Fneu<=Fakt //wenn sich nichts ändert, trotzdem wandern!!!
Fakt = Fneu;
u=uneu;
alfa=alfa*1.1;
else
alfa=alfa*0.9;
end
end
disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))
disp("Alfa am Ende:")
disp(alfa);
Code 0-6: Schrittweitensteuerung und Abbruchkriterium ergänzt.
AKTUELL: Ab KW48, ab 30.11. beide Blöcke Donnerstags, erst Mechatroniklabor ab 09:30Uhr, dann D.5.13.
LV#3 Donnerstag 30.11.2023
Themen:
|
Material zum Invertierenden Pendel mit Zustandsregler: 62_Regelungssysteme/98_day_by_day_WS2021_SoSe21
Genetische Optimierung: 50_Simulationstechnik/07_Genalgorithmus
Optimierung der Regelparameter beim Invertierenden Pendel mittels modifiziertem Gradientenverfahren
//Auslegung des Reglers für das invertierende Pendel
//mit Hilfe eines Optimierers
clear();
m = 1; //kg
g = 9.81; // m/s^2
l = 1; // m
h = l/2; // m
r = 0.1; // m
J = 0.25*m*r*r + (1/12)*m*l*l; // kg*m^2
R = [10.0, 0.5];
Ropt = [11.63, 0.7904851];
Fgrenz=1.73;
function f = rechteSeite(t,y)
phi = y(1,1);
om = y(2,1);
f(1,1) = om;
FA = -R * [phi;om];
if FA>Fgrenz then
FA=Fgrenz;
end
if FA<-Fgrenz then
FA=-Fgrenz;
end
N = J + m*h*h*sin(phi)*sin(phi);
f(2,1) = (-m*h*h*om*om*sin(phi)*cos(phi) + h*m*sin(phi)*g + h*cos(phi)*FA )/N;
endfunction
t = 0:0.01:8;
y0 = [10.0*%pi/180,0.0]'; //Start in der Nähe der instabilen Ruhelage
t0 = 0;
y = ode(y0,t0,t,rechteSeite);
FFA = -R(1)*y(1,:)-R(2)*y(2,:);
//plot(t,y(1,:)',t,y(2,:)',t,FFA);
function err = fehlerfunktion(RR)
R = RR;
y = ode(y0,t0,t,rechteSeite);
err = sqrt(y(1,:)*(y(1,:)'));
endfunction
err = fehlerfunktion(Ropt)
R1 = [10.0,0.5];
err = fehlerfunktion(R1)
R2 = [11.0,0.7];
err = fehlerfunktion(R2)
ustart = R1; //[1,1];
//uopt = [2/sqrt(3),4/sqrt(3) ]
Fstart = fehlerfunktion(ustart)
//Fopt = fehlerfunktion(uopt)
alfa = 0.1;
alfaunterschwelle=0.003;
schritte = 100
u=ustart;
Fakt=fehlerfunktion(u)
//for i=1:schritte
while alfa>alfaunterschwelle
r = floor(grand(2, 1, "unf", 0, 2.999999999))-1;
uneu = u + alfa*(r');
Fneu = fehlerfunktion(uneu);
if Fneu<=Fakt //wenn sich nichts ändert, trotzdem wandern!!!
Fakt = Fneu;
u=uneu;
alfa=alfa*1.1;
else
alfa=alfa*0.9;
end
end
disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))
disp("Alfa am Ende:")
disp(alfa);
R = u;
y = ode(y0,t0,t,rechteSeite);
FFA = -R(1)*y(1,:)-R(2)*y(2,:);
plot(t,y(1,:)',t,y(2,:)',t,FFA);
Code 0-7: Scilab Script zur Optimierung.
Parameterstudie als alternative Möglichkeit, sinnvolle Parameter zu finden
//Auslegung des Reglers für das invertierende Pendel
//mit Hilfe eines Optimierers
clear();
m = 1; //kg
g = 9.81; // m/s^2
l = 1; // m
h = l/2; // m
r = 0.1; // m
// siehe: http://www.kramann.info/54_Kinetik/02_NewtonEuler/01_Traegheitsmomente
J = 0.25*m*r*r + (1/12)*m*l*l; // kg*m^2
R = [10.0, 0.5];
Ropt = [11.63, 0.7904851];
Fgrenz=1.73;
function f = rechteSeite(t,y)
phi = y(1,1);
om = y(2,1);
f(1,1) = om;
FA = -R * [phi;om];
if FA>Fgrenz then
FA=Fgrenz;
end
if FA<-Fgrenz then
FA=-Fgrenz;
end
N = J + m*h*h*sin(phi)*sin(phi);
f(2,1) = (-m*h*h*om*om*sin(phi)*cos(phi) + h*m*sin(phi)*g + h*cos(phi)*FA )/N;
endfunction
t = 0:0.01:8;
y0 = [10.0*%pi/180,0.0]'; //Start in der Nähe der instabilen Ruhelage
t0 = 0;
y = ode(y0,t0,t,rechteSeite);
FFA = -R(1)*y(1,:)-R(2)*y(2,:);
//plot(t,y(1,:)',t,y(2,:)',t,FFA);
function err = fehlerfunktion(RR)
R = RR;
y = ode(y0,t0,t,rechteSeite);
err = sqrt(y(1,:)*(y(1,:)'));
endfunction
err = fehlerfunktion(Ropt)
R1 = [10.0,0.5];
err = fehlerfunktion(R1)
R2 = [11.0,0.7];
err = fehlerfunktion(R2)
ustart = R1; //[1,1];
//uopt = [2/sqrt(3),4/sqrt(3) ]
Fstart = fehlerfunktion(ustart)
//Fopt = fehlerfunktion(uopt)
// 11.428411 0.53358
// r1 r2
// Parameterstudie:
// r1 = [9..13] r2=[0.4..0.9]
err_alt = 99999.99;
r1best=0;
r2best=0;
for r1=20:0.1:30
for r2=1.0:0.01:2.0
u=[r1,r2];
err_neu = fehlerfunktion(u);
if err_neu<err_alt
err_alt = err_neu;
r1best = r1;
r2best = r2;
end
end
end
disp("Beste Kombination aus der Parameterstudie:");
R = [r1best,r2best]
errbest = err_alt
y = ode(y0,t0,t,rechteSeite);
FFA = -R(1)*y(1,:)-R(2)*y(2,:);
plot(t,y(1,:)',t,y(2,:)',t,FFA);
Code 0-8: Parameterstudie.
Ausregelung aller Zustände: phi, omega, x, vx
clear();
m = 1; //kg
g = 9.81; // m/s^2
l = 1; // m
h = l/2; // m
r = 0.1; // m
// siehe: http://www.kramann.info/54_Kinetik/02_NewtonEuler/01_Traegheitsmomente
J = 0.25*m*r*r + (1/12)*m*l*l; // kg*m^2
R = [27.834942, 3.2444592, -6.9996602, -4.8997621];
function f = rechteSeite(t,y)
phi = y(1,1);
om = y(2,1);
x = y(3,1);
v = y(4,1);
FA = -R * [phi;om;x;v];
f(1,1) = om;
N = J + m*h*h*sin(phi)*sin(phi);
f(2,1) = (-m*h*h*om*om*sin(phi)*cos(phi) + h*m*sin(phi)*g + h*cos(phi)*FA )/N;
f(3,1) = v;
f(4,1) = FA/m;
endfunction
t = 0:0.01:10;
y0 = [10.0*%pi/180,0.0,0.0,0.0]'; //Start in der Nähe der instabilen Ruhelage
t0 = 0;
y = ode(y0,t0,t,rechteSeite);
plot(t,y(1,:),t,y(2,:),t,y(3,:),t,y(4,:));
Code 0-9: Zustandsregelung Gesamtzustand.
4 Zustände optimieren
clear();
m = 1; //kg
g = 9.81; // m/s^2
l = 1; // m
h = l/2; // m
r = 0.1; // m
// siehe: http://www.kramann.info/54_Kinetik/02_NewtonEuler/01_Traegheitsmomente
J = 0.25*m*r*r + (1/12)*m*l*l; // kg*m^2
R = [27.834942, 3.2444592, -6.9996602, -4.8997621];
function f = rechteSeite(t,y)
phi = y(1,1);
om = y(2,1);
x = y(3,1);
v = y(4,1);
FA = -R * [phi;om;x;v];
f(1,1) = om;
N = J + m*h*h*sin(phi)*sin(phi);
f(2,1) = (-m*h*h*om*om*sin(phi)*cos(phi) + h*m*sin(phi)*g + h*cos(phi)*FA )/N;
f(3,1) = v;
f(4,1) = FA/m;
endfunction
t = 0:0.01:10;
y0 = [10.0*%pi/180,0.0,0.0,0.0]'; //Start in der Nähe der instabilen Ruhelage
t0 = 0;
//y = ode(y0,t0,t,rechteSeite);
///////////
//FFA = -R(1)*y(1,:)-R(2)*y(2,:);
//plot(t,y(1,:)',t,y(2,:)',t,FFA);
function err = fehlerfunktion(RR)
R = RR;
y = ode(y0,t0,t,rechteSeite);
err = sqrt(y(1,:)*(y(1,:)'));
endfunction
//err = fehlerfunktion(Ropt)
R1 = [28, 3, -6, -5];
err = fehlerfunktion(R1)
R2 = [26, 2, -5, -4];
err = fehlerfunktion(R2)
//#########################
ustart = R1; //[1,1];
//uopt = [2/sqrt(3),4/sqrt(3) ]
Fstart = fehlerfunktion(ustart)
//Fopt = fehlerfunktion(uopt)
alfa = 0.1;
alfaunterschwelle=0.003;
schritte = 100
u=ustart;
Fakt=fehlerfunktion(u)
//for i=1:schritte
while alfa>alfaunterschwelle
r = floor(grand(4, 1, "unf", 0, 2.999999999))-1;
uneu = u + alfa*(r');
Fneu = fehlerfunktion(uneu);
if Fneu<=Fakt //wenn sich nichts ändert, trotzdem wandern!!!
Fakt = Fneu;
u=uneu;
alfa=alfa*1.1;
else
alfa=alfa*0.9;
end
end
disp("Endergebnis der Optimierung:")
disp(u)
disp("Fehler am Ende:")
disp(fehlerfunktion(u))
disp("Alfa am Ende:")
disp(alfa);
R = u;
y = ode(y0,t0,t,rechteSeite);
//FFA = -R(1)*y(1,:)-R(2)*y(2,:);
///
plot(t,y(1,:),t,y(2,:),t,y(3,:),t,y(4,:));
Code 0-10: 4 Zustände optimieren.
LV#5 Donnerstag 07.12.2023
Themen:
Nachdem das modifizierte Gradientenverfahren eingeführt wurde, bei dem vorausgesetzt wird, dass der Fehlerraum einfach und glatt ist, wird nun als Alternative auch Genetische Optimierung eingeführt, ein Verfahren, das auch bei zerklüfteten Suchräumen noch funktionieren kann.
Um sich erst ganz auf das Verfahren konzentrieren zu können, wird zunächst ein sehr einfaches Problem behandelt und erst dann im Vergleich zu den anderen Problemen beispielhaft wieder das invertierende Pendel als Beispiel genommen.
|
1. Einführung in Evolutionäre Algorithmen
Einführung der Methode der Genetischen Optimierung: 50_Simulationstechnik/07_Genalgorithmus
2. Genetische Optimierung zum Erraten eines Binärpatterns
Gemeinsame Umsetzung mit Scilab.
|
3. selbständige ÜBUNG Genetische Optimierung des Reglers für das Invertierende Pendel
Rorschach-Bilder genetisch optimieren mit Processing
public void setup()
{
size(600,600);
frameRate(30);
}
public void draw()
{
background(255);
fill(255,0,0,100);
stroke(0,255,0);
rect(0,0,width/2,height/2);
fill(0,0,255,100);
noStroke();
rect(width/4,height/4,width/2,height/2);
}
Code 0-11: Erstes Processing Beispiel.
Zufallsarray:
import java.util.Random;
Random zufall = new Random(System.currentTimeMillis());
public int[][] erzeugeZufallsmatrix(int zeilen, int spalten)
{
int[][] arr = new int[zeilen][spalten];
for(int i=0;i<arr.length;i++)
for(int k=0;k<arr[i].length;k++)
arr[i][k] = zufall.nextInt(2);
return arr;
}
public void showArray(int[][] arr)
{
println();
for(int i=0;i<arr.length;i++)
{
for(int k=0;k<arr[i].length;k++)
{
print(arr[i][k]+" ");
}
println();
}
}
public void setup()
{
size(600,600);
frameRate(30);
int[][] x = erzeugeZufallsmatrix(8, 8);
showArray(x);
}
public void draw()
{
background(255);
}
Code 0-12: Zufallsarray.
Ausgangspunkt für die Übung
Rorschach103.zip
import java.util.Random;
Random zufall = new Random(System.currentTimeMillis());
public int[][] erzeugeZufallsmatrix(int zeilen, int spalten)
{
int[][] arr = new int[zeilen][spalten];
for(int i=0;i<arr.length;i++)
for(int k=0;k<arr[i].length;k++)
arr[i][k] = zufall.nextInt(2);
return arr;
}
public int[] erzeugeZufallsarray(int spalten)
{
int[] arr = new int[spalten];
for(int k=0;k<arr.length;k++)
arr[k] = zufall.nextInt(2);
return arr;
}
public int[][] geno2phaeno(int[] arr)
{
int spalten = (int)Math.sqrt((double)arr.length);
int[][] bild = new int[spalten][spalten];
int ii=0;
for(int i=0;i<bild.length;i++)
for(int k=0;k<bild[i].length;k++)
bild[i][k]=arr[ii++];
return bild;
}
public void copyA2B(int[] a, int[] b)
{
for(int i=0;i<a.length;i++)
b[i]=a[i];
}
public void drawArray(int[][] arr)
{
float dx = width/(float)arr[0].length;
float dy = height/(float)arr.length;
noStroke();
for(int i=0;i<arr.length;i++)
{
for(int k=0;k<arr[i].length;k++)
{
if(arr[i][k]>0)
fill(0);
else
fill(255);
rect((float)k*dx,(float)i*dy,dx,dy);
}
}
}
public void showArray(int[][] arr)
{
println();
for(int i=0;i<arr.length;i++)
{
for(int k=0;k<arr[i].length;k++)
{
print(arr[i][k]+" ");
}
println();
}
}
int[][] x;
int rorschachbreite = 80;
//Gene einer Generation
int anzahlProGeneration = 100;
int anzahlSelektion = 10;
int[][] gen = new int[anzahlProGeneration][rorschachbreite*rorschachbreite];
int[][] genbest = new int[anzahlSelektion][rorschachbreite*rorschachbreite];
double[] fehler = new double[anzahlProGeneration];
int[][] BILD;
public void setup()
{
size(600,600);
frameRate(4);
int[] meingen = erzeugeZufallsarray(gen[0].length);
copyA2B(meingen, genbest[0]);
BILD = geno2phaeno(genbest[0]);
//Initialisierung der 0. Generation
//1. gen mit Zufallswerten füllen (0 oder 1)
}
public void draw()
{
background(255);
//2. Bewertung jedes Gens und merken in double[] fehler
//3. Die zehn besten Gene identifizieren
//4. Aus den 10 besten 90 neue rekombinieren
//und dann von vorne
//5. BILD des allerbesten Gens zeigen
drawArray(BILD);
}
Code 0-13: Ausgangspunkt für die Übung
LÖSUNG
Bild 0-3: Screenshot nach einem Optimierungslauf.
Rorschach104.zip
import java.util.Random;
Random zufall = new Random(System.currentTimeMillis());
public double fehlerGen(int[] arr)
{
int rorschachbreite = (int)Math.sqrt((double)arr.length);
double err=0.0;
for(int i=0;i<(rorschachbreite);i++)
{
int x = i*rorschachbreite;
for(int k=0;k<rorschachbreite/2;k++)
{
if(arr[x+k]!=arr[x+rorschachbreite-1-k])
{
err+=1.0;
}
}
}
return err;
}
public int[][] erzeugeZufallsmatrix(int zeilen, int spalten)
{
int[][] arr = new int[zeilen][spalten];
for(int i=0;i<arr.length;i++)
for(int k=0;k<arr[i].length;k++)
arr[i][k] = zufall.nextInt(2);
return arr;
}
public int[] erzeugeZufallsarray(int spalten)
{
int[] arr = new int[spalten];
for(int k=0;k<arr.length;k++)
arr[k] = zufall.nextInt(2);
return arr;
}
public int[][] geno2phaeno(int[] arr)
{
int spalten = (int)Math.sqrt((double)arr.length);
int[][] bild = new int[spalten][spalten];
int ii=0;
for(int i=0;i<bild.length;i++)
for(int k=0;k<bild[i].length;k++)
bild[i][k]=arr[ii++];
return bild;
}
public void copyA2B(int[] a, int[] b)
{
for(int i=0;i<a.length;i++)
b[i]=a[i];
}
public void drawArray(int[][] arr)
{
float dx = width/(float)arr[0].length;
float dy = height/(float)arr.length;
noStroke();
for(int i=0;i<arr.length;i++)
{
for(int k=0;k<arr[i].length;k++)
{
if(arr[i][k]>0)
fill(0);
else
fill(255);
rect((float)k*dx,(float)i*dy,dx,dy);
}
}
}
public void showArray(int[][] arr)
{
println();
for(int i=0;i<arr.length;i++)
{
for(int k=0;k<arr[i].length;k++)
{
print(arr[i][k]+" ");
}
println();
}
}
//-------------
int[][] x;
int rorschachbreite = 80;
//Gene einer Generation
int anzahlProGeneration = 1000;
int anzahlSelektion = 100;
int[][] gen = new int[anzahlProGeneration][rorschachbreite*rorschachbreite];
int[][] genbest = new int[anzahlSelektion][rorschachbreite*rorschachbreite];
double[] fehler = new double[anzahlProGeneration];
int[][] BILD;
public void setup()
{
size(600,600);
frameRate(30);
int[] meingen = erzeugeZufallsarray(gen[0].length);
copyA2B(meingen, genbest[0]);
BILD = geno2phaeno(genbest[0]);
//Initialisierung der 0. Generation
//1. gen mit Zufallswerten füllen (0 oder 1)
for(int i=0;i<gen.length;i++)
for(int k=0;k<gen[0].length;k++)
gen[i][k] = zufall.nextInt(2);
int[] gg = {0,0,0,0, 1,0,0,1, 0,1,1,0, 0,0,0,0};
println("Fehler = "+fehlerGen(gg));
int[] hh = {0,0,0,0, 1,0,0,1, 0,1,1,0, 0,0,0,1};
println("Fehler = "+fehlerGen(hh));
}
double BESTFEHLER = Double.MAX_VALUE;
public void draw()
{
background(255);
//2. Bewertung jedes Gens und merken in double[] fehler
for(int i=0;i<gen.length;i++)
fehler[i] = fehlerGen(gen[i]);
//3. Die zehn besten Gene identifizieren
int bestindex = -1;
int[] bestbestgen = new int[rorschachbreite*rorschachbreite];
for(int i=0;i<genbest.length;i++)
{
double bestfehler = Double.MAX_VALUE;
int index = -1;
int start = zufall.nextInt(gen.length);
for(int kk=0;kk<gen.length;kk++)
{
int k = (kk+start)%gen.length;
if(fehler[k]<=bestfehler)
{
bestfehler = fehler[k];
copyA2B(gen[k], genbest[i]);
index=k;
}
}
if(i==0)
{
copyA2B(genbest[i],bestbestgen);
BESTFEHLER=bestfehler;
}
fehler[index]=Double.MAX_VALUE;
}
//Ich suche 10mal das absolut beste, aber schließe das bereits Gefundene
//für die nachfolgenden Durchgänge aus.
//4. Aus den 10 besten 90 neue rekombinieren
//und dann von vorne
//4a Beste in den Genpool zurück kopieren
for(int i=0;i<genbest.length;i++)
copyA2B(genbest[i],gen[i]);
for(int i=genbest.length;i<gen.length;i++)
{
int inxA = zufall.nextInt(genbest.length);
int inxB = (inxA+1+zufall.nextInt(genbest.length-1))%genbest.length;
for(int k=0;k<gen[i].length;k++)
{
if(zufall.nextBoolean())
{
gen[i][k] = genbest[inxA][k];
}
else
{
gen[i][k] = genbest[inxB][k];
}
}
//MUTATION
if(zufall.nextBoolean())
{
int inxC = zufall.nextInt(gen[i].length);
gen[i][inxC]=1-gen[i][inxC];
}
}
//5. BILD des allerbesten Gens zeigen
BILD = geno2phaeno(bestbestgen);
drawArray(BILD);
fill(0,255,0);
textSize(60);
text("err="+BESTFEHLER,150,150);
}
Code 0-14: LÖSUNG Rorschachsymmetrie Evolution.
LV#6 Donnerstag 14.12.2023
Beginn heute: 09:15Uhr
Organisatorisches:
Die Prüfung findet semesterbegleitend in elektronischer Form am Donnerstag den 18.01.2024 ab 10:00Uhr im Mechatroniklabor, Raum D.2.08 statt.
Vorbereitend gibt es einen Probeetest am Donnerstag den 11.01.2024. Dieser wird direkt im Anschluss gemeinsam ausgewertet. Der Probeetest wird kürzer sein, als die Prüfung und es werden im Probeetest nicht alle Inhalte abgeprüft, die möglich sind.
Themen:
|
1. Überblick zu Fuzzy-Systemen
67_Echtzeitsysteme/13_Fuzzy
2. Die Fuzzy-Größe
67_Echtzeitsysteme/13_Fuzzy/01_Fuzzylogik
3. Das Fuzzy-Ausgangsset
4. Das Fuzzy-Eingangsset
5. Fuzzifizierung von Eingangsgrößen
6. Defuzzifizierung von Ausgangsgrößen
7. Abbilden von Regeln durch ein Fuzzy-System
67_Echtzeitsysteme/13_Fuzzy/03_Uebung9
8. Aufbau eines Fuzzy-Reglers mit Hilfe eines Fuzzy-Systems
9. Implementierung eines Fuzzy-Reglers
10. Anwendung eines Fuzzy-Reglers
siehe Beispiel hier ganz unten:
08_Archiv/02_WS2021_22/05_REGmecha5/01_day_by_day
11. Optimierung eines Fuzzy-Reglers mit Hilfe eines Evolutionären Algorithmus
80_Robuste_Systemintegration/10_EvoFuzzy
80_Robuste_Systemintegration/10_EvoFuzzy/01_Fuzzy/07_Haengependel
12. Übung: Fuzzy-Regler und genetische Optimierung
13. Übung: PD-Regler bei einem nicht linearen System und genetische Optimierung
Tafelbilder:
Bild 0-4: Fuzzy 1
Bild 0-5: Fuzzy 2
Bild 0-6: Fuzzy 3
Bild 0-7: Fuzzy 4
float[][] xTy=
{
{0.0,21.0,0.0},
{0.5,20.0,0.0},
{0.5,0.0,0.0},
{0.5,10.0,0.0},
{0.25,0.0,0.0},
{0.25,10.0,0.0}
};
public void setup()
{
for(int i=0;i<xTy.length;i++)
xTy[i][2] = fuzzyRegler(xTy[i][1],xTy[i][0]);
for(int i=0;i<xTy.length;i++)
{
println("x="+xTy[i][0]+" T="+xTy[i][1]+" => y="+xTy[i][2]);
}
}
public float minimum(float x, float y)
{
if(x<y)
return x;
else
return y;
}
public float fuzzyRegler(float T, float x)
{
float fenster_auf=0.0;
float fenster_zu=0.0;
float zimmer_warm=0.0;
float zimmer_kalt=0.0;
//Fuzzifizierung:
if(T<0.0)
zimmer_kalt = 1.0;
else if(T<20.0)
zimmer_kalt = 1.0-T/20.0;
if(T>20.0)
zimmer_warm = 1.0;
else if(T>0.0)
zimmer_warm = T*20.0;
if(x>1.0)
fenster_auf = 1.0;
else if(x>0.0)
fenster_auf = x;
if(x<0.0)
fenster_zu=1.0;
else if(x<1.0)
fenster_zu=1.0-x;
//Anwendung der Regeln:
float R1 = minimum(fenster_zu,zimmer_warm);
float R2 = minimum(fenster_zu,zimmer_kalt);
float R3 = minimum(fenster_auf,zimmer_warm);
float R4 = minimum(fenster_auf,zimmer_kalt);
//Defuzzifizierung (Schwerpunktberechnung)
return R2*R2/(R1*R1+R2*R2+R3*R3+R4*R4);
}
Code 0-15: Implementierung
x=0.0 T=21.0 => y=0.0 x=0.5 T=20.0 => y=0.0 x=0.5 T=0.0 => y=0.5 x=0.5 T=10.0 => y=0.25 x=0.25 T=0.0 => y=0.9 x=0.25 T=10.0 => y=0.26666668
Code 0-16: Ergebnis
ÜBUNG
Fuzzy102.zip
Übertragen Sie das System von der Tafel auf das verallgemeinerte Fuzzysystem Fuzzy102.
Fuzzy301.zip -- Lösung
Fuzzy und Dynamische Systeme: Regelung des Einachsers mittels Fuzzy
Grundlagen:
30_Informatik3/16_Nuetzliches/03_RungeKutta
78_Processing/06_Snippets/15_Simulation -- Beispielsystem, das in Processing mit dem Runge-Kutta-Verfahren integriert wird.
62_Regelungssysteme/01_day_by_day -- Herleitung Einachser
Umsetzung:
...gemeinsam und als Übung in der LV#7 und Fortsetzung der Themen, Donnerstag 21.12.2023 ab 09:00Uhr.
ergänzend: Übersicht zu Neuronale Netze:
79_Deep_Learning
75_Echtzeit3/01_NeuronaleNetze
ÜBUNG
Ersetzen Sie den Zustandsregler durch einen Fuzzy-Regler gemäß Fuzzy301.
Lösung.
AKTUELL, Stand 12.01.24:
Der E-Test zu Simulations- und Regelungstechnik 5-MT findet ab 10:00Uhr am Donnerstag den 18.01.2024 im Mechatroniklabor D.2.08 statt.
Themenliste / mit Aufgaben zu:
|
Die Gewichtung der Themen in der Prüfung orientiert sich klar daran, wie umfangreich im Unterricht zu den einzelnen Themen etwas erarbeitet, bzw. gerechnet wurde. Zu nur oberflächlich behandelten Teilthemen kann ich höchstens ein paar Fragen stellen. Aber da, wo auch an selber oder an der Tafel gerechnet oder programmiert wurde, kann auch genau das in einer Klausuraufgabe gefordert sein.