kramann.info
© Guido Kramann

Login: Passwort:










Robuste Systemintegration
1 Grundlagen
..1.1 Newton
....1.1.1 LinearSchwinger
....1.1.2 Daempfung
....1.1.4 ODE
....1.1.5 Saaluebung
..1.2 NewtonEuler
....1.2.1 Traegheitsmomente
....1.2.2 Modellgleichungen
....1.2.3 Einfachpendel
..1.3 Scilab
....1.3.1 Erste_Schritte
....1.3.2 Skripte
....1.3.3 Funktionen
..1.4 Laplace
....1.4.1 Eigenwerte
....1.4.2 PT1
..1.5 Regleroptimierung
....1.5.1 Guetefunktion
....1.5.2 Heuristiken
....1.5.3 Scilab
..1.6 Einstellregeln
....1.6.1 Totzeit
....1.6.2 Methode1
....1.6.3 Methode2
....1.6.4 Scilab
..1.7 Zustandsregler
..1.8 Polvorgabe
..1.8 Polvorgabe_alt
..1.9 Beobachter
....1.9.1 Haengependel
..1.10 Daempfungsgrad
..1.11 Processing
....1.11.1 Installation
....1.11.2 Erste_Schritte
....1.11.3 Mechatronik
....1.11.4 Bibliotheken
....1.11.5 Uebung
....1.11.6 Snippets
......1.11.6.1 Dateioperationen
......1.11.6.2 Bilder
......1.11.6.3 GUI
......1.11.6.4 Text
......1.11.6.5 PDF
......1.11.6.8 Maus
......1.11.6.10 Zeit
......1.11.6.13 Animation
......1.11.6.15 Simulation
....1.11.7 Referenzen
..1.12 Breakout
2 Beispiel
3 Beispielloesung
4 Praxis
5 javasci
6 Fehlertoleranz1
7 Reglerentwurf
..7.1 Sprungantwort
..7.2 Messdaten
..7.3 Systemidentifikation
..7.4 Polvorgabe
..7.5 Beobachter
..7.6 Robuster_Entwurf
..7.7 SIL
8 Systementwicklung
9 Arduino
..9.1 Lauflicht
..9.2 Taster
..9.3 Sensor
..9.12 Motor_PWM1
..9.13 Motor_PWM2_seriell
..9.14 Motor_PWM3_analogWrite
..9.15 Scheduler
..9.20 AV
..9.21 Mikrofon
..9.22 Universal
....9.22.1 Laborplatine
....9.22.2 LED_Leiste
....9.22.3 Motortreiber
....9.22.4 Sensoreingaenge
....9.22.5 Taster
....9.22.6 Tests
....9.22.7 Mikrofon
....9.22.8 Lautsprecher
....9.22.9 Fahrgestell
..9.23 Zauberkiste
..9.24 OOP
....9.24.1 Uebungen
..9.25 AVneu
....9.25.1 Tests
..9.26 DA_Wandler
..9.27 CompBoard
....9.27.1 Tastenmatrix
....9.27.2 ASCIIDisplay
..9.28 CTC
..9.29 Tonerzeugung
10 EvoFuzzy
..10.1 Fuzzy
....10.1.1 Fuzzylogik
....10.1.2 FuzzyRegler
....10.1.3 Uebung9
....10.1.5 Softwareentwicklung
......10.1.5.1 AgileSoftwareentwicklung
......10.1.5.2 FuzzyRegler
......10.1.5.3 Uebung
....10.1.6 Umsetzung
......10.1.6.1 FuzzyRegler
......10.1.6.2 Simulation
......10.1.6.3 Optimierung
......10.1.6.4 Uebung
....10.1.7 Haengependel
......10.1.7.1 Haengependel
......10.1.7.2 Simulation
......10.1.7.3 FuzzyRegler
......10.1.7.4 Optimierer
......10.1.7.5 Genetisch
....10.1.8 Information
....10.1.9 Energie
..10.2 Optimierung
....10.2.1 Gradientenverfahren
....10.2.2 Heuristiken
....10.2.3 ModifizierteG
....10.2.4 optim
..10.3 Genalgorithmus
..10.4 NeuronaleNetze
....10.4.1 Neuron
....10.4.2 Backpropagation
....10.4.3 Umsetzung
....10.4.4 Winkelerkennung
..10.5 RiccatiRegler
11 Agentensysteme
12 Simulation
20 Massnahmen
21 Kalmanfilter
..21.1 Vorarbeit
..21.2 Minimalversion
..21.3 Beispiel
30 Dreirad
31 Gleiter
..31.1 Fehlertoleranz
80 Vorlesung_2014_10_01
81 Vorlesung_2014_10_08
82 Vorlesung_2014_10_15
83 Vorlesung_2014_10_22
84 Vorlesung_2014_10_29
kramann.info
© Guido Kramann

