Problem mit der Minimierungsfunktion in JSLHallo allerseits,
Ich versuche, die Minimierungsfunktion in JSL zu verwenden, um die Werte von zwei (oder mehr) Variablen zu erhalten, die den mittleren Fehlerquadrat eines großen Modells minimieren. Ich kann es nicht zur Konvergenz bringen, obwohl ich weiß, zu welchem Wert es konvergieren soll (durch Versuch und Irrtum).
Die grundlegende Syntax, die ich verwendet habe, ist:
minfun = Minimize( min_test, {kD( 0.4, 0.8 ), wshc( 0.1, 1.5 )}, <<DETAILS></DETAILS>Ich habe verschiedene Nachrichten ausprobiert, aber sie ändern nichts.
Das Ziel hier besteht darin, die Werte von kD und wshc zu finden und den Ausdruck min_test zu minimieren, der selbst eine Folge ausgewerteter Ausdrücke wie in ist
min_test = Expr(
Eval( light );
Eval( parafile );
Eval( runprg );
Eval( reshandling2 );
Eval( SSE2 );
);
Die geänderten kD- und wshc-Werte ändern die Ausdrücke „light“ und „parafile“, die dann eine ausführbare Programmdatei (im runprg-Ausdruck) ausführen, deren Ergebnisse manipuliert werden und von der der mittlere quadratische Fehler (MSE) als letztes abhängt im SSE2-Ausdruck ausgewertet. Für den Kontext übermittelt der Ausdruck „runprg“ mehrere erstellte Dateien an eine eigenständige ausführbare Datei, die die thermische Entwicklung von Seen simuliert. Jeder Durchlauf des „runprg“-Ausdrucks erfordert etwa 10–20 Sekunden Rechenzeit, deren Ergebnisse wieder in JSL eingelesen werden, um den MSE zu berechnen.
Der Prozess selbst scheint insofern korrekt zu funktionieren, als er den Zielfunktionswert bei jedem Schritt korrekt liest und die Werte der Parameter korrekt an den Ausdruck zu übergeben scheint. Das Problem besteht darin, dass der Algorithmus die kD- und wshc-Parameter so geringfügig (nur in der 5. Dezimalstelle) relativ zu den Anfangswerten, die ich ihnen gegeben habe, „verschiebt“, dass die Konvergenz fehlschlägt. Wenn ich beispielsweise mit Anfangswerten von 0,8 bzw. 0,5 beginne, erhalte ich normalerweise etwas wie „
0,8
0,49999945654133
bei der nächsten Iteration und hat daher keinen wesentlichen Einfluss auf die resultierende MSE. Mit den Parametergrenzen, die ich in der Minimierungsfunktion angegeben habe, gibt es viel Platz zum Verschieben der Parameter. Ich verstehe, dass mein Fall ziemlich weit von der typischen einfachen differenzierbaren Funktion entfernt ist. Durch die „manuelle“ Ausführung des Programms mit unterschiedlichen Parameterwerten weiß ich jedoch, dass die Zielfunktion in Bezug auf die Parameter ziemlich konvex ist, und dachte daher, dass die Minimierungsfunktion gut funktionieren würde, insbesondere bei Verwendung der <
Irgendwelche Vorschläge für eine Problemumgehung, die in dieser Situation hilfreich sein könnten?
Vielen Dank im Voraus, Yves
Erweiterte statistische ModellierungAutomatisierung und SkripterstellungMac OSBetreff: Problem mit der Minimierungsfunktion in JSLDer Algorithmus wird danach beendet MaxIter Iterationen - also würde ich das auf einen viel größeren Wert als den Standardwert erhöhen und sehen, ob das hilft.
Betreff: Problem mit der Minimierungsfunktion in JSLVielen Dank für den Vorschlag, David, aber ich fürchte, er hilft nicht. Allerdings hätte ich klarer sagen sollen, dass die Anzahl der Iterationen, die es tatsächlich durchführt, bevor es abstürzt, nicht hoch ist, vielleicht etwa 20 bis 30, aber jedes Mal ist die Änderung der Parameterwerte zu gering, um irgendeine Auswirkung zu haben.
Yves
Betreff: Problem mit der Minimierungsfunktion in JSLDas ist nicht wirklich mein Fachgebiet, aber es scheint, als ob es funktionieren sollte. Hier ist meine Test-JSL.
aa = expr(
Show( "evaluating", Char( a, 19, 16 ), Char( b, 19, 16 ) ); // peek inside
(a - 10) ^ 2 + (b - 11) ^ 2 // the function, roots at 10 and 11
);
min_test = Expr( Eval( aa ) );
a = 33; // initial guesses
b = -55; // (not very good)
minfun = Minimize(
min_test,
{a( -100, 100 ), b( -100, 100 )},
<<DETAILS></DETAILS>
Hier ist das Protokoll. Es scheint seltsam, dass eine Reihe von Anrufen mit genau den gleichen anfänglichen falschen Schätzungen getätigt werden, obwohl sie auf die erste *echte* Schätzung eine nahezu perfekte Antwort zu erhalten scheinen.
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000005066394806";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "32.9999994933605194";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-54.999999165534973";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000000834465027";
"evaluating";
Char(a, 19, 16) = "33.0002058854513791";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "32.9997941145486209";
Char(b, 19, 16) = "-55.000000000000000";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-54.999660894550665";
"evaluating";
Char(a, 19, 16) = "33.0000000000000000";
Char(b, 19, 16) = "-55.000339105449335";
"evaluating";
Char(a, 19, 16) = "33.0003391054493349";
Char(b, 19, 16) = "-54.999660894550665";
"evaluating";
Char(a, 19, 16) = "32.9996608945506651";
Char(b, 19, 16) = "-54.999660894550665";
"evaluating";
Char(a, 19, 16) = "33.0003391054493349";
Char(b, 19, 16) = "-55.000339105449335";
"evaluating";
Char(a, 19, 16) = "32.9996608945506651";
Char(b, 19, 16) = "-55.000339105449335";
nParm=2 SR1 ******************************************************
Iter nFree Objective RelGrad NormGrad2 Ridge nObj nGrad nHess Parm0 Parm1
0 2 4885 9770 9770 0 1 1 1 33 -55
"evaluating";
Char(a, 19, 16) = "9.9999350076876112";
Char(b, 19, 16) = "11.0000734771922168";
"evaluating";
Char(a, 19, 16) = "9.9999351715994163";
Char(b, 19, 16) = "11.0000734771922168";
"evaluating";
Char(a, 19, 16) = "9.9999348437758062";
Char(b, 19, 16) = "11.0000734771922168";
"evaluating";
Char(a, 19, 16) = "9.9999350076876112";
Char(b, 19, 16) = "11.0000736560072454";
"evaluating";
Char(a, 19, 16) = "9.9999350076876112";
Char(b, 19, 16) = "11.0000732983771883";
1 2 9.623e-9 0.006344 1.925e-8 0 1 1 0 9.999935 11.00007
"evaluating";
Char(a, 19, 16) = "9.9999999999733351";
Char(b, 19, 16) = "10.9999999999907079";
"evaluating";
Char(a, 19, 16) = "10.0000001638861082";
Char(b, 19, 16) = "10.9999999999907079";
"evaluating";
Char(a, 19, 16) = "9.9999998360605620";
Char(b, 19, 16) = "10.9999999999907079";
"evaluating";
Char(a, 19, 16) = "9.9999999999733351";
Char(b, 19, 16) = "11.0000001788046422";
"evaluating";
Char(a, 19, 16) = "9.9999999999733351";
Char(b, 19, 16) = "10.9999998211767736";
2 2 7.97e-22 2.42e-15 1.59e-21 0 1 1 0 10 11
Convergence SUCCESS: Gradient
Time: 0
"evaluating";
Char(a, 19, 16) = "9.9999999999733351";
Char(b, 19, 16) = "10.9999999999907079";
minfun = 7.97360035815878e-22;
a = 9.99999999997334;
b = 10.9999999999907;
Es sieht so aus, als ob Sie mit 27 Aufrufen der 10-20-Sekunden-Funktion rechnen könnten.
Generiert Ihr Algorithmus dieselbe Antwort für dieselbe Eingabe oder gibt es eine Zufallskomponente? Das könnte einen Unterschied machen.
Betreff: Problem mit der Minimierungsfunktion in JSLSehr interessanter Craige. Ich bin Ihrem Ansatz gefolgt und habe die Werte im laufenden Betrieb überprüft. In diesem Beispiel sind meine Anfangswerte 0,8 bzw. 0,5 .
minfun = Minimize( min_test, {kD( 0.4, 0.8 ), wshc( 0.1, 1.5 )}, <<DETAILS></DETAILS>Die zweite Iteration ergibt dies
/*:2 2 44.86266 210.178 0.080004 128 12 1 0 0.799999 0.50001
und der 3
/*:3 2 45.33956 0 0.080004 4096 16 0 0 0.799999 0.50001
und es kann nicht besser sein als Iteration 2, also hört es hier auf. Hier beträgt der beste Zielfunktionswert 44,86.
Wenn ich dem Algorithmus jedoch „manuell“ die Parameterwerte 0,52 bzw. 1,13 gebe, beträgt die Zielfunktion (MSE) etwa 6,8, viel besser als die oben genannten Ergebnisse. Das Einzige, woran ich denken kann, ist, dass es bei den Anfangswerten ein sehr lokales Minimum gibt, aber das scheint unwahrscheinlich, weil ich unabhängig von meinen Anfangswerten die gleichen Ergebnisse erhalte ...
Betreff: Problem mit der Minimierungsfunktion in JSLIch bin mir ziemlich sicher, dass die Minimierung von den Steigungen abhängt, die zur Antwort führen.
In der Vergangenheit habe ich damit gespielt, eine Reihe zufälliger Startpunkte für die Minimierung zu verwenden, die beste Antwort beizubehalten und neue zufällige Startpunkte mit einer Normalverteilung um diesen Punkt herum zu erstellen. Aber das funktioniert nur, wenn man genug Zeit hat ... und man weiß nie, ob man die beste Antwort gefunden hat.
Betreff: Problem mit der Minimierungsfunktion in JSLJa, ich neige zu einer „Brute-Force“-Lösung, die der von Ihnen vorgeschlagenen ähnelt. Andernfalls müsste ich eine Nelder-Mead-Optimierungsroutine programmieren, die für diese Art von Problemen möglicherweise besser geeignet ist. Gibt es eine Chance, dass jemand bei JMP bereits einen solchen Code geschrieben hat? 
Danke, Yves
Betreff: Problem mit der Minimierungsfunktion in JSLEs ist schwer, genau zu sagen, was passiert, ohne das Beispiel selbst ausführen zu können, aber es fallen Ihnen zwei andere Ansätze ein, die Sie möglicherweise ausprobieren könnten.Die erste besteht darin, die zu verwenden eingeschränkt minimieren Funktion ohne lineare Einschränkungen.Es verwendet eine andere Methode als die minimieren Funktion, also könnte es möglicherweise helfen. Ausgehend von Craiges Beispiel könnten Sie also etwa Folgendes tun:
aa = expr(
Show( "evaluating", Char( a, 19, 16 ), Char( b, 19, 16 ) ); // peek inside
(a - 10) ^ 2 + (b - 11) ^ 2 // the function, roots at 10 and 11
);
min_test = Expr( Eval( aa ) );
minFun =
Constrained Minimize(
min_test,
{a( -100, 100 ), b( -100, 100 )},
<<StartingValues( [0, 0] ), <<show details(true)
);
Eval List( {a, b, minFun} );
Oder Sie könnten einen anderen Ansatz ausprobieren: Erstellen Sie eine kleine Datentabelle und verwenden Sie den Profiler für die Optimierung.Ich bin mir nicht wirklich sicher, wie gut das mit Ihrer Formel funktionieren wird, aber ich füge ein Beispiel bei, wie das mit Craiges Beispiel funktionieren würde. Hier ist ein Bild der Lösung, die Sie erhalten, wenn Sie die Funktion im Profiler optimieren:
Wenn Sie das erste an die Datentabelle angehängte Skript ausführen, starten Sie den Profiler vor der Optimierung.Das zweite Skript startet den Profiler mit der optimalen Lösung. Der Profiler verwendet mehrere zufällige Starts und ist daher robuster bei der Suche nach der global optimalen Lösung.
Betreff: Problem mit der Minimierungsfunktion in JSLHallo Laura,
Vielen Dank für Ihre Vorschläge. Bisher habe ich nur die erste Funktion ausprobiert (eingeschränktes Minimieren) und sie verhält sich auf jeden Fall anders als die Minimierungsfunktion! Allerdings habe ich jetzt das umgekehrte Problem, dh die Parameter bewegen sich überall innerhalb des erlaubten Parameterraums, ohne scheinbar jemals stabile Werte zu erreichen!! Was mir nicht ganz klar ist, ist der Unterschied zwischen „Iterationen“ und der Häufigkeit, mit der die Zielfunktion ausgewertet wird. Offensichtlich sind sie nicht gleich. Ich hatte einen maximalen Iter(5) festgelegt, aber die Funktion wurde viele Male ohne Konvergenz ausgewertet. Nach ein paar Minuten musste ich das Beenden von JMP erzwingen.
Ich fange an zu denken, dass die Art von Modell, die ich zu optimieren versuche, ziemlich lästig ist!
Ich werde Ihrem zweiten Vorschlag eine Chance geben! Beste Grüße, Yves
