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:

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)



zu 2.: Laplacetransformation


zu 3.: Auslegungsmethoden nach Ziegler und Nichols



zu 4. Eigenwertberechnung
s. Tafel im Unterricht
zu 5. Polvorgabe

zu 6. Zustandsregler

Ü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:
|
|



Allgemeines zu Optimierungsverfahren

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

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
Quelle: https://de.wikipedia.org/wiki/Heuristik, Aufruf 23.11.2023.


4. Gradientenverfahren


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:
|


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

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

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.

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

2. Die Fuzzy-Größe

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

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:

11. Optimierung eines Fuzzy-Reglers mit Hilfe eines Evolutionären Algorithmus


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

Übertragen Sie das System von der Tafel auf das verallgemeinerte Fuzzysystem Fuzzy102.

Fuzzy und Dynamische Systeme: Regelung des Einachsers mittels Fuzzy
Grundlagen:



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:


ÜBUNG


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.