Mathematik: Optimale Steuerung bzw. Neuronales Netz mit variablen Gewichten - ein Beispiel
Released by matroid on Mi. 06. Januar 2021 19:41:41 [Statistics]
Written by Delastelle - 311 x read [Outline] Printable version Printer-friendly version -  Choose language   
Mathematik

\(\begingroup\) Im Artikel berechne ich die Lösung eines Problems der Optimalen Steuerung. Die Steuerungen u kann man auch als Gewichte w eines Neuronalen Netzes mit variablen Gewichten sehen. Gelöst wird das Achtproblem - hier mit 4 gewöhnlichen Differentialgleichungen. Zur Lösung werden Fortran und Matlab/Octave eingesetzt.

Problembeschreibung

Es geht um das Lernen (Approximieren) einer Kurve. Es werden dabei Anfangswertprobleme gelöst. Die rechten Seiten der Differentialgleichungen sehen so aus: dx(1)= (-x(1)+atan(u(1)*x(1)+u(2)*x(2))) dx(2)= (-x(2)+atan(u(3)*x(1)+u(4)*x(2))) pi = 3.1415926535d0 pi_12 = pi * 12.0d0 d1 = 1.0d0/2.0d0+(9.0d0 / 20.0d0) * sin(2.0d0 * t) d2 = 1.0d0+(9.0d0 / 10.0d0) * sin(t) Für eine gewisse Zeit (Einschwingzeit bis t1) gibt es keine Forderung dann soll eine Acht im ersten Quadranten gelernt werden. Die 3.Differentialgleichung sammelt die Summe der Quadrate der Abweichungen von der Acht ein. if (t.lt.t1) then dx(3) = 0.0d0 else dx(3) = ( (x(1) - d1) * (x(1) - d1) * + (x(2) - d2) * (x(2) - d2) ) endif Die 4 Differentialgleichung sammelt die Quadrate der Steuerungen ein. Dies dient der Stabilisierung des Problems. Es soll die Acht gelernt werden, aber mit wenig Energie der Steuerungen. dx(4) = dgl_alpha * (u(1)*u(1)+u(2)*u(2)+u(3)*u(3)+u(4)*u(4)) Die Startwerte der Anfangswertprobleme sind 1, 1, 0, 0. Also 1; 1 für das Lernen der Acht bzw. 0 und 0 für die Aufsummierung der Fehler. Die Zielfunktion ist der Zustand x(3) + x(4) am Ende des Integrationsintervalls, also die Summe aus den Abweichungen von der Acht plus der Energie der Steuerungen. Die Steuerungen u(1) bis u(4) sind unterteilt in 50 Intervalle in t. Die Steuerungen werden als stückweise konstant oder linear zwischen den Intervallen gewählt. Zu Beginn der Optimierung sind die Steuerungen zufällig gewählt oder gleich 0. Bei mir immer 0 zu Beginn. alpha für Differentialgleichung 4 wurde immer auf 0,01 gesetzt. Die Zeit t läuft von 0 bis 12 Pi.

Lösung in Fortran

Steuerungen u1,u2,u3,u4 am Ende der Rechnung
Zustand x1, x2, x3, x4 am Ende der Rechnung Für nichtlineare Optimierungsprobleme wie das gegebene kann man SQP-Verfahren einsetzen. (SQP - Sequentiell Quadratic Programming). Weiterhin kann man zum Lösen der Differentialgleichungen ode45 einsetzen - ein Löser mit variabler Schrittweite und Fehlerkontrolle. Bei dem vorliegenden Programm wurde eine ältere Routine OPRQP zur Lösung des Nichtlinearen Optimierungsproblems verwendet. Weiterhin wurde ein Runge-Kutta-Verfahren 4.Ordnung zur Integration verwendet. Während der Rechnung werden die Integrationsintervalle verkleinert. Die Zustände x wurden immer auch an Gitterpunkten (z.B. 51 pro Differentialgleichung) berechnet und gespeichert. Zu Beginn sind die Steuerungen 0. Zuerst rechnet das Programm 200 Iterationen mit 50 Intervallen (ndiskret = 51, inter = 1). Dann 200 Iterationen mit 100 Intervallen (ndiskret = 51, inter = 2). Dann 200 Iterationen mit 200 Intervallen (ndiskret = 51, inter = 4). Zuletzt 10 Iterationen mit 600 Intervallen (ndiskret = 51, inter = 12). Die Rechenzeit beträgt ca. 15 Sekunden auf einem 4 GHz Laptop. Der Fehler beträgt am Ende der Rechnung etwa 0,31. Die Steuerungen sind jetzt an ndisket Stellen gegeben. Für die Rechnung wurden sie linear interpoliert. Das Programm zur Rechnung "kreishochdi2.for" findet sich in meinem Matheplanet-Notizbuch. Wie komme ich auf den Dateinamen? Es geht um das Kreis- und Achtproblem und es wird im schnellsten Programm "hochdiskretisiert".