Login: Passwort:




Optimierung mittels modifizierter Gradientenverfahren

  • Als Grundlage zu optimierende Funktion wird im folgenden wirder z = x3-4*x+y3-16*y verwendet.
  • Zur Orientierung: Das gesuchte lokale Minimum liegt bei [x,y]=[2/sqrt(3),4/sqrt(3)]=[1,154700538,2,309401077].
  • Der folgende mit Scilab erstellte 3-D-Plot zeigt den Graph dieser Funktion im Bereich -3>x>3, -3>y>3.
fxy.png

Bild 0-1: z = x3-4*x+y3-16*y für -3>x>3, -3>y>3.

  • Zur Erstellung des Graphen wurde folgendes Scilab-Skript verwendet:
  • alpha und theta legen dabei den Blickwinke des Betrachters fest.
function z=f(x,y)
    z = x^3-4*x+y^3-16*y
endfunction

x=-3:0.1:3;
y=x;

fplot3d(x,y,f,alpha=5,theta=31);
 

Code 0-1: Scilab-Skript, um den Graph der Funktion z = x3-4*x+y3-16*y zu erstellen.

  • Wenn es keine Möglichkeit gibt, für den zu optimierenden Sachverhalt eine Gradientenfunktion zu bilden und ausgehend von einem aktuellen Punkt in die Richtung der Koordinatenachsen gesucht wird, um den Punkt mit dem größten Abstieg zu suchen, dann hat man das Problem, dass man mit größerer Näherung an den Zielpunkt die Suchweite sukkzessive verringern muß.
  • Folgende Umsetzung in Scilab löst dieses Problem am Beispiel einer speziellen schon mehrfach verwendeten Funktion z = x3-4*x+y3-16*y.
  • Für jede Suchrichtung wird untersucht, ob es eine Verbesserung bringt, den bisher verwendeten Richtungsvektor in seiner Länge zu halbieren oder zu verdoppeln.
  • Hierdurch werden die Schritte in der Nähe des gescuhten Wertepaares automatisch kürzer:
function z=f(x,y)
    z = x^3-4*x+y^3-16*y
endfunction

//Suchen ausgehend von einem aktuellen Punkt in Richtung [xricht,yricht] nach dem kleinsten Wert
//für die übergebene Funktion funk.
function alfabest=frichtung(x,y,xricht,yricht,funk)
    alfa = [-2.0,-1.0,-0.5,0.5,1.0,2.0];
    wert_best = funk(x+alfa(1)*xricht,y+alfa(1)*yricht);
    alfa_best = alfa(1);

    for i=2:6
        wert = funk(x+alfa(i)*xricht,y+alfa(i)*yricht);
        if wert < wert_best
            wert_best = wert;
            alfa_best = alfa(i);
        end
    end
    alfabest = alfa_best;
endfunction


//Matrix mit Einheitsvektoren U=[ex,ey] geben zu Beginn
//Suchrichtung vor:
U=[[1;0],[0;1]]

