Beispiel für die Anwendung von Python auf das Engineering: Ermitteln von Parametern der ungefähren Berechnungsformel aus tatsächlichen Daten
Wenn Sie die Temperatur usw. mit einem eingebetteten Gerät messen möchten, kann es vorkommen, dass Sie nicht an der gewünschten Position messen können und diese irgendwie berechnen und approximieren müssen. dann,
――Können Sie eine gute Näherungsformel erstellen?
- So bestimmen Sie die Parameter der Formel
Das ist ein Problem.
In diesem Artikel werde ich Ihnen ein Beispiel zeigen, wie Sie den letzteren Parameter einfach mithilfe von "scipy" in Python bestimmen können.
―― Schließlich soll es auf eingebettete Geräte angewendet werden, die nur eine schlechte Ganzzahlarithmetik ausführen können.
- Behandeln Sie das System, das Sie annähern möchten, bis zu einem gewissen Grad als Black Box.
Im Folgenden erfolgt die gesamte Ausführung auf dem Jupyter-Notizbuch. Es wird auf Github veröffentlicht.
Daten lesen
Angenommen, die folgenden Daten sind als CSV-Datei bereit, lesen Sie zunächst diese Daten.
--t Zeit --x Messwerte wie tatsächlich erhaltene Sensoren --y Der Wert, den Sie tatsächlich erhalten möchten, möchten Sie diesem Wert von x annähern
Die Problemeinstellung lautet "y kann im tatsächlichen Betrieb nicht gemessen werden, daher wird es aus dem Wert von x angenähert". (Obwohl y am Entwicklungsstandort mit einer speziellen Methode gemessen werden kann, kommt es häufig vor, dass im Betriebsstadium nur x erhalten werden kann.)
Entspricht den Lehrerdaten y für maschinelles Lernen und den Eingabedaten x.
%matplotlib inline
import matplotlib.pyplot as plt
import pandas
from scipy import optimize
import numpy as np
#Lesen Sie CSV
datafile = 'xy_data.csv' #Datendateiname
df = pandas.read_csv(datafile)
#Lassen Sie uns visualisieren
df.plot()
plt.show()
#Ich werde auch den numerischen Wert der Daten anzeigen(100 bis 5)
df[100:105]
x(オレンジ)を使ってy(緑)を近似したい。
Verwenden wir nun x, um y zu approximieren.
Modell 1 - Ungefähr mit linearer Gleichung
y kann als 1 gesehen werden.? Zeiten von x. Daher haben wir uns entschlossen, mit f (x) = a * x + b zu approximieren und die Parameter a und b mit scipy zu finden.
#Definieren Sie eine Annäherung
def f1(x, a, b): #Listen Sie die erforderlichen Parameter nach einer Eingabe auf
return a*x + b
#Fassen Sie ungefähre Berechnungen in Funktionen zusammen
def param_solver(f, x, y, debug_print=True):
'''Funktion f(x)Berechnen Sie die mit dem Anfangswert geschätzten Parameter so, dass die Eingabe x mit y übereinstimmt.'''
params, params_covariance = optimize.curve_fit(f, x, y) # <----------Optimierungsberechnung hier
if debug_print:
print('params =', params) #Erhaltene Parameter
print('params_covariance =', params_covariance) #Kovarianz mit diesem Parameter
print('standad deviation errors = ', np.sqrt(np.diag(params_covariance))) #Standardabweichung
return params
#Konvertieren Sie Daten einmal in numpy Daten
x = np.array(df['x'].tolist())
y = np.array(df['y'].tolist())
t = np.array(df['t'].tolist())
#Parameter berechnen
params = param_solver(f=f1, x=x, y=y)
params = [ 1.24075239e+00 2.31148413e+03] params_covariance = [[ 3.47128802e-04 -4.06799576e+00] [ -4.06799576e+00 5.46259540e+04]] standad deviation errors = [ 1.86313929e-02 2.33721959e+02]
Sie können die ungefähren Parameter leicht in *** optimize.curve_fit *** in scipy finden.
Visualisieren Sie Approximationen mit gefundenen Parametern
Wie nah könnte es sein?
#Kombinieren Sie Visualisierungen zu Funktionen
def plot_all(f, x, y, params):
fig, ax = plt.subplots()
ax.plot(t, f(x, *params), 'b-', label="f(x)")
ax.plot(t, x if len(np.array(x).shape) == 1 else x[0], 'r-', label="x")
ax.plot(t, y, 'g-', label="y")
ax.legend()
plt.show()
plot_all(f1, x, y, params)
Es war unmöglich, weil ich gerade x (rot) mit einer Konstanten in Bezug auf y (grün) multipliziert habe ... Lassen Sie uns das Modell ändern.
Modell 2 - Eingeführte quadratische Gleichung
Ungefähr mit f (x) = a * x ^ 2 + b * x + c.
#Definieren Sie eine Annäherung
def f2(x, a, b, c):
return a*x**2 + b*x + c
#Parameter berechnen
params2 = param_solver(f=f2, x=x, y=y) #Erraten Sie drei Elemente
#Visualisieren
plot_all(f2, x, y, params2)
params = [ -5.82931117e-05 2.42030720e+00 -2.33839533e+03] params_covariance = [[ 1.78832431e-11 -3.61865487e-07 1.42649657e-03] [ -3.61865487e-07 7.56116875e-03 -3.16641976e+01] [ 1.42649657e-03 -3.16641976e+01 1.51375869e+05]] standad deviation errors = [ 4.22885837e-06 8.69549812e-02 3.89070519e+02]
Es ist ziemlich ähnlich, aber die Gipfel sind nicht sehr nahe. Wenn Sie genau hinschauen, scheinen die Punkte der Kurve zwischen x und y zeitlich unterschiedlich zu sein. Berücksichtigen Sie auch den Zeitfaktor.
Modell 3 - Differenzierung einführen
Näherung mit f (x) = a * x ^ 2 + b * x + c * dx / dt + d unter Verwendung des Differentialterms dx / dt.
def f3(xs, a, b, c, d):
x, xdelayed = xs
dx = x - xdelayed #Die Differenzierung wird durch die Differenz zur Verzögerungskomponente ausgedrückt
return a*x**2 + b*x + c*dx + d;
def make_delayed(d, delay_step):
'''Erste Verzögerung_Stufenstücke d[0]Und die Verzögerung am Heck_Erstellen Sie d mit abgeschnittenem Schritt'''
d = list(d)
n = len(d)
result = np.array([d[0] for i in range(delay_step)] + list(d[:-delay_step]))
return result
#Erstellen Sie Daten 10 Stunden später
x10 = make_delayed(x, delay_step=10)
#Parameter berechnen und visualisieren
params3 = param_solver(f=f3, x=(x, x10), y=y) #X zwei Eingänge geben
plot_all(f3, (x, x10), y, params3)
params = [ -3.54499345e-05 2.03961022e+00 3.95514919e+00 -2.84616185e+03] params_covariance = [[ 2.27985415e-12 -4.55332708e-08 2.90736635e-08 1.64730881e-04] [ -4.55332708e-08 9.39580914e-04 -4.84532248e-04 -3.67720697e+00] [ 2.90736635e-08 -4.84532248e-04 5.03391759e-03 -6.46259873e-01] [ 1.64730881e-04 -3.67720697e+00 -6.46259873e-01 1.79598365e+04]] standad deviation errors = [ 1.50991859e-06 3.06525841e-02 7.09501063e-02 1.34014314e+02]
Ganz ähnlich! Allerdings ist das angenäherte f (x) in der zweiten Hälfte leicht von y (grün) entfernt. Hier ist der einfache Weg, die Differenzierung vorzunehmen, "x (t) - x (t-10)", aber war es mit dieser 10-fachen Verzögerung in Ordnung?
Ich werde auch nach dieser Verzögerungskomponente (im Folgenden td) als Parameter suchen.
Finden Sie den optimalen Wert für die Differentialnäherung
#Für die Zeitverzögerung td die Bewertungsfunktion, die die Güte, das Ziel und f quantifiziert(x)Absolutwert der Differenz von(L1 Abstand)Definiert als die Summe von
def cost(td, *args):
_f, _x, _y = args
#Verzögerungsdaten erstellen
xdelay = make_delayed(d=_x, delay_step=td)
#Optimierung berechnen
_params = param_solver(f=_f, x=(_x, xdelay), y=_y, debug_print=False)
#Berechnen Sie die Summe der Entfernungen
return np.sum(np.abs(_y - _f((_x, xdelay), *_params)))
print('cost(td=5) = ', cost(5, f3, x, y))
print('cost(td=10) = ', cost(10, f3, x, y))
cost(td=5) = 178246.4667 cost(td=10) = 149393.276741
Zuerst entschied ich mich leicht für die Bewertungsfunktion, und als ich den Wert mit td = 5, 10 als Versuch nahm, konnte ich quantitativ bestätigen, dass 10 besser als 5 ist.
Auch hier optimiert scipy.
def cost_for_brute(td, *args):
'''Verhalten des Tieres(Schließlich ist td in der Liste angegeben)Wrapper nach, geben Sie immer einen ganzzahligen Wert zu den Kosten'''
try:
td = int(td[0])
except:
pass
return cost(td, *args)
#Suche
result = optimize.brute(cost_for_brute, [slice(1, 50, 1)], args=(f3, x, y), full_output=True)
final_td, final_cost, tds, costs = result #Optimaler td,Optimale Kosten,Suchbereich td,Jeder kostet
final_td = int(final_td[0]) # [23.]Da es als Liste von reellen Zahlen wie zurückgegeben wird, wird es in eine Ganzzahl konvertiert.
print('final optimum td = ', final_td, 'for cost = ', final_cost)
#Visualisierung
fig, ax = plt.subplots()
ax.plot(tds, costs, 'b-', label="cost(td)")
ax.plot(final_td, final_cost, 'go', label="Minima")
ax.legend()
plt.show()
final optimum td = 23 for cost = 123800.706755
Sie sehen, dass es nur eine optimale Lösung gibt, die gut konvex ist und den kleinsten Wert für die Bewertungsfunktion aufweist. Lassen Sie uns nun den Approximationszustand mit diesem Parameter td visualisieren.
def solve_and_plot_by_td(td, f, x, y, debug_print=True):
#Verzögerungsdaten erstellen
xdelay = make_delayed(d=x, delay_step=td)
#Optimierung berechnen
params = param_solver(f=f, x=(x, xdelay), y=y, debug_print=debug_print)
#Visualisierung
plot_all(f, (x, xdelay), y, params)
return params
f3_params = solve_and_plot_by_td(final_td, f3, x, y)
params = [ -3.56938479e-05 2.02134829e+00 1.78433928e+00 -2.62914982e+03] params_covariance = [[ 1.41335136e-12 -2.83473596e-08 7.69752574e-09 1.03708164e-04] [ -2.83473596e-08 5.86738635e-04 -1.35889230e-04 -2.30772756e+00] [ 7.69752574e-09 -1.35889230e-04 6.07763010e-04 -9.90337036e-02] [ 1.03708164e-04 -2.30772756e+00 -9.90337036e-02 1.11544635e+04]] standad deviation errors = [ 1.18884455e-06 2.42226884e-02 2.46528499e-02 1.05614693e+02]
Es hat sich verbessert. Der Wert der Bewertungsfunktion wird speziell wie folgt optimiert, und f (x) überlappt sich fast mit dem Ziel y in der Grafik.
cost(td=10) = 149393.276741
cost(td=23) = 123800.706755
Wenn das Ziel damit erreicht wurde, war der ungefähre Ausdruck f3 () wirklich optimal?
War zum Beispiel der quadratische Term "a * x ** 2" notwendig? Es gibt auch eine Differenzierung, aber ist kein Integrationsbegriff erforderlich?
Modell 4 - Lassen Sie den quadratischen Term weg
Ungefähr mit "f (x) = b * x + c * dx / dt + d", wobei "x ^ 2" weggelassen wird.
def f4(xs, b, c, d):
x, xdelayed = xs
dx = x - xdelayed #Die Differenzierung wird durch die Differenz zur Verzögerungskomponente ausgedrückt
return b*x + c*dx + d;
#Suche Implementierung
result = optimize.brute(cost_for_brute, [slice(1, 50, 1)], args=(f4, x, y), full_output=True)
final_td, final_cost, tds, costs = result #Optimaler td,Optimale Kosten,Suchbereich td,Jeder kostet
final_td = int(final_td[0]) # [23.]Da es als Liste von reellen Zahlen wie zurückgegeben wird, wird es in eine Ganzzahl konvertiert.
print('final optimum td = ', final_td, 'for cost = ', final_cost)
#Visualisierung
fig, ax = plt.subplots()
ax.plot(tds, costs, 'b-', label="cost(td)")
ax.plot(final_td, final_cost, 'go', label="Minima")
ax.legend()
plt.show()
final optimum td = 32 for cost = 251326.900162
Ich fand, dass die Kosten schlecht waren. Lassen Sie uns für alle Fälle den Approximationszustand visualisieren.
solve_and_plot_by_td(final_td, f4, x, y)
params = [ 1.28868602 1.44297502 176.91492786] params_covariance = [[ 6.30546320e-05 3.59497597e-05 -7.78121379e-01] [ 3.59497597e-05 1.08222102e-03 -1.60091104e+00] [ -7.78121379e-01 -1.60091104e+00 1.21028825e+04]] standad deviation errors = [ 7.94069468e-03 3.28971279e-02 1.10013101e+02]
Auf den ersten Blick sehen Sie, dass es sich in der Grafik verschlechtert hat. Wie oben erwähnt, verstehe ich, dass der quadratische Term notwendig war.
Als nächstes führen wir den Integrationsbegriff ein.
Modell 5 - Integrationsbegriff einführen
Näherung mit f (x) = a * x ^ 2 + b * x + c * dx / dt + d * Summe (x) + e unter Verwendung des Integrationsterms Summe (x).
#Erhalten Sie den integrierten Wert im beweglichen Bereich. Teilen Sie durch die Anzahl der hinzuzufügenden Daten, um ein Überlaufen der Ziffern zu verhindern=>∴ Gleitender Durchschnitt ...
def integral(d, span):
d = list(d)
n = len(d)
dspan = [d[0] for i in range(span - 1)] + d #Span am Anfang-Bereiten Sie ein Array mit einem hinzugefügten vor
return np.array([sum(dspan[i:i+span])/span for i in range(n)])#Erstellen Sie Daten, indem Sie beim Verschieben Bereiche hinzufügen
#Definieren Sie eine Annäherung
def f5(xs, a, b, c, d, e):
x, xdelay, xsum = xs
dx = x - xdelay
return a*x**2 + b*x + c*dx + d*xsum + e
#Eine Bewertungsfunktion, die die Güte für die Integrationszeit ti, das Ziel und f quantifiziert(x)Absolutwert der Differenz von(L1 Abstand)Definiert als die Summe von
def cost5(ti, *args):
f, x, xdelay, y = args
#Erstellen Sie integrierte Daten
xsum = integral(x, ti)
#Optimierung berechnen
params = param_solver(f=f, x=(x, xdelay, xsum), y=y, debug_print=False)
#Berechnen Sie die Summe der Entfernungen
return np.sum(np.abs(y - f((x, xdelay, xsum), *params)))
#Verzögerungsdaten erstellen(* Verwenden Sie den zuletzt erzielten optimalen Wert.)
xdelay = make_delayed(d=x, delay_step=final_td)
#Versuchen Sie es mit ti=Berechnen Sie die Kosten, wenn 10
print(cost5(5, f5, x, xdelay, y))
print(cost5(10, f5, x, xdelay, y))
105806.884719 105436.131801
def cost5_for_brute(td, *args):
'''Verhalten des Tieres(Schließlich ist td in der Liste angegeben)Wrapper nach, geben Sie immer einen ganzzahligen Wert zu den Kosten'''
try:
td = int(td[0])
except:
pass
return cost5(td, *args)
#Suche Implementierung
result = optimize.brute(cost5_for_brute, [slice(1, 400, 1)], args=(f5, x, xdelay, y), full_output=True)
final_ti, final_cost, tis, costs = result #Optimale ti,Optimale Kosten,Suchbereich ti,Jeder kostet
final_ti = int(final_ti[0]) # [23.]Da es als Liste von reellen Zahlen wie zurückgegeben wird, wird es in eine Ganzzahl konvertiert.
print('final optimum ti = ', final_ti, 'for cost = ', final_cost)
#Visualisierung
fig, ax = plt.subplots()
ax.plot(tis, costs, 'b-', label="cost5(ti)")
ax.plot(final_ti, final_cost, 'go', label="Minima")
ax.legend()
plt.show()
final optimum ti = 47 for cost = 89564.819536
Sie können sehen, dass die Auswertungsfunktion dieses Mal drei lokale Lösungen im Bereich von [1.400] hat. Es wurde gezeigt, dass dies die optimale Lösung ist 47.
def solve_and_plot_by_ti(ti, f, x, xdelay, y, debug_print=True):
#Erstellen Sie integrierte Daten
xsum = integral(x, ti)
#Optimierung berechnen
params = param_solver(f=f, x=(x, xdelay, xsum), y=y, debug_print=debug_print)
#Visualisierung
plot_all(f, (x, xdelay, xsum), y, params)
return params
f5_params = solve_and_plot_by_ti(final_ti, f5, x, xdelay, y)
params = [ -3.03782209e-05 9.91815249e+00 -4.26387796e+00 -7.99927214e+00 -2.47884462e+03] params_covariance = [[ 6.63718559e-13 3.34745759e-08 -2.98614480e-08 -4.66996212e-08 4.64742006e-05] [ 3.34745759e-08 7.18603686e-02 -5.03435446e-02 -7.23475214e-02 -1.40511200e+00] [ -2.98614480e-08 -5.03435446e-02 3.54804571e-02 5.08234965e-02 2.46752985e-01] [ -4.66996212e-08 -7.23475214e-02 5.08234965e-02 7.31066200e-02 3.71334580e-01] [ 4.64742006e-05 -1.40511200e+00 2.46752985e-01 3.71334580e-01 4.98091129e+03]] standad deviation errors = [ 8.14689241e-07 2.68067843e-01 1.88362568e-01 2.70382359e-01 7.05755715e+01]
Die Summe der von der Bewertungsfunktion zurückgegebenen L1-Abstände scheint immer noch 89564 zu betragen, aber der Graph hat den Punkt erreicht, an dem der ungefähre Ausdruck fast mit dem Ziel übereinstimmt. Durch die Einführung des Integrationsbegriffs wird die Verzögerung der Annäherung durch die Ernte verbessert.
Bisher optimale Approximationsformel
def f5(xs, a, b, c, d, e):
x, xdelay, xsum = xs
dx = x - xdelay
return a*x**2 + b*x + c*dx + d*xsum + e
Andererseits wurde festgestellt, dass jeder Parameter die folgenden Werte verwenden sollte.
params = [ -3.03782209e-05 9.91815249e+00 -4.26387796e+00 -7.99927214e+00 -2.47884462e+03]
Lassen Sie uns zum Schluss noch zwei betrachten.
- Brauchst du wirklich den x ^ 2 Term?
- Bei Anwendung auf eingebettete Geräte gibt es Fälle, in denen 50 Puffer mit gleitendem Durchschnitt nicht gespeichert werden können. Was ist in diesem Fall zu tun?
Modell 6 - Bestätigung der Notwendigkeit sekundärer Begriffe
Betrachtet man den Wert von Parameter a = params [0], so ist dies "-3.03782209e-05".
Mit anderen Worten, der *** quadratische Term trägt wenig zum Ergebnis bei und ist nicht notwendig? Lassen Sie uns die Formel tatsächlich ändern und überprüfen.
#Definieren Sie eine Annäherung
def f6(xs, b, c, d, e):
x, xdelay, xsum = xs
dx = x - xdelay
return b*x + c*dx + d*xsum + e
#Suche
result = optimize.brute(cost5_for_brute, [slice(1, 400, 1)], args=(f6, x, xdelay, y), full_output=True)
final_ti, final_cost, tis, costs = result #Optimale ti,Optimale Kosten,Suchbereich ti,Jeder kostet
final_ti = int(final_ti[0]) # [23.]Da es als Liste von reellen Zahlen wie zurückgegeben wird, wird es in eine Ganzzahl konvertiert.
print('final optimum ti = ', final_ti, 'for cost = ', final_cost)
#Visualisierung
fig, ax = plt.subplots()
ax.plot(tis, costs, 'b-', label="cost(ti)")
ax.plot(final_ti, final_cost, 'go', label="Minima")
ax.legend()
plt.show()
solve_and_plot_by_ti(final_ti, f6, x, xdelay, y)
final optimum ti = 339 for cost = 152778.51452
params = [ 1.45958277 1.24676966 -0.27112565 246.80198745] params_covariance = [[ 1.74462598e-04 -1.29255162e-04 -2.11185881e-04 -4.55806349e-01] [ -1.29255162e-04 8.85113218e-04 2.42461052e-04 -1.11227411e+00] [ -2.11185881e-04 2.42461052e-04 3.35043878e-04 -8.63631214e-02] [ -4.55806349e-01 -1.11227411e+00 -8.63631214e-02 7.95856480e+03]] standad deviation errors = [ 1.32084291e-02 2.97508524e-02 1.83042038e-02 8.92107886e+01]
*** Immerhin war der quadratische Term notwendig. *** ***
Wenn der Wert des Parameters klein ist, denken Sie vielleicht, dass der Beitrag klein ist, aber es ist klar, dass Sie erst dann ein Urteil fällen können, wenn Sie ihn tatsächlich überprüfen.
Schließlich sollten Sie sich für ein kleines eingebettetes System, das keinen großen Wert für ti annehmen kann (keinen großen Integrationspuffer annehmen kann, keine großen Ganzzahlen verarbeiten kann, mit mehreren Bits schwer zu berechnen ist), ansehen, was passiert, wenn ti klein ist. schauen.
Beim Betrieb von Modell 5 mit einem kleinen ti
Es gibt bis zu 10 lokale Lösungen für ti. Was ist mit diesem Fall?
#Suche Implementierung
result = optimize.brute(cost5_for_brute, [slice(1, 30, 1)], args=(f5, x, xdelay, y), full_output=True)
final_ti, final_cost, tis, costs = result #Optimale ti,Optimale Kosten,Suchbereich ti,Jeder kostet
final_ti = int(final_ti[0]) # [23.]Da es als Liste von reellen Zahlen wie zurückgegeben wird, wird es in eine Ganzzahl konvertiert.
print('final optimum ti = ', final_ti, 'for cost = ', final_cost)
#Visualisierung
fig, ax = plt.subplots()
ax.plot(tis, costs, 'b-', label="cost(ti)")
ax.plot(final_ti, final_cost, 'go', label="Minima")
ax.legend()
plt.show()
solve_and_plot_by_ti(final_ti, f5, x, xdelay, y)
final optimum ti = 9 for cost = 105290.231346
params = [ -3.35077051e-05 6.34533112e+00 8.26308638e-01 -4.35919543e+00 -2.65976841e+03] params_covariance = [[ 9.91381369e-13 8.29449613e-10 1.80437951e-09 -2.06410309e-08 7.13151940e-05] [ 8.29449613e-10 4.55158040e-02 -4.96419025e-03 -4.52708548e-02 -3.90835831e+00] [ 1.80437951e-09 -4.96419025e-03 7.59625712e-04 4.90797861e-03 2.31789824e-01] [ -2.06410309e-08 -4.52708548e-02 4.90797861e-03 4.54355845e-02 2.30925244e+00] [ 7.13151940e-05 -3.90835831e+00 2.31789824e-01 2.30925244e+00 7.83076217e+03]] standad deviation errors = [ 9.95681359e-07 2.13344332e-01 2.75613082e-02 2.13156244e-01 8.84915938e+01]
Es ist der optimalen Lösung nicht so unterlegen, wenn "ti = 47" ist.
Wenn die Implementierung schwierig ist, ist das Arbeiten mit "ti = 9" oft ein Kompromiss.
Zusammenfassung
Immerhin konnte ich mit PID (Proportional / Integral / Differential) + quadratischem Term eine gute Annäherung machen.
Da das ursprüngliche Ziel dieser Zeit ein Thema war, das dem klassischen Kontrollsystem nahe kommt, denke ich, dass es eine erwartete Antwort für diejenigen in dieser Richtung ist. Wenn Sie sich eine solche Näherungsformel vorstellen können und Scipy in Python gut verwenden, können Sie leicht einen geeigneten Parameter überprüfen und finden.
Zu dieser Zeit ist es meiner Meinung nach am schnellsten, Jupyter Notebook zu verwenden, um technische Notizen zusammen mit Daten und Formeln zu hinterlassen.
Ergänzung und zukünftige Entwicklung
Diesmal wurden die Daten in einer Stichprobe erläutert. Dies mag in Ordnung sein, wenn das System nicht so stark schwankt, aber in Wirklichkeit ist es sicherer, statistisch vorzugehen, indem 30 Proben entnommen werden.
Zu diesem Zeitpunkt bleibt noch viel zu tun, z. B. ob im Stichprobenstadium gemittelt oder die Parameter berechnet und integriert werden sollen.
Auch nach einmaliger Modellierung können sich die Eigenschaften des Systems ändern (Drift). Die Herausforderung besteht darin, wie man sich zu diesem Zeitpunkt anpasst und ob es mit einem kleinen Programm realisiert werden kann, um die Parameter anzupassen.
Abgesehen davon kann der Ansatz, das Ganze als probabilistisches System zu betrachten, auch besser sein. Ich möchte ein neues Wahrscheinlichkeitsmodell erstellen und MCMC usw. verwenden, um es als nächstes zu untersuchendes Problem zu finden.
Beiseite
»Da ich vor einigen Jahren beschäftigt war, ließ ich einen Kollegen eine ungefähre Formel finden und lösen. ――Jedoch, obwohl die Näherungsformel erstellt wurde, suchte ein anderer Kollege per Hand nach Parametern (ein Dilemma, das ich mir nicht selbst nehmen konnte ...). Ich konnte es so approximieren, wie es war, und es wurde so belassen, wie es war, weil es nicht besonders kritisch war. ―― Tatsächlich wurde in der Approximationsformel nur der Differentialterm verwendet (diesmal entspricht dies Modell 3). Ich war nicht skeptisch, aber ich war sehr skeptisch, ob es das Beste war. ――Diese Aktivität habe ich versucht, bis zu einem gewissen Grad zu vertiefen, einschließlich des Grundes, warum ich keine Integration verwendet habe.
Aufgrund der diesmal anhaltenden Untersuchung scheint das Folgende genutzt werden zu können.
- Es ist jetzt möglich, die Parameteroptimierung zu automatisieren.
- Ich habe mindestens eine Annäherung gefunden, die in einem besseren, kleineren System implementiert werden kann.
Recommended Posts