Polynom-Regression von Messwerten

Es geht noch viel mehr: ein Polynom passt ja nicht für jeden Verlauf. 
Deshalb noch ein Beispiel für Y=f(1/x). Man schreibt einfach für den 
x-Bereich z.B. 1/A12:D32 und schon liefert RGP die Koeffizienten für das 
Kehrwert-Polynom. Man kann auch noch logarithmische Regression machen, 
wenn man für den x-Bereich ln(A12:A32) schreibt.
Übrigens finde ich die Microsoft-Methode für die Ausgabe der Array-Werte 
recht umständlich. Mir ist die Index-Funktion sympatischer. Unter 
welchem Index die Koeffizienten zu finden sind, habe ich unter der 
Tabelle dargestellt. So kommt man auch besser an die ganzen Kennwerte. 
Z.B. liefert der "Bestimmtheitswert" R2 (0...1), wie gut die Regression 
geklappt hat.
Hier noch die passende Microsoft-Seite:
http://office.microsoft.com/de-de/excel-help/rgp-HP005209155.aspx

Hermann schrieb:
> Vielleicht kennt ihr noch bessere Möglichkeiten.

Ja, gnuplot kann beliebige Funktionen in beliebig vielen Parametern 
numerisch fitten. Das funktioniert mehr oder weniger gut, je nach dem, 
wie der Kern gewählt wurde. Manchmal muss man mit Startwerten 
nachhelfen, wenn der Algorithmus ansonsten in in falsches (lokales) 
Optimum läuft.

Deine Polynome eignen sich außerdem und im allgemeinen eher schlecht, um 
unbekannte Messwertverläufe anzunähern. Wenn man von vornherein weiß, 
dass es etwas Polynom-ähnliches wird, dann geht es. Oder beim 
allgemeinen numerischen Fitten, wenn man den Kurventyp kennt und nur die 
Parameter optimieren möchte (z.B. irgendeine Halbleiterkennlinie).

Ansonsten neigen höhergradige Polynome gern zum Oszillieren.

Zum Glätten gibts geeignetere Methoden mit Splines und so.

Nase schrieb:
> gnuplot kann beliebige Funktionen in beliebig vielen Parametern
> numerisch fitten

Naja, je nachdem wofür man es braucht. gnuplot ist doch die 
command-line-Geschichte. Ich kenne es nicht, aber die Einarbeitung ist 
wohl schon mal nicht von Pappe. Ich hab mir mal die absoluten Basics in 
youtube angesehen.
Zum Glätten von Messwerten ist Spline sicherlich gut.

Meine Intension ist aber eher das Berechnen von Zwischenwerten, oft auch 
im Mikroproz. Da brauche ich eine Näherungsfunktion. Dafür scheint mir 
gnuplot und spline eher ungeeignet. Wenn die Funktion nicht passt, nehme 
ich lieber eine Wertetabelle und interpoliere.
Vielleicht sehe ich das auch falsch.

Hermann schrieb:
> Endlich habe ich herausgefunden, wie man Messwerte mit einem Polynom
> beliebigen Grades annähert.

Sehr gut, das ist ein schöner Anfang!

Wenn Du mehr lernen möchtest und deutlich mächtigere Dinge machen 
möchtest, solltest Du Deine Energie nicht weiter mit dem Excel-Mist 
verschwenden und statt dessen Dich auf SciPy konzentrieren:

   http://www.scipy.org

bzw., konkreter:

   http://docs.scipy.org/doc/numpy/reference/routines.polynomials.polynomial.html

und mit deutlich mehr Möglichkeiten:

   http://docs.scipy.org/doc/scipy/reference/optimize.html

Um ein Polynom n-ter Ordnung durch n Punkte zu faedeln,
braucht man nur ein lineares Gleichungssystem n-ter Ordnung loesen.

Das ist nun wirklich keine Raketenwissenschaft...
(Und ein Excel braucht man dazu auch nicht unbedingt.)

Im allgemeinen wird das damit erzeugte Polynom aber nicht den
Anspruechen gerecht, die man gemeinhin an eine "nutzbare" Approximation
stellt.

Deswegen werden dort eher Splines und Bezierkurven verwendet.

Kai Klaas schrieb:
> Polynom-Regressionen sind tükisch. Es wimmelt hier nur so von
> Fallstricken

Ihr scheint ja alle was gegen Polynome zu haben. Ich weiß auch, das die 
nicht immer passen. Das war ja nur ein Beispiel.
Wenn man sich mit RGP() beschäftigt, merkt man irgend wann, dass man der 
Funktion alles unterjubeln kann - also belibig unterschiedliche 
Funktionsteile gespickt mit Bedingungen und sonstwas. Ich bin nun mal 
ein Excel-Fan und muss euch noch beweisen, dass das Schimpfen über 
Polynome das Einrennen von offenen Türen ist.
Also habe ich im Anhang mit Exp()-Funktionen einen krummen Verlauf 
hingebastelt, der am Schluss über eine Wenn()-Funktion abschmiert. 
Hierfür soll RGB jetzt eine Regression zaubern.
Dazu muss ich RGP etwas passendes anbieten: ein bisschen sieht die Kurve 
wie zwei Parabeln aus, eine nach oben und eine nach unten geöffnet und 
auf der x-Achse verschoben. Also biete ich RGP zwei Parabeln mit einem 
x-Offset an, wobei die zweite über eine Bedingung erst ab dem Offset 
einsetzt. Ein bisschen am Offset gespielt, und die Regession sieht schon 
mal ganz gut aus.

