Die Mathe-Redaktion - 17.10.2019 12:57 - Registrieren/Login
Auswahl
ListenpunktHome
ListenpunktAktuell und Interessant ai
ListenpunktArtikelübersicht/-suche
ListenpunktAlle Links / Mathe-Links
ListenpunktFach- & Sachbücher
ListenpunktMitglieder / Karte / Top 15
ListenpunktRegistrieren/Login
ListenpunktArbeitsgruppen
Listenpunkt? im neuen Schwätz
ListenpunktWerde Mathe-Millionär!
ListenpunktFormeleditor fedgeo
Schwarzes Brett
Aktion im Forum
Suche
Stichwortsuche in Artikeln und Links von Matheplanet
Suchen im Forum
Suchtipps

Bücher
Englische Bücher
Software
Suchbegriffe:
Mathematik bei amazon
Naturwissenschaft & Technik
In Partnerschaft mit Amazon.de
Kontakt
Mail an Matroid
[Keine Übungsaufgaben!]
Impressum

Bitte beachten Sie unsere Nutzungsbedingungen, die Distanzierung, unsere Datenschutzerklärung und
die Forumregeln.

Sie können Mitglied werden. Mitglieder können den Matheplanet-Newsletter bestellen, der etwa alle 2 Monate erscheint.

Der Newsletter Okt. 2017

Für Mitglieder
Mathematisch für Anfänger
Wer ist Online
Aktuell sind 735 Gäste und 17 Mitglieder online.

Sie können Mitglied werden:
Klick hier.

Über Matheplanet
 
Zum letzten Themenfilter: Themenfilter:
Matroids Matheplanet Forum Index
Moderiert von mire2 gaussmath
Mathematische Software & Apps » Matlab » Ausführen von Code Optimierungsalgorithmus
Druckversion
Druckversion
Antworten
Antworten
Autor
Universität/Hochschule Ausführen von Code Optimierungsalgorithmus
Aliaju
Junior Letzter Besuch: im letzten Monat
Dabei seit: 25.04.2019
Mitteilungen: 13
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2019-09-17


Hallo,

zur Minimierung der Rosenbrockfunktion $F(x,y)=100(y-x^2)^2+(^-x)^2$ mit Startpunkt $x=(1.2,1.2)$ mit Gradientenverfahren gibt es unten stehenden Code.
Da ich immer mit anderen Programmiersprachen programmiere und nie mit Matlab weiß ich gar nicht wie ich den Code ausführen kann. Z.B. weiß ich auch nicht, wie ich eine Funktion mit zwei Variablen eintippen kann und deren Gradienten. Ich hab schon mehrere Sachen probiert und teilweise haben Sachen funktioniert, wie die Erkennung einer Funktion, die zwei Variablen hat. Aber insgesamt (mit dem Gradienten zb) und der der Ausführung des Codes hat es leider gar nicht funktioniert.

Außerdem sagt mir mein Programm auch zb bei dem Code der function B_k, dass s_k' wegen des Simikolons ein "invalid character" sei. Vielleicht brauche ich den Teil des Codes aber auch gar nicht, um das Gradientenverfahren auf die Rosenbrockfunktion anzuwenden?


Kann mir bitte jemand weiterhelfen und mir
1. sagen, was ich beispielsweise in die Kommandozeile tippen kann, um das Programm auszuführen?

und 2. sagen, wie ich das Problem mit dem Zeichen" ' " lösen kann, falls ich den Teil des Codes benötige?


