kramann.info
© Guido Kramann

Login: Passwort:










kramann.info
© Guido Kramann

Login: Passwort:




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

  • Die vorliegende Seite stellt den Einstiegspunkt für diese Lehrveranstaltung dar und verzeichnet chronologisch die behandelten Inhalte.
  • Aber ein großer Teil der Inhalte findet sich nicht direkt hier, sondern die Seite hier verlinkt auf andere Bereiche von kramann.info.
  • Die Prüfung findet Semester begleitend in elektronischer Form statt (E-Test).

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

  1. Rückblick
  2. Statische Optimierung: Die Methode der Kleinsten Quadrate
  3. Dynamische Optimierung: Das Gradientenverfahren
  4. Evolutionäre Algorithmen
  5. Fuzzy-Logik und Fuzzy-Regler
  6. Reglerauslegung für nicht lineare dynamische Systeme

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

  1. Scilab (ode, csim)
  2. Laplacetransformation
  3. Auslegungsmethoden nach Ziegler und Nichols
  4. Eigenwertberechnung
  5. Polvorgabe
  6. Zustandsregler

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.

  • Bilden Sie das Gesamtübertragungsverhalten des offenen und des geschlossenen Regelkreises.
  • Transformieren Sie beide danach in den Zeitbereich.
  • Welcher Typ von Regler liegt hier vor?

$ 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)

  • Übertragen Sie R(s) und G(s) mit Hilfe von syslin() nach Scilab.
  • Ergänzten Sie Ihr Scilab-Skript so, dass aus R(s) und G(s) das Übertragungsverhalten H(s) des offenen und des geschlossenen Regelkreises Q(s) gebildet werden.

2b)

  • Vervollständigen Sie zwei Varianten des Scilab-Skripts aus 2a) so, dass ein
  • Einheitssprung auf den offenen und den geschlossenen Regelkreis simuliert wird.

2c)

Verdeutlichen Sie sich durch Zeichnen eines Blockschaltbildes:

  • Was ist jeweils Ein- bzw. Ausgang beim offenen und geschlossenen Regelkreis?


  1. Lineare Regression
  2. Kleinste Quadrate Methode
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
  2. Beispiel zur Kleinsten Quadrate Methode mit einer transzendenten Funktion
  3. Heuristiken
  4. Gradientenverfahren

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

Plot der 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.

Plot dazu.

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:

  1. Wiederholung Invertierendes Pendel
  2. Wiederholung Zustandsregler Invertierendes Pendel
  3. Formulierung einer Fehlerfunktion für die Beurteilung der Regelung des Invertierenden Pendels
  4. Optimierung eines Reglers für das invertierende Pendel mittels Gradientenverfahren
  5. Übung: Implementierung Parameterstudie als Alternative Auslegungsmethode
  6. Zustandsregelung des Gesamtzustandes / Hinzunahme der Position in x-Richtung
  7. Übung: Gradientenverfahren anpassen um Regelparameter zur Ausregelung des Gesamtzustandes zu finden
  8. Einführung in Evolutionäre Algorithmen
  9. Genetische Optimierung zum Erraten eines Binärpatterns
  10. Genetische Optimierung des Reglers für das Invertierende Pendel
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
  2. Genetische Optimierung zum Erraten eines Binärpatterns
  3. Genetische Optimierung des Reglers für das Invertierende Pendel
  4. Je nach Zeit: Beginn mit Fuzzy-Logik (nächstes Thema)

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.

  1. Überlegen, welche Softwarekomponenten benötigt werden.
  2. Etappenweise Umsetzung der einzelnen Komponenten.
  3. Test des Gesamtsystems.
  4. Verallgemeinerung in Hinblick auf die Übertragbarkeit auf andere Probleme.
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
Screenshot nach einem Optimierungslauf.

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

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:

Fuzzy 1

Bild 0-4: Fuzzy 1

Fuzzy 2

Bild 0-5: Fuzzy 2

Fuzzy 3

Bild 0-6: Fuzzy 3

Fuzzy 4

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:

  1. Methode der kleinsten Quadrate
  2. Der Begriff der Heuristik im Zusammenhang mit Optimierungsverfahren
  3. Modifiziertes Gradientenverfahren
  4. Evolutionäre Algorithmen
  5. Fuzzylogik, Fuzzy-Systeme und Fuzzy-Regler
  6. Neuronale Netze und Lernmethoden (überwachtes, bestärkendes und unüberwachtes Lernen)
  7. Auslegung eines Zustandsreglers mittels Polvorgabe (Wiederholung aus RT1)
  8. Skripte mit Scilab schreiben (Funktionen und Variablen)
  9. Sketche mit Processing (Java) schreiben (setup- draw-Methode, Klassen)

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.