Lösung in Matlab/Octave

Bild 1: Steuerungen u1 bis u4, Bild 2: x3, Bild 3: Zustand x1 und Bild 4: Zustand x2 nach 100 Iterationen Es wird dasselbe Problem wie eben gelöst. Das nichtlineare Problem wird mit einem einfachen Gradientenverfahren gelöst. (Ich hatte zeitweise auch mit einem SQP-Verfahren gerechnet, aber momentan kein Matlab zur Verfügung. In Octave sind die Aufrufe für das SQP-Verfahren anders.) Diesmal wird ode45 in Octave genutzt. Zu Beginn sind die Steuerungen 0. Es werden diesmal 100 Iterationen ausgeführt. Die Rechenzeit beträgt 27257 Sekunden auf einem 4 GHz Laptop. Der Funktionswert beträgt am Ende 0,62 und würde bei weiterer Rechnung noch etwas fallen. Das Programm "Acht2.m" und die Hilfsprogramme finden sich in meinem Matheplanet-Notizbuch. Mit SQP-Verfahren und ode45 ist das Achtproblem in Matlab lösbar - leider ziemlich langsam (auch beim Gradientenverfahren und ode45 in Octave).

Ergänzungen

Steuerungen u am Ende der Rechnung (ndiskret = 1501)
Zustand x am Ende der Rechnung (ndiskret = 1501) (a) In Fortran habe ich auch einmal mit ndiskret = 1501 und inter = 1 gerechnet. alpha war wie immer 0,01. Siehe Bilder. (b) Unter Octave habe ich mit kleinerem ndiskret experimentiert. Für n = 11 (bzw. ndiskret) und n = 21 findet man keine vernünftige Approximation der Acht. (c) Das Achtproblem ist mit konstanten u's nicht zu lösen. Es gibt einen Kreuzungspunkt. Dort müssen die rechten Seiten der zugehörigen Differentialgleichungen verschiedene Werte haben. (d) Wenn man zu einer "atan()"-Differentialgleichung am Ende noch einen Input addiert, hat man ein Input-Neuron eines Neuronalen Netzes mit variablen Gewichten.
(e) Als Aktivierungsfunktion des Neuronalen Netzes wurde atan gewählt - eine sigmoide (s-Förmige) Funktion (siehe Bild). (f) Ein Kurzvideo zum Achtproblem findet sich auch in meinem Matheplanet-Notizbuch.

Ende

In meinem Matheplanet-Notizbuch finden sich ein Fortran-Programm und mehrere Matlab/Octave-Files und extra auch ein Kurzvideo zur "Acht". fav.php?uname=Delastelle Viele Grüße Ronald
\(\endgroup\)
Get link to this article Get link to this article  Printable version Printer-friendly version -  Choose language     Kommentare zeigen Comments  
pdfFür diesen Artikel gibt es keine pdf-Datei