Ich würde den Code echt gerne ausführen... :(

Matlab
function [min, xhist, steplength] = ... descentdirect(f, grad_f, hessian_f, x0, maxit, tol, dir, line) 
%-------------------------------------------------------------------------- 
% General descent direction method 
%-------------------------------------------------------------------------- 
% f: object function % grad_f: gradient of f % hessian_f: hessian matrix of f 
%-------------------------------------------------------------------------- 
%-------------------------------------------------------------------------- 
% Parameter 
%-------------------------------------------------------------------------- 
c_1 = 10^-4; c_2 = 0.9; 
%c_1 = 0.4; c_2 = 0.6; 
alpha_max = 16; 
%-------------------------------------------------------------------------- 
% Initialization 
%-------------------------------------------------------------------------- 
i = 1; x_k = x0; stop = 1; xsize = length(x0); B_k = eye(xsize); 
xhist = zeros(xsize,maxit); xhist(:,i) = x_k; steplength = zeros(maxit,1); 
%-------------------------------------------------------------------------- while stop && i < maxit 
%-------------------------------------------------------------------- 
% Search Direction 
%-------------------------------------------------------------------- 
if (dir == 1) 
% Steepest descent direction 
p_k = steepdir(grad_f,x_k); 
elseif (dir == 2)  % Newton’s direction p_k = newtondir(grad_f,hessian_f,x_k); 
elseif (dir == 3) % Quasi-Newton direction p_k = qnewtondir(grad_f,B_k,x_k); 
end 
%-------------------------------------------------------------------- 
% Step Length 
%-------------------------------------------------------------------- 
if (line == 1) 
% No stepsize control alpha = 1; elseif (line == 2) 
% Wolfe condition alpha = linesearch(f, grad_f, p_k, x_k, c_1, c_2, alpha_max); 
end steplength(i) = alpha; 
%-------------------------------------------------------------------- 
% Update 
%-------------------------------------------------------------------- 
x_old = x_k; 
x_k = x_k + alpha * p_k; i = i + 1; 
xhist(:,i) = x_k; 
if (norm(grad_f(x_k)) < tol) || (norm(x_k - x_old) < 1e-12) 
stop = 0; 
end 
%-------------------------------------------------------------------- 
% Updating Quasi-Newton matrix 
%-------------------------------------------------------------------- 
if (dir == 3) 
% Quasi-Newton direction B_k = bfgs(x_k,x_old,B_k,grad_f); 
end 
end 
min = x_k; 
steplength = steplength(1:i); 
xhist = xhist(:,1:i); 
Matlab
%--------------------------------------------------------------------
function p_k = steepdir(grad_f,x_k)
% Steepest descent direction
p_k = - feval(grad_f, x_k);
%--------------------------------------------------------------------
function p_k = newtondir(grad_f,hessian_f,x_k)
% Newton’s direction
grad_f_k = feval(grad_f, x_k);
hessian_f_k = feval(hessian_f, x_k);
p_k = - hessian_f_k\grad_f_k;
%--------------------------------------------------------------------
function p_k = qnewtondir(grad_f,B_k,x_k)
% Quasi-Newton’s direction
grad_f_k = feval(grad_f, x_k);
p_k = -B_k\grad_f_k;
%--------------------------------------------------------------------
function B_k = bfgs(x_k,x_old,B_k,grad_f)
% BFGS
s_k = x_k - x_old;
y_k = feval(grad_f, x_k) - feval(grad_f, x_old);
if y_k’ * s_k <= 0
return
end
B_k = B_k - (B_k * s_k * s_k’ * B_k) / (s_k’ * B_k * s_k) + ...
(y_k* y_k’) / (y_k’ * s_k);
%--------------------------------------------------------------------
function B_k = sr1(x_k,x_old,B_k,grad_f)
% SR1
s_k = x_k - x_old;
y_k = feval(grad_f, x_k) - feval(grad_f, x_old);
if y_k’ * s_k <= 0
return
end
B_k = B_k + ((y_k - B_k * s_k) * (y_k - B_k *s_k)) / ...
(y_k - B_k * s_k)’*s_k;
 
 




  Profil  Quote  Link auf diesen Beitrag Link
majoka
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 25.02.2014
Mitteilungen: 774
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2019-09-17


Du kannst den Code in etwa so aufrufen
Matlab
clear all
b = 100;
a = 1;
F = @(x) (a-x(1)).^2 + b*(x(2)-x(1).^2).^2;
 
x0 = [2.2;2.2];
 
grad_F = @(x) [2*(a-x(1))*(-1) + 2*b*(x(2)-x(1).^2)*(-2*x(1));
                2*b*(x(2)-x(1).^2)];
 
 
%  [min, xhist, steplength] = descentdirect(f, grad_f, hessian_f, x0, maxit, tol, dir, line) 
[min, xhist, steplength] = descentdirect(F, grad_F, [], x0, 100000, 1e-15, 3, 1)
min

Ich erhalte damit das Ergebnis von der Wiki-Seite.

Allerdings scheinen in dem Code aus dem Themenstart noch Formatierungsfehler zu sein.

(Speichere das folgende in ein File mit dem Namen "descentdirect.m" ab.)
Matlab
function [min, xhist, steplength] = descentdirect(f, grad_f, hessian_f, x0, maxit, tol, dir, line)
%--------------------------------------------------------------------------
% General descent direction method
%--------------------------------------------------------------------------
% f: object function % grad_f: gradient of f % hessian_f: hessian matrix of f
%--------------------------------------------------------------------------
%--------------------------------------------------------------------------
% Parameter
%--------------------------------------------------------------------------
c_1 = 10^-4; c_2 = 0.9;
%c_1 = 0.4; c_2 = 0.6;
alpha_max = 16;
%--------------------------------------------------------------------------
% Initialization
%--------------------------------------------------------------------------
i = 1; x_k = x0; stop = 1; xsize = length(x0); B_k = eye(xsize);
xhist = zeros(xsize,maxit); xhist(:,i) = x_k; steplength = zeros(maxit,1);
%--------------------------------------------------------------------------
while stop && i < maxit
    %--------------------------------------------------------------------
    % Search Direction
    %--------------------------------------------------------------------
    if (dir == 1)
        % Steepest descent direction
        p_k = steepdir(grad_f,x_k);
    elseif (dir == 2)  % Newton’s direction
        p_k = newtondir(grad_f,hessian_f,x_k);
    elseif (dir == 3) % Quasi-Newton direction
        p_k = qnewtondir(grad_f,B_k,x_k);
    end
    %--------------------------------------------------------------------
    % Step Length
    %--------------------------------------------------------------------
    if (line == 1)
        % No stepsize control
        alpha = 1;
    elseif (line == 2)
        % Wolfe condition
        alpha = linesearch(f, grad_f, p_k, x_k, c_1, c_2, alpha_max);
    end
    steplength(i) = alpha;
    %--------------------------------------------------------------------
    % Update
    %--------------------------------------------------------------------
    x_old = x_k;
    x_k = x_k + alpha * p_k; i = i + 1;
    xhist(:,i) = x_k;
    if (norm(grad_f(x_k)) < tol) || (norm(x_k - x_old) < 1e-12)
        stop = 0;
    end
    %--------------------------------------------------------------------
    % Updating Quasi-Newton matrix
    %--------------------------------------------------------------------
    if (dir == 3)
        % Quasi-Newton direction
        B_k = bfgs(x_k,x_old,B_k,grad_f);
    end
end
min = x_k;
steplength = steplength(1:i);
xhist = xhist(:,1:i);
 
 
%--------------------------------------------------------------------
function p_k = steepdir(grad_f,x_k)
% Steepest descent direction
p_k = - feval(grad_f, x_k);
%--------------------------------------------------------------------
function p_k = newtondir(grad_f,hessian_f,x_k)
% Newton’s direction
grad_f_k = feval(grad_f, x_k);
hessian_f_k = feval(hessian_f, x_k);
p_k = - hessian_f_k\grad_f_k;
%--------------------------------------------------------------------
function p_k = qnewtondir(grad_f,B_k,x_k)
% Quasi-Newton’s direction
grad_f_k = feval(grad_f, x_k);
p_k = -B_k\grad_f_k;
%--------------------------------------------------------------------
function B_k = bfgs(x_k,x_old,B_k,grad_f)
% BFGS
s_k = x_k - x_old;
y_k = feval(grad_f, x_k) - feval(grad_f, x_old);
if y_k' * s_k <= 0
    return
end
B_k = B_k - (B_k * s_k * s_k' * B_k) / (s_k' * B_k * s_k) + ...
    (y_k* y_k') / (y_k' * s_k);
%--------------------------------------------------------------------
function B_k = sr1(x_k,x_old,B_k,grad_f)
% SR1
s_k = x_k - x_old;
y_k = feval(grad_f, x_k) - feval(grad_f, x_old);
if y_k' * s_k <= 0
    return
end
B_k = B_k + ((y_k - B_k * s_k) * (y_k - B_k *s_k)') / ...
    (y_k - B_k * s_k)'*s_k;
 
 



  Profil  Quote  Link auf diesen Beitrag Link
Aliaju hat die Antworten auf ihre/seine Frage gesehen.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2019 by Matroids Matheplanet
This web site was made with PHP-Nuke, a web portal system written in PHP. 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]