Lange Aussicht: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Entschuldigen Sie den Verstoß, der ironischerweise eine direkte Folge meiner persönlichen Fortschritte in JSL ist.
Ein sehr hilfsbereiter Informatiker in meiner Organisation versucht, etwas, das ursprünglich in JSL geschrieben wurde, in Python zu übersetzen. Konkret besteht die Herausforderung darin, zu reproduzieren, was die JSL-Funktion „ Vec Quadratic() “ macht. Siehe auch die beigefügte Beispieltabelle.
Hintergrund:
Die zu übersetzende JSL-Anwendung erstellt Formelspalten für die Konfidenz- und Vorhersageintervalle. Die Formeln werden dann verwendet, um die Werte der Konfidenz- und Vorhersageintervalle für einen vom Benutzer angegebenen Wert von x , auch unabhängige Variable genannt, zu berechnen.
Fragen:
Screenshots zur Orientierung:
- Was wir in Python erreichen wollen (Ergebnisse im roten Rahmen)
- So wurden die oben angezeigten Spalten generiert
Automatisierung und SkriptingGrundlegende Datenanalyse und ModellierungBetreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Haben Sie die Python-Community danach gefragt? Mir persönlich erscheint es der JMP-Community kontraproduktiv, sich darum zu bemühen, jemanden von JMP wegzubringen.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Einerseits stimmt das. Andererseits ist Python in JMP18 integriert, was darauf schließen lässt, dass es Leute geben muss, die sich mit dieser Realität abfinden. Ich hatte gehofft, dass jemand aus der Community es erklären könnte, da ich es für unendlich wahrscheinlicher halte, dass ein JSL-Benutzer das Python-Äquivalent von ' Vec Quadratic() ' kennt, als umgekehrt. (Und was wird mir die Python-Community sagen, wenn ich sie frage?)
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Während das jmp.DataTable-Objekt einigen Benutzern einen einfacheren Weg zum Exportieren von JMP-Daten bietet, konzentriert sich die verbesserte Python-Integration darauf, dem JMP-Benutzer Vorteile zu bieten.
- Es bietet eine Umgebung, in der Benutzer, die JMP noch nicht kennen, aber mit Python vertraut sind, sofort produktiv sein können.
- Das Design der Python-Integration konzentriert sich darauf, JMPs Fähigkeit zu verbessern, der zentrale Punkt des Workflows zu sein. Die Notwendigkeit zu verringern, JMP zu verlassen, um die Arbeit zu erledigen. Die Hoffnung/der Wunsch ist, dass die JMP-Umgebung bequemer und ansprechender wird, dass die Arbeit in JMP übertragen und nicht aus JMP exportiert wird. Diese JMP/Python-Integration wird mehr als nur die Zusammenführung von JMP und Python. Zum Beispiel:
- Von JMP noch nicht unterstützte Dateiformate können mit externen Python-Paketen, Parquet, HDF5 usw. geöffnet werden.
- Ermöglichen Sie JMP-Benutzern die Nutzung von Desktop-GPUs über Pakete wie pyopencl und pyCUDA.
- Zusätzliche statistische Funktionen wie hierarchisches Dichteclustering (HDBSCAN)
- Zusätzliche Plot- und Grafikfunktionen mit Paketen wie matplotlib, plotly, …
- Integration mit anderen Softwaresystemen über die Python-Schnittstelle. SAS, MatLab, R, ...
Die Statistiker und Tester von JMP stecken viel Arbeit in die Erstellung von Code, der zuverlässig, genau und gut getestet ist. Das ist das Wertversprechen. Wir konzentrieren uns auf die Statistik, damit Sie sich auf Ihre Anwendung konzentrieren können, anstatt das statistische „Rad“ neu erfinden zu müssen.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Ich bezweifle nicht, dass die JMP-Statistiker viel Mühe in die Erstellung zuverlässigen Codes stecken. Was ich bezweifle, ist die Erwartung, dieses Forum frei von Python-bezogenen Fragen zu halten.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Danke, das ist sehr nett! Möglicherweise haben wir eine Lösung gefunden: https://numpy.org/doc/stable/reference/generated/numpy.cov.html
Bearbeiten: Der Titel dieses Beitrags ist irreführend. numpy.polyfit ist wahrscheinlich nicht zum Emulieren von „ Vec Quadratic() “ geeignet.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Wir freuen uns über Python-Fragen in den JMP-Blogs. Ich habe in letzter Zeit viele davon beantwortet. Einschließlich Beispielcode und Diskussionen darüber, wie man Python in JMP optimal nutzt.
Der Kommentar von @txnelson zur Frage an die Python-Community ist gültig, ebenso wie eine Frage an Statistikblogs. Anstatt jedoch zu fragen, wie man JSLs „Vec Quadratic()“ repliziert, formulieren Sie es so, dass Sie fragen, wie man die gewünschten Ergebnisse grafisch darstellt und wie man die gewünschten Statistiken in Python erstellt.
Was die Beantwortung dieser speziellen Frage angeht, kann ich Ihnen nicht helfen. Ich weiß nicht, wie „Vec Quadratic()“ intern funktioniert. Aber ich kann Ihnen sagen, was der Scripting-Index sagt. Die Scripting-Index-Definition von Vec Quadratic( S, X ) besagt, dass es als Vec Diag ( X * S * X ) ausgewertet wird. Die Beschreibung von Vec Diag( X ) im Scripting-Index lautet: Gibt die diagonalen Elemente der quadratischen Matrix als Vektor zurück. Es sei denn, ich übersehe etwas, das wie einfache Matrizenmathematik aussieht.
Und wie rufe ich „Vec Quadriatic()“ aus meinem in JMP laufenden Python-Programm auf, damit ich die Ergebnisse weiterverarbeiten kann? Das wäre eine interessante Frage.
Sie können ein Numpy-Array für S und X verwenden und Python Get(S), Python Get(X) ausführen, um die Numpy-Arraywerte als JSL-Matrix in die JSL-Umgebung zu bekommen. Und Sie können jmp.run_jsl( 'Vec Quadratic( S, X)' ) aufrufen. Dann können Sie von Python in JMP aus die Spaltenergebnisse direkt aus der Datentabelle in Python abrufen. Siehe den Scripting Index für jmp.DataTable- und jmp.DataTable.Column-Objekte.
Abgeleitet aus dem JSL-Beispiel „Vec Quadratic()“ im Scripting-Index.
import jmp
import numpy as np
s = np.array( [[1,3,5],[3,2,6], [5,6,1] ])
x = np.array( [[1,3,5],[2,4,6] ])
jmp.run_jsl('''
S = Python Get(s);
X = Python Get(x);
show(Vec Quadratic(S, X));
''')
Ergebnisse liefern
/*:
//:*/
S = Python Get(s);
X = Python Get(x);
show(Vec Quadratic(S, X));
/*:
Vec Quadratic(S, X) = [292, 528];
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?@Paul_Nelson , danke. Ich wusste bereits vor dem Posten, was die JSL-Funktion „Vec Quadratic()“ macht. Entschuldigen Sie, dass ich meine Frage in diesem Post nicht richtig formuliert habe. Nicht jeder in diesem Forum ist englischer Muttersprachler. Und nur der Vollständigkeit halber:
Dein Kommentar:
Anstatt jedoch zu fragen, wie man „Vec Quadratic()“ von JSL repliziert …
Meine ursprüngliche Frage:
Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?
Ist die Verwendung des Wortes „reproduzieren“ anstößig?
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?... Sie bemerken, dass es einige Probleme mit Matrixmanipulationen gibt:)
nach dem Anpassen der Klammern erhält man:
import numpy as np
s = np.array( [[1.,3.,5.],[3.,2.,6.], [5.,6.,1.] ])
x = np.array( [[1.,3.,5.],[2.,4.,6.] ])
res= x @ (s @ x.T)
print(res)
print(res.diagonal())
... das passt zu
Names Default To Here( 1 );
exS = [1 3 5, 3 2 6, 5 6 1];
exX = [1 3 5, 2 4 6];
Print(r= exX * exS * exX`);
tmp=as list(r);
print(tmp[1][1],tmp[2][2])
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?@Ressel Ich denke, der verwirrende Teil Ihrer Anfrage ist, dass Vec Quadratic() einfach Matrixmathematik ausführt, wie im Scripting Index beschrieben. Die Ergebnisse von Vec Quadratic() sind einfach die Ausgabe von Matrixoperationen.
Die Formeln selbst, die die 95 %-Werte liefern, werden von der Plattform „Fit Y by X“ generiert. „Fit y By X“ ist auch für die Erstellung des Diagramms verantwortlich. Die Frage, wie ich sie verstehe, lautet also genauer: Wie führe ich eine bivariate Anpassung von y by x mit Konfidenzniveaus in Python oder Numpy durch?
Ich denke, der Schwerpunkt von Vec Quadratic() liegt falsch, da weder dadurch die Formel noch die Konstanten erstellt wurden, sondern es sich lediglich um eine mathematische Operation in der generierten Formel handelt.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?@Paul_Nelson , das ist richtig, was ich erst später herausgefunden habe (und schamlos ausgenutzt habe, um meine eigene Antwort als Lösung zu akzeptieren). Diesbezüglich sowie hinsichtlich der genauen Formulierung der Frage hatte ich es ehrlich gesagt nicht in mir. Je mehr man lernt … Vielen Dank fürs Teilen & schönes Wochenende.
(P.S.: Als hochentwickeltes Unternehmen für statistische Software würde man fast damit rechnen, dass Ingenieure ohne rechnerisches Talent Teil des Geschäftsmodells sind. Im Guten wie im Schlechten.)
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Ich begrüße die Offenheit von Jmp für Python:)
Wie @Paul_Nelson erwähnt – wenn jetzt mit Jmp18 eine Funktionalität in JMP fehlt, kann sie jeder Benutzer problemlos aus Python abrufen – mit 2–3 Codezeilen. Unglaublich nützlich!
Andererseits besteht kein Grund zur Sorge, dass einige Wikipedia-Kenntnisse über Matrixmanipulation, DOEs, Regression, neuronale Netzwerke usw. „gestohlen“ werden könnten.
Während die „Funktionalität“ aus hochmodernen, aktuellen Python-Paketen stammt, sind es die „Soft Skills“, die Abwesenheit von Fehlern, die intuitive Benutzeroberfläche und das überlegene Benutzererlebnis , die für JMP sprechen und es von der Konkurrenz abheben:
Betreff: Wunschliste - neu Label: Benutzererfahrung
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Vielleicht das
NormalContour = sqrt(ChiSquare Quantile( 0.95, 2 ));
Die Idee von Ellipse wird Sie in die richtige Richtung weisen. Ich mache Bilder, keine Statistiken, also könnte ich völlig danebenliegen. Aber um das Ellipsenbild zu erstellen, musste ich eine ähnliche Frage beantworten.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?wenn Sie Copilot fragen:
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Darüber hinaus halte ich es für ganz natürlich, dass Benutzer, die über JMP in die Datenanalyse und -automatisierung einsteigen, wahrscheinlich keine guten Kenntnisse in Python oder einer anderen Programmier- und Skriptsprache haben. JMP versucht proaktiv, diese Art von Benutzern zu gewinnen, und macht (meiner Meinung nach) den Einstieg in die Skripterstellung in JSL einfach. Sobald der Benutzer sich jedoch weiterentwickelt und lernt, kann davon ausgegangen werden, dass dies den Wunsch nach zusätzlichem Wissen weckt, zumindest in einigen Fällen und nachdem die anfängliche Hürde des Verständnisses einiger grundlegender, rechnerischer Konzepte überwunden ist. Natürlich wird die erste Intuition dieser Art von Benutzern darin bestehen, die Community um Hilfe zu bitten, insbesondere nach der angekündigten Python-Integration in JMP 18. Schließlich spricht die Tatsache, dass ein professioneller Datenwissenschaftler damit beauftragt wird, das zu kopieren, was ein Laienstatistiker in JMP entwickelt hat, um es in einer tatsächlichen Geschäftsumgebung zu verwenden, für sich. Obwohl ich das vielleicht alles falsch verstehe.
Betreff: Long Shot: Wie verwende ich numpy.polyfit, um Vec Quadratic()-Ergebnisse zu reproduzieren?Falls es jemanden interessiert: Der folgende Python-Code scheint genau das zu reproduzieren, was JMP in Bezug auf die Berechnung des Konfidenzintervalls um eine Regression macht. Dieser Codeblock kann direkt in ein Jupyter-Notebook eingefügt werden. Neben der Berechnung der Y-Koordinaten des Konfidenzintervalls für jedes X in der linearen Regression erstellt er auch ein Diagramm, berechnet den Regressionskoeffizienten, den Achsenabschnitt, die damit verbundenen Unsicherheiten und stellt die Ergebnisse tabellarisch dar.
Ich glaube nicht, dass ich das selbst geschrieben habe, aber es ist trotzdem nützlich zum Lernen.
import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt
# the data as array
x_coordinate = np.array([0, 1, 2, 3])
y_coordinate = np.array([0.0, 0.5, 1.2, 5.1])
# linear model
func = lambda x, a, b: a * x + b
# model fit
best_fit_ab, covar = curve_fit(func, x_coordinate, y_coordinate)
sigma_ab = np.sqrt(np.diagonal(covar))
# extract fitted parameters and uncertainties
a, b = best_fit_ab
a_err, b_err = sigma_ab
text_res = f"Best fit parameters:\na = {a:.10f} ± {a_err:.10f}\nb = {b:.10f} ± {b_err:.10f}"
print(text_res)
# calculate the standard error of the regression
residuals = y_coordinate - func(x_coordinate, a, b)
s_err = np.sqrt(np.sum(residuals**2) / (len(x_coordinate) - 2))
# define a function to calculate the confidence intervals
def predict_ci(x, func, popt, pcov, s_err, alpha=0.05): # adjust alpha here
from scipy.stats import t
df = len(x_coordinate) - 2
t_val = t.ppf(1 - alpha / 2, df) # t-value for the given confidence level and degrees of freedom
y = func(x, *popt)
ci = t_val * s_err * np.sqrt(1/len(x_coordinate) + (x - np.mean(x_coordinate))**2 / np.sum((x_coordinate - np.mean(x_coordinate))**2))
return y - ci, y + ci
# generate points for high-resolution x-axis
hires_x = np.linspace(x_coordinate.min(), x_coordinate.max(), 100)
# calculate confidence intervals
ci_lower_orig, ci_upper_orig = predict_ci(x_coordinate, func, best_fit_ab, covar, s_err)
# tabulate the original data and confidence intervals
table_orig = np.column_stack((x_coordinate, y_coordinate, ci_lower_orig, ci_upper_orig))
print("\nTabulated values (original data):")
print("X Coordinate\tY Coordinate\t\tCI Lower\t\tCI Upper")
for row in table_orig:
print(f"{row[0]:.2f}\t\t{row[1]:.10f}\t\t{row[2]:.10f}\t{row[3]:.10f}") # adjust decimals for tabulation
# plotting the data
plt.scatter(x_coordinate, y_coordinate, label='Data', color='blue')
# plotting the fitted model
plt.plot(hires_x, func(hires_x, *best_fit_ab), 'black', label='Fitted model')
# plotting the confidence intervals
ci_lower, ci_upper = predict_ci(hires_x, func, best_fit_ab, covar, s_err)
plt.fill_between(hires_x, ci_lower, ci_upper, color='black', alpha=0.15, label='Confidence interval')
# adding text with parameters
plt.text(x_coordinate.min() + 0.5, y_coordinate.max() - 0.5, text_res)
# customize plot
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')
plt.title('Y Coordinate vs. X Coordinate')
plt.legend()
plt.show()