Mathelehrling schrieb:
> mit dem Excel-Mist
> verschwenden und statt dessen Dich auf SciPy konzentrieren

Meckern kann jeder, aber es wäre mir lieber, wenn du dich als 
Mathelehrer gemeldet und mal ein Beispiel vorgeführt hättest. Aber 
nichts für ungut, ich gucke mir das SciPy mal an. Das Gnuplot und 
Splines waren für meine Zwecke schon mal nichts.
Aber über Excel lasse ich nichts kommen - damit habe ich bisher fast 
alles hingekriegt.

Hermann schrieb:
> Meckern kann jeder, aber es wäre mir lieber, wenn du dich als
> Mathelehrer gemeldet und mal ein Beispiel vorgeführt hättest.

Gerne. Folgendes Progrämmchen findet die Parameter exakt:

1

from numpy import *

2

from scipy import *

3

from scipy.optimize import curve_fit

4

5

@vectorize

6

def f(x, a0, a1, a2, a3):

7

    if x > 4:

8

        return a0 + a1*e**(x-2) + a2*e**(-x) + a3*(x-4)**2

9

    else:

10

        return a0 + a1*e**(x-2) + a2*e**(-x)

11

12

13

x = arange(0, 5, 0.2)

14

y = f(x, 5, 0.5, 5, -20)

15

16

popt, pcov = curve_fit(f, x, y, ones(4))

17

18

print(popt)

Mir ging es aber gar nicht darum, irgendwie zu meckern. Ja, mir ist auch 
bekannt, dass ganze Unternehmen auf Excel basieren. Ich wollte nur 
darauf hinweisen, dass es deutlich mächtigere Software für solche 
Aufgaben gibt, die auch noch OpenSource und völlig kostenlos ist.

Klar, am Anfang ist es etwas schwieriger als Excel. Aber sobald man sich 
damit regelmäßig beschäftigt will man nie wieder zu Excel zurück.

./. schrieb:

> Um ein Polynom n-ter Ordnung durch n Punkte zu faedeln,
> braucht man nur ein lineares Gleichungssystem n-ter Ordnung
> loesen. [...]
>
> Im allgemeinen wird das damit erzeugte Polynom aber nicht
> den Anspruechen gerecht, die man gemeinhin an eine "nutzbare"
> Approximation stellt.

Es ist nicht verwunderlich, dass ein Interpolationspolynom
nicht die an eine Approximation gestellten Ansprüchen genügt,
in der Tat.

Ein Fahrrad erfüllt auch nicht unbedingt die an eine
Schubkarre gestellten Ansprüche.

Mathelehrling schrieb:
> Folgendes Progrämmchen findet die Parameter exakt:

Vielen Dank, da kann man sich wenigstens etwas vorstellen. Habe ich 
schon festgestellt: Scipy ist eine Programmiersprache mit einer großen 
Bibliothek. Die Einarbeitung, bis ich die Lösung schnell mal 
hinschreiben kann, tue ich mir erstmal nicht an. Dann kann ich ja auch 
VBA in Excel nehmen, da kenn ich mich schon aus.

Man kann das ja halbwegs lesen was da passiert. Ist das so richtig?:
- Def definiert die Funktion
- X=arange und Y=f(x...) füllt die Testdaten
- curve_fit optimiert die Parameter
Es müsste dann das herauskommen, was in y=f(x...) angegeben ist

Das macht einen sehr guten Eindruck!!
Aber leider kostet das die Einarbeitung. Wenn ich ständig 
unterschiedliche Probleme lösen muss, würde sich das lohnen. Andenfalls 
fange ich wieder von vorne an.
Und dann müsste ich noch Gnuplot, Splines, Simulink, ....
Ich bleibe erstmal bei meinem geliebten Allerwelts-Tool Excel.
Nochmal Danke Mathelehrer

Hermann schrieb:

> Ich bin nun mal ein Excel-Fan und muss euch noch
> beweisen, [...]

Nee.

Missionieren führt nur zu Glaubenskriegen. Davon hat
keiner 'was.

Hermann schrieb:
> Scipy ist eine Programmiersprache mit einer großen
> Bibliothek.

Genau genommen ist die Programmiersprache Python. Python hat nun schon 
fast 25 Jahre auf dem Buckel:

  https://www.python.org/

SciPy ist in der Tat im Prinzip eine große Bibliothek. Die ersten 
Anfänge von SciPy liegen knapp 15 Jahre zurück. Die Module setzen 
teilweise auf richtig gute abgehangene Software die z.B. in Fortran 
geschrieben ist und sich schon seit Jahrzehnten bewährt.


> Die Einarbeitung, bis ich die Lösung schnell mal
> hinschreiben kann, tue ich mir erstmal nicht an. Dann kann ich ja auch
> VBA in Excel nehmen, da kenn ich mich schon aus.

Excel ist nicht schlecht. Für Formulare die auch noch ein bisschen 
rechnen und hübsch aussehen sollen, super. Sobald man aber VBA anwirft, 
sollte man darüber nachdenken, ob Excel noch das richtige Vehikel ist.


> Man kann das ja halbwegs lesen was da passiert. Ist das so richtig?:
> - Def definiert die Funktion

Exakt.

> - X=arange und Y=f(x...) füllt die Testdaten

Genau. arange(0, 5, 0.2) erzeugt ein Array mit den Werten 0, 0.2, 0.4 
etc.

Und dann wird die Funktion 'f' mit dem Array aus den X-Werten aufgerufen 
(und den Parametern). Das '@vectorize' bei der Funktionsdefinition sorgt 
dafür, dass 'f' als ersten Parameter ein Array verwenden kann und für 
jeden Wert im Array durchlaufen wird.


> - curve_fit optimiert die Parameter

Richtig. curve_fit bekommt die Funktion für die die Parameter gesucht 
werden sollen, ein Array mit den X-Werten, ein Array mit den dazu 
passenden Y-Werten. Zusätzlich benötigt curve_fit noch ein Array mit der 
ersten "Schätzung" für die zu suchenden Parameter. Hier habe ich einfach 
'ones(4)' genommen, das wiederum ein Array bestehend aus vier Einsen 
erzeugt.


> Es müsste dann das herauskommen, was in y=f(x...) angegeben ist

curve_fit() sucht die Parameter a0 bis a3 und gibt ein Array mit den 
Parametern zurück (und noch einigen anderen Werten die uns hier nicht 
interessieren).


> Aber leider kostet das die Einarbeitung. Wenn ich ständig
> unterschiedliche Probleme lösen muss, würde sich das lohnen. Andenfalls
> fange ich wieder von vorne an.

Naja. Python + SciPy ist sehr mächtig. Man lernt es nur einmal, und 
kann damit einen haufen Kram berechnen, analysieren etc.


> Und dann müsste ich noch Gnuplot, Splines, Simulink, ....

Gnuplot brauchst Du nicht. Plotting ist in SciPy integriert und malt 
viel schönere Diagramme. Splines kannst Du, wenn Du willst, natürlich 
auch mit SciPy rechnen.

Das ist ja das schöne an Python + SciPy: Ein Schweizer Taschenmesser auf 
Steroide. Heute einfache Polynome oder ein curve_fit. Morgen willst Du 
vielleicht Tschebyscheff-Polynome berechnen. Übermorgen Daten 
statistisch untersuchen und nächste Woche Filtern designen.

Mathelehrling schrieb:

> Sobald man aber VBA anwirft, sollte man darüber nachdenken,
> ob Excel noch das richtige Vehikel ist.

Also doch Missionierung.

Ein Einäugiger missioniert den anderen, doch mal das andere
Auge zu benutzen.

Naja.

Possetitjel schrieb:
> Mathelehrling schrieb:
>
>> Sobald man aber VBA anwirft, sollte man darüber nachdenken,
>> ob Excel noch das richtige Vehikel ist.
>
> Also doch Missionierung.
>
> Ein Einäugiger missioniert den anderen, doch mal das andere
> Auge zu benutzen.
>
> Naja.

Nee das sehe ich ganz und gar nicht so. Der Lehrling hat da Recht, 
warum? Ganz einfach: Eine Tabellenkalkulation (es gibt durchaus andere, 
auch freie Produkte, die das gleiche können wie der genannte MARKENNAME) 
hat da seine Vorteile, wenn es mal eben schnell gehen soll/muss. 
Spätestens wenn man mit VBA anfängt oder anfangen muss, ist es mit 
schnell und einfach ganz schnell vorbei. Und VBA ist für mathematische 
Aufgabenstellungen sicher nicht optimal geeignet. Von daher sehe ich die 
Aussage des Lehrlings nicht als Missionierer sondern als jemanden, der 
was von der Sache versteht.

Mathelehrling schrieb:
> from numpy import *
> from scipy import *
> from scipy.optimize import curve_fit
>
> @vectorize
> def f(x, a0, a1, a2, a3):
>     if x > 4:
>         return a0 + a1*e**(x-2) + a2*e**(-x) + a3*(x-4)**2
>     else:
>         return a0 + a1*e**(x-2) + a2*e**(-x)
>
> x = arange(0, 5, 0.2)
> y = f(x, 5, 0.5, 5, -20)
>
> popt, pcov = curve_fit(f, x, y, ones(4))
>
> print(popt)

Nur mal so zum Verständnis: die Funktion f ist eine frei erfundene 
Funktion, die keinen Zusammenhang hat zu dem Original-Post Polygon?

Denn ich bin hier etwas ratlos.