z=[4;4];
znull=z;
for i=1:15
    alfax = frichtung(z(1,1),z(2,1),U(1,1),U(2,1),f);
    alfay = frichtung(z(1,1),z(2,1),U(1,2),U(2,2),f);
    //Neuen Punkt in die Richtung setzen, die den größten Abstieg liefert:
    wertx = f(z(1,1)+alfax*U(1,1),z(2,1)+alfax*U(2,1));
    werty = f(z(1,1)+alfay*U(1,2),z(2,1)+alfay*U(2,2));
    if  wertx < werty
        z(1,1) = z(1,1) + alfax*U(1,1);
        z(2,1) = z(2,1) + alfax*U(2,1);
    else
        z(1,1) = z(1,1) + alfay*U(1,2);
        z(2,1) = z(2,1) + alfay*U(2,2);
    end    
    U(:,1) = alfax*U(:,1);
    U(:,2) = alfax*U(:,2);
    z=z
    fehler = abs(z(1)-2/sqrt(3))+abs(z(2)-4/sqrt(3))
end
 

Code 0-1: Beispiel für die Anwendung eines konkreten modifizierten Gradientenverfahrens am Beispiel der Funktion z = x3-4*x+y3-16*y.

  • Eine weitere Verbesserung liefert das Verfahren von Powell.
  • Gegenüber dem vorangegangenen Beispiel wird hier noch geschaut, welches die mittlere Suchrichtung ist und diese als eine der Suchrichtungen gesetzt.
  • Da die Gefahr besteht, dass U dadurch mit der Zeit linearabhängig wird, wird immer derjenige Richtungsvektor behalten, dessen Skalaprodukt mit dem neuen möglichst klein ist.
  • Als mittlere Suchrichtung wird dabei einfach der Differenzvektor zwischen aktueller Position und der Startposition verwendet, da die aktuelle Position die Summe aus allen Richtungen seit Beginn des Algorithmus darstellt.
  • Um diesen Summenvektor der aktuellen Situation anzupassen, wird er auf die Länge des zuletzt verwendeten Vektors gebracht.
  • Gegenüber dem vrangehenden Verfahren, ist der Fehler bei gleicher Interationsanzahl bei nachfolgdendem Verfahren etwas besser:
function z=f(x,y)
    z = x^3-4*x+y^3-16*y
endfunction

function alfabest=frichtung(x,y,xricht,yricht,funk)
    alfa = [-2.0,-1.0,-0.5,0.5,1.0,2.0];
    wert_best = funk(x+alfa(1)*xricht,y+alfa(1)*yricht);
    alfa_best = alfa(1);

    for i=2:6
        wert = funk(x+alfa(i)*xricht,y+alfa(i)*yricht);
        if wert < wert_best
            wert_best = wert;
            alfa_best = alfa(i);
        end
    end
    alfabest = alfa_best;
endfunction

U=[[1;0],[0;1]]

z=[4;4];
znull=z;
for i=1:15
    betrag=1.0;
    alfax = frichtung(z(1,1),z(2,1),U(1,1),U(2,1),f);
    alfay = frichtung(z(1,1),z(2,1),U(1,2),U(2,2),f);
    //Neuen Punkt setzen:
    wertx = f(z(1,1)+alfax*U(1,1),z(2,1)+alfax*U(2,1));
    werty = f(z(1,1)+alfay*U(1,2),z(2,1)+alfay*U(2,2));
    if  wertx < werty
        z(1,1) = z(1,1) + alfax*U(1,1);
        z(2,1) = z(2,1) + alfax*U(2,1);
        betrag = norm(alfax*U(:,1));
    else
        z(1,1) = z(1,1) + alfay*U(1,2);
        z(2,1) = z(2,1) + alfay*U(2,2);
        betrag = norm(alfay*U(:,2));
    end    
    U(:,1) = alfax*U(:,1);
    U(:,2) = alfax*U(:,2);

    //Konjugierte Richtung einsetzen:
    if  wertx < werty
        if abs((z-znull)'*U(:,1))<abs((z-znull)'*U(:,2))
            U(:,2)=U(:,1);
        end
        U(:,1) = betrag*(z-znull)/norm(z-znull);
    end        
    
    z=z
    fehler = abs(z(1)-2/sqrt(3))+abs(z(2)-4/sqrt(3))
end
 

Code 0-2: Implementierung eines modifizierten Gradientenverfahrens unter Verwendung konjugierter Richtungsvektoren nach Powell.