Arbeitsgruppe Alexandria Dieser Artikel ist im Verzeichnis der Arbeitsgruppe Alexandria eingetragen:
: Mathematik :: automatisch eingefügt und unbearbeitet :: Differentialgleichung :: Optimierung :: Neuronales Netz :
Optimale Steuerung bzw. Neuronales Netz mit variablen Gewichten - ein Beispiel [von Dela  
Im Artikel berechne ich die Lösung eines Problems der Optimalen Steuerung. Die Steuerungen u kann man auch als Gewichte w eines Neuronalen Netzes mit variablen Gewichten sehen. Gelöst wird das Achtproblem - hier mit 4 gewöhnlichen Differentialgleichungen. Zur Lösung werden Fortran und Matlab/O
[Die Arbeitsgruppe Alexandria katalogisiert die Artikel auf dem Matheplaneten]

 
 
Aufrufzähler 311
 
Aufrufstatistik des Artikels
Insgesamt 12 externe Seitenaufrufe zwischen 2021.02 und 2022.10 [Anzeigen]
DomainAnzahlProz
https://google.com541.7%41.7 %
https://google.de216.7%16.7 %
https://duckduckgo.com216.7%16.7 %
https://www.ecosia.org18.3%8.3 %
https://www.startpage.com18.3%8.3 %
https://www.bing.com18.3%8.3 %

Häufige Aufrufer in früheren Monaten
Insgesamt 4 häufige Aufrufer [Anzeigen]
DatumAufrufer-URL
2021-2022 (4x)https://google.com/

[Top of page]

"Mathematik: Optimale Steuerung bzw. Neuronales Netz mit variablen Gewichten - ein Beispiel" | 1 Comment
The authors of the comments are responsible for the content.

Re: Optimale Steuerung bzw. Neuronales Netz mit variablen Gewichten - ein Beispiel
von: Delastelle am: Mi. 19. Oktober 2022 17:26:01
\(\begingroup\)Hallo, https://www.matheplanet.de/matheplanet/nuke/html/uploads/b/15578_SQP_ode23_n50_inter12_iter50_dglalpha0k01_ff0k06_Zeit11418Sekunden.png das Achtproblem kann auch mit SQP-Vefahren in Octave gelöst werden. Im Bild 4 Steuerungen Blau, die Zielfunktion x3 (x3+x4 ergibt gesamte Zielfunktion), x1 und x2 (grün). \showon \sourceon Octave function [f,g] = acht4(xopt2,knoten,ya) global schranke knoten ya options n nzk % --------------------------------------------------------------- % Loesung eines Optimalsteuerungsproblems % Spline-Problems % % In diesem File wird die zu minimierende Funktion f und die % Nebenbedingungen g definiert. % Die Nebenbedingungen sind allsamt Gleichungsnebenbedingungen. % --------------------------------------------------------------- % Eingabe - Parameter % xopt : Vektor der zu optimierenden Variablen. In den letzten n % Komponenten sind die n Variablen der zu bestimmenden Steuerung % an den ersten n Knoten abgelegt. % knoten : Das diskretisierte Integrationsintervall % ya : Anfangswerte fuer alle Differentialgleichungen % --------------------------------------------------------------- % Ausgabe - Parameter % f : f(u), wobei f die zu minimierende skalare Funktion ist. % g : g(u), wobei g die vektorwertige Funktion der Nebenbedingungen ist. % --------------------------------------------------------------- xopt = reshape(xopt2,n,4); % generelle Abkuerzungen definieren N1 = size(knoten,1); % n+1 = Anzahl der Knoten N = N1 - 1; % n = Anzahl der Diskretisierungsintervalle nopt = 4 * size(xopt,1); % Anzahl der zu bestimmenden Variablen u = zeros(N,4); for i = 1:4 %u(i) = xopt(nopt-N+1:nopt,i); % In den letzten n Komponenten von xopt ist die u(:,i) = xopt(1:N,i); end % Steuerung u an den Knoten gespeichert nx = size(ya,1); % Anzahl der Differentialgleichungen % Optionen fuer den DGL-Loeser: options = odeset('AbsTol',1e-3,'Refine',1); % options = odeset; % ====================================================================== % Ab hier muss die Datei an die konkrete Aufgabenstellung angepasst werden. % ====================================================================== % Abkuerzungen fuer die konkrete Aufgabe definieren parameter = []; % zu optimierende Anfangswerte aus dem Vektor xopt % in den Vektor der Anfangswerte zum Loesen der DGL uebertragen. % Integration der Zustandsgroessen: [tt,xdgl] = getyplot('dglacht4',options,knoten,ya,u); % Definiton von f, der zu minimierenden Funktion. % nn = 2600; si = size(xdgl,1); % f = xdgl(N1,3)+xdgl(N1,4); f = xdgl(si,3)+xdgl(si,4); % Definition der Nebenbedingungen in Form der Funktion g: % Interpolationsbedingungen am Ende: n = N1-1; for i = 1:4 %(i-1)*2*n+1:(i-1)*2*n+n %(i-1)*2*n+n+1:i*2*n g((i-1)*2*n+1:(i-1)*2*n+n) = u(1:n,i) - schranke; g((i-1)*2*n+n+1:i*2*n) = -u(1:n,i) - schranke; end return; \sourceoff \sourceon Octave function dy = dglacht4(t,y,flag,u,parameter) global dglalpha fak t1 options uu; % Loesung eines Optimalsteuerungsproblems % kubisches Spline-Problem % % In diesem File werden die Differentialgleichungen fuer den Integrationsschritt % definiert. % ------------------------------------------------------------------------------- % Eingabe - Parameter: % t : unabhaengige Variable (Zeit) % y : abhaengige Variable % flag : wird in diesem Fall nicht benutzt. Mittels "flag" kann die Ausgabe der % Funktion an den Integrator gesteuert werden. % u : Parameter: Steuerung, diese ist zwischen zwei Knoten konstant. % parameter: nicht benutzt % ------------------------------------------------------------------------------- % Rueckgabe-Parameter: % dy : die rechte Seite der Differentialgleichung y' = f(t,y) % ------------------------------------------------------------------- u = uu; dy = zeros(4,1); % erzeugt einen Spaltenvektor mit lauter Nullen. dy(1) = fak*(-y(1)+2*atan(u(1)*y(1)+u(2)*y(2))); dy(2) = fak*(-y(2)+2*atan(u(3)*y(1)+u(4)*y(2))); if (t < t1) dy(3) = 0; else d1 = 1/2 + 9 / 20 * sin(fak*2*t); d2 = 1 + 9 / 10 * sin(fak*t); dy(3) = fak* ((y(1) - d1) * (y(1) - d1) + (y(2) - d2) * (y(2) - d2)); end dy(4) = dglalpha * ( u(1)*u(1)+u(2)*u(2)+u(3)*u(3)+u(4)*u(4) ); return \sourceoff \sourceon Octave function [t,y] = getyplot(dglname,options,knoten,ya,u) global uu nzk; % --------------------------------------------------------------- % Loesung eines Optimalsteuerungsproblems % % In diesem File wird die Trajektorie intervallweise integeriert. % Die Trajektorie wird an nzk+1 Stellen in [knoten(j),knoten(j+1)] bestimmt. % Dies ist fuer nzk>1 zum Zeichnen der Trajektorie nuetzlich. % Dieses File ist nicht an ein spezielles Beispiel gebunden! % --------------------------------------------------------------- % Eingabe - Parameter % dglname : Name der Datei, in denen die Differentialgleichungen definiert sind. % options : Optionen fuer den DGL-Loeser, die mit odeset gesetzt werden koennen. % knoten: Die einzelnen Diskretisierungspunkte % ya : (ndgl)-Vektor der Anfangswerte % u : (n+1)-Vektor. u_i Steuerung fuer das Intervall [t_i,t_{i+1}] % nzk: Anzahl der Zwischenknoten im Intervall [knoten_j, knoten_{j+1}[ % parameter : enthaelt Parameter, die unveraendert an das odefile % weitergegeben werden. % --------------------------------------------------------------- % Rueckgabe - Parameter: % t : (n*nzk+1) Vektor der Argumente zu y. % y : (n*nzk+1) x ndgl Matrix. y_{j k} gibt den Zustand y_k(t_j) an. % --------------------------------------------------------------- ndgl = size(ya,1); n = size(knoten,1)-1; t = []; y = []; options.AbsTol = 1e-3; % options = odeset % nzk = 12; % eventuell verringern 51 for j=1:n uu = u(j,:); % das j-te Intervall wird definiert. tspan = [knoten(j):(knoten(j+1)-knoten(j))/nzk:knoten(j+1)]; % der Wert von y(t_{j+1}) wird bestimmt % [tj1,yj1] = ode23(dglname,tspan,ya,options,u(j,:),parameter); [tj1,yj1] = ode23(dglname,tspan,ya,options); y = cat(1,y,yj1); t = cat(1,t,tj1); ya = yj1(nzk+1,:)'; end; \sourceoff \sourceon Octave function [xopt] = startacht2(xopt) global dglalpha fak t1 schranke knoten ya options n nzk % Loesung eines Optimalsteuerungsproblems % Acht-Problem % 53 -> acht4 // 66 getyplot % Dies ist die Startdatei fuer das Optimalsteuerungsproblem "acht". % Der Vektor xopt ist wie folgt belegt: % xopt =[ u(t0), u(t1),...,u(tf)] % % Stoppuhr tic; % Vorgaben festlegen n = 50; % Anzahl der Diskretisierungsintervalle n1 = n+1; % Anzahl der Diskretisierungspunkte nx = 4; % Anzahl der Zustandsgroessen hurz = n*nx; inter = 12; % Anzahl Zwischenintegrationsintervalle nzk = inter; maxiter = 30000; % Max Anzahl von f-Auswertungen fak = 12*pi; % Vorfaktor Dgl dglalpha = 0.01; t1 = 1/6; % Startzeit der Fehlerfunktion schranke = 10; % Nebenbedingung: |u| <= schranke %options = zeros(13,1); % Diskretisierung festlegen; knoten = [0:1/n:1]'; % Variablen fuer die Minimierungsroutine initialisieren % (u besteht aus Anfangszustaenden und diskreter Steuerung) % (nur wenn keine Anfangsschaetzungen vorgegeben wurden) if (nargin < 1) nxopt = n; xopt = zeros(nxopt,4); else nxopt = size(xopt,1); end; % Die festen Anfangszustaende bestimmen ya = zeros(nx,1); ya(1) = 1; ya(2)= 1; ya(3) = 0; ya(4) = 0; % Minimierungsroutine aufrufen xopt2 = reshape(xopt,hurz,1); MAXITER = 100; for j = 1:1 j [xopt3,ff,info,iter,nf,lambda] = sqp(xopt2,'acht4',[],[],[],[],MAXITER); lala = toc; fprintf('\nIter = %i ff = %f \n',iter,ff) fprintf(' Zeit = %f \n',lala) % Die optimale Steuerung aus xopt explizit benennen. xopt = reshape(xopt3,n,4); for i = 1:4 u(:,i) = xopt(1:n,i); end % options = odeset; options = odeset('AbsTol',1e-3,'Refine',1); [t,xdgl] = getyplot('dglacht4',options,knoten,ya,u); yy = xdgl; si = size(xdgl,1); subplot(2,2,1) hold off mi = min(min(u(:,:))); ma = max(max(u(:,:))); abstand = floor(abs(ma)+abs(mi))+1; plot(u(:,1)+1.5*abstand,'b') hold on plot(u(:,2)+0.5*abstand,'b') plot(u(:,3)-0.5*abstand,'b') plot(u(:,4)-1.5*abstand,'b') grid on axis([1 n -2.5*abstand 2.5*abstand]) subplot(2,2,2) plot(abs(yy(:,3)),'r'); grid on axis([1 si 0 1.1*max(abs(yy(:,3)))]) % 1 n % axis([1 2600 0 56]); subplot(2,2,3) plot(yy(:,1),'g') grid on axis([1 si min(yy(:,1)) max(yy(:,1))]) subplot(2,2,4) plot(yy(:,2),'g') grid on axis([1 si min(yy(:,2)) max(yy(:,2))]) drawnow end toc end \sourceoff \showoff Viele Grüße Ronald \(\endgroup\)
 

 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2022 by Matroids Matheplanet
This web site was originally made with PHP-Nuke, a former web portal system written in PHP that seems no longer to be maintained nor supported. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]