Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats de Vec Quadratic() ?Toutes mes excuses pour la transgression, c'est-à-dire ; ironiquement ; un résultat direct de mes progrès personnels en JSL.
Un informaticien très utile de mon organisation essaie de traduire quelque chose initialement écrit en JSL en Python. Plus précisément, le défi est de savoir comment reproduire ce que fait la fonction JSL ' Vec Quadratic() ' ? Voir également le tableau exemple ci-joint.
Arrière-plan:
L'application JSL à traduire crée des colonnes de formules pour les intervalles de confiance et de prédiction. Les formules sont ensuite utilisées pour calculer les valeurs des intervalles de confiance et de prédiction pour une valeur spécifiée par l'utilisateur de x , c'est-à-dire une variable indépendante.
Des questions:
Captures d'écran pour vous orienter:
- Ce que nous voulons réaliser en Python (résultats dans le cadre rouge)
- Comment les colonnes affichées ci-dessus ont été générées
Automatisation et scriptsAnalyse et modélisation des données de baseRe : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Avez-vous interrogé la communauté Python à ce sujet. Personnellement, il semble contre-productif pour la communauté JMP de déployer des efforts pour aider quelqu'un à quitter JMP.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?C'est vrai d'une part. D’un autre côté, cependant, Python est intégré à JMP18, ce qui suggère qu’il doit y avoir des gens qui doivent accepter cette réalité. J'espérais que quelqu'un dans la communauté puisse expliquer, car je considère qu'il est infiniment plus probable qu'un utilisateur JSL connaisse l'équivalent Python de ' Vec Quadratic() ', plutôt que l'inverse. (Et que me dira la communauté Python lorsque je leur demanderai ?)
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Alors que l'objet jmp.DataTable permettra à certains utilisateurs d'exporter plus facilement des données JMP, l'intégration améliorée de Python vise à bénéficier à l'utilisateur JMP.
- Il fournit un environnement dans lequel les utilisateurs novices dans JMP, mais familiers avec Python, peuvent être immédiatement productifs.
- La conception de l'intégration Python se concentre sur l'amélioration de la capacité de JMP à devenir la plaque tournante du flux de travail. Pour réduire le besoin de quitter JMP pour accomplir le travail. L'espoir/le désir est que l'environnement JMP devienne plus pratique, plus attrayant, que le travail soit importé dans JMP plutôt qu'exporté depuis JMP. Cette intégration JMP/Python va bien au-delà de la simple agrégation de JMP et Python. Par exemple:
- Les formats de fichiers non encore pris en charge par JMP peuvent être ouverts à l'aide de packages Python externes, parquet, hdf5, ...
- Autorisez les utilisateurs de JMP à utiliser des GPU de bureau via des packages tels que pyopencl et pyCUDA.
- Fonctionnalités statistiques supplémentaires telles que le clustering de densité hiérarchique (HDBSCAN)
- Capacités de traçage et de représentation graphique supplémentaires avec des packages tels que matplotlib, plotly, ...
- Intégration avec d'autres systèmes logiciels via l'interface Python. SAS, MatLab, R, ...
Les statisticiens et testeurs de JMP ont déployé beaucoup d'efforts pour créer un code fiable, précis et bien testé. C'est la proposition de valeur. Nous nous concentrons sur les statistiques afin que vous puissiez vous concentrer sur votre application, plutôt que d'avoir à réinventer la « roue » statistique.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Je ne doute pas que les statisticiens de JMP consacrent beaucoup d'efforts à la création d'un code fiable. Ce dont je doute, c'est l'espoir de garder ce forum exempt de questions liées à Python.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Merci, c'est très gentil ! Il est possible que nous ayons trouvé une solution : https://numpy.org/doc/stable/reference/generated/numpy.cov.html
Edit : Le titre de cet article est trompeur. numpy.polyfit n'est probablement pas adapté pour émuler ' Vec Quadratic() '.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Nous acceptons les questions Python dans les blogs JMP. J'ai répondu à beaucoup d'entre eux ces derniers temps. Y compris des exemples de code et des discussions sur la meilleure façon d'utiliser Python dans JMP de manière optimale.
Le commentaire de @txnelson sur la question de la communauté Python est valable, tout comme le serait la question des blogs statistiques. Cependant, au lieu de demander comment reproduire le « Vec Quadratic() » de JSL, vous le formulez en demandant comment représenter graphiquement les résultats souhaités, comment faire les statistiques souhaitées en Python.
Quant à répondre à cette question spécifique, je ne peux pas vous aider. Je n'ai aucune connaissance du fonctionnement interne de 'Vec Quadratic()'. Mais je peux vous dire ce que dit le Scripting Index. La définition de l'index de script de Vec Quadratic( S, X ) indique qu'il est évalué comme Vec Diag ( X * S * X ). La description de Vec Diag( X ) dans l'index de script est Renvoie les éléments diagonaux de la matrice carrée sous forme de vecteur. À moins que je manque quelque chose qui semble être un calcul matriciel simple.
Quant à savoir comment appeler 'Vec Quadriatic()' depuis mon programme Python exécuté dans JMP afin de pouvoir traiter davantage les résultats... C'est le genre de question qui serait intéressante.
Vous pouvez utiliser un tableau numpy pour S et X et vous pouvez effectuer Python Get(S), Python Get(X) pour obtenir les valeurs du tableau numpy dans l'environnement JSL en tant que matrice JSL. Et vous pouvez appeler jmp.run_jsl( 'Vec Quadratic( S, X)' ). Ensuite, à partir de Python dans JMP, vous pouvez obtenir les résultats des colonnes directement à partir de la table de données en Python. Consultez l'index de script sur les objets jmp.DataTable et jmp.DataTable.Column.
Dérivé de l'exemple JSL "Vec Quadratic()" dans l'index des scripts.
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));
''')
donner des résultats
/*:
//:*/
S = Python Get(s);
X = Python Get(x);
show(Vec Quadratic(S, X));
/*:
Vec Quadratic(S, X) = [292, 528];
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?@Paul_Nelson , merci. Je savais déjà ce que faisait la fonction JSL 'Vec Quadratic()' avant de publier. Toutes mes excuses pour avoir mal formulé ma question dans ce post. Tout le monde sur ce forum n'est pas de langue maternelle anglaise. Et juste pour être complet :
Votre commentaire:
Bien qu'au lieu de demander comment reproduire le 'Vec Quadratic()' de JSL...
Ma question initiale :
Comment utiliser numpy.polyfit pour reproduire les résultats de Vec Quadratic() ?
Est-ce l'utilisation du mot « reproduire » qui offense ?
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?... vous remarquez qu'il a quelques problèmes avec les manipulations matricielles:)
après avoir ajusté les supports, vous obtenez :
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())
... qui s'adapte à
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])
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?@Ressel Je pense que la partie déroutante de votre demande est que Vec Quadratic() effectue simplement des calculs matriciels comme décrit par l'index de script. Les résultats de Vec Quadratic() sont simplement le résultat d’opérations matricielles.
Les formules elles-mêmes, qui donnent les valeurs de 95 %, sont générées par la plateforme Fit Y by X. « Fit y By X » est également responsable de la création de l'intrigue. La question, telle que je la comprends, est donc plus précise : Comment faire un ajustement bivarié de y par x avec des niveaux de confiance en Python ou numpy ?
Je pense que Vec Quadratic() n'est pas le bon focus puisqu'il n'a pas créé la formule ou les constantes, c'est juste une opération mathématique dans la formule générée.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?@Paul_Nelson , c'est correct, ce que je n'ai compris que plus tard (et exploité sans vergogne pour accepter ma propre réponse comme solution). En ce qui concerne cela ainsi que la formulation exacte de la question, honnêtement, je ne l'avais pas en moi. Plus on apprend... Merci beaucoup pour le partage & bon week-end.
(Ps : en tant qu'éditeur de logiciels statistiques sophistiqués, vous compteriez presque sur des ingénieurs sans que les talents informatiques fassent partie du modèle commercial. Pour le meilleur ou pour le pire.)
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?J'applaudis l'ouverture de Jmp pour Python:)
Comme le mentionne @Paul_Nelson - maintenant avec Jmp18, si une fonctionnalité manque dans JMP, chaque utilisateur peut facilement la récupérer à partir de Python - avec 2-3 lignes de code. incroyablement utile !
D'un autre côté, certaines connaissances de Wikipédia sur la manipulation matricielle, les DOE, la régression, les réseaux de neurones, etc. n'ont rien à craindre d'être « volées ».
Avec les "fonctionnalités" issues des packages Python de pointe et à jour, ce seront les "soft skills", l'absence de bugs, l'interface intuitive, l' expérience utilisateur supérieure qui parleront en faveur de JMP. et le démarquer de la concurrence :
Re: Liste de souhaits - nouveau Libellé : expérience utilisateur
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Peut-être le
NormalContour = sqrt(ChiSquare Quantile( 0.95, 2 ));
L'idée d' Ellipse vous orientera dans la bonne direction. Je fais des photos, pas des statistiques, donc je me trompe peut-être. Mais pour réaliser l’image de l’ellipse, j’ai dû répondre à une question similaire.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?si vous demandez à Copilot :
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?De plus, je pense qu'il est tout à fait naturel que les utilisateurs qui se lancent dans le travail d'analyse et d'automatisation des données via JMP n'aient probablement pas une bonne maîtrise de Python, ou de tout autre langage de programmation et de script d'ailleurs. JMP essaie de manière proactive de recruter ce type d'utilisateur et facilite (je pense) l'entrée dans les scripts en JSL. Cependant, une fois que l'utilisateur a développé et appris, on peut s'attendre à ce que cela déclenche le désir de connaissances supplémentaires, au moins dans certains cas et après que l'obstacle initial de la compréhension de quelques concepts informatiques de base soit surmonté. Bien sûr, la première intuition pour ce type d'utilisateur sera de demander de l'aide à la communauté, surtout après l'intégration annoncée de Python dans JMP 18. Enfin, le fait qu'un data scientist professionnel soit chargé de copier ce qu'un statisticien non professionnel a développé dans JMP pour une utilisation dans un contexte professionnel réel parle de lui-même. Même si je me trompe peut-être.
Re : Plan long : Comment utiliser numpy.polyfit pour reproduire les résultats Vec Quadratic() ?Si quelqu'un est intéressé, le code Python ci-dessous semble reproduire exactement ce que fait JMP en termes de calcul de l'intervalle de confiance autour d'une régression. Ce bloc de code peut être collé directement dans un notebook Jupyter. En plus de calculer les coordonnées Y de l'intervalle de confiance pour chaque X dans la régression linéaire, il crée également un tracé, calcule le coefficient de régression, l'ordonnée à l'origine, les incertitudes associées et compile les résultats.
Je ne crois pas que j'ai écrit ceci moi-même, mais cela reste utile pour apprendre.
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()
