Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Disculpas por la transgresión, que es; irónicamente; un resultado directo de mi progreso personal en JSL.
Un informático muy útil de mi organización está intentando traducir algo escrito inicialmente en JSL a Python. Específicamente, el desafío es cómo reproducir lo que está haciendo la función JSL ' Vec Quadratic() '. Consulte también la tabla de ejemplo adjunta.
Fondo:
La aplicación JSL que se va a traducir crea columnas de fórmula para los intervalos de confianza y predicción. Luego, las fórmulas se utilizan para calcular los valores de los intervalos de confianza y de predicción para algún valor de x especificado por el usuario, también conocido como variable independiente.
Preguntas:
Capturas de pantalla para orientación:
- Lo que queremos lograr en Python (resultados dentro del marco rojo)
- Cómo se generaron las columnas que se muestran arriba
Automatización y secuencias de comandosAnálisis y modelado de datos básicosRe: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?¿Le preguntaste a la comunidad de Python sobre esto? Personalmente, parece contraproducente para la comunidad de JMP esforzarse en ayudar a alejar a alguien de JMP.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Cierto por un lado. Por otro lado, sin embargo, Python está integrado en JMP18, lo que sugiere que debe haber gente que esté aceptando esta realidad. Esperaba que alguien en la comunidad pudiera explicarme, ya que considero que es infinitamente más probable que un usuario de JSL conozca el equivalente en Python de ' Vec Quadratic() ', en lugar de viceversa. (¿Y qué me dirá la comunidad Python cuando les pregunte?)
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Si bien el objeto jmp.DataTable permitirá a algunos usuarios una ruta más fácil para exportar datos JMP, la integración mejorada de Python se centra en beneficiar al usuario de JMP.
- Proporciona un entorno en el que los usuarios nuevos en JMP, pero familiarizados con Python, pueden ser productivos de inmediato.
- El diseño de la integración de Python se centra en mejorar la capacidad de JMP como centro del flujo de trabajo. Reducir la necesidad de abandonar JMP para realizar el trabajo. La esperanza/deseo es que el entorno JMP se vuelva más conveniente, más atractivo, que el trabajo se lleve a JMP en lugar de exportarse fuera de JMP. Esa integración de JMP/Python se vuelve más grande que simplemente la agregación de JMP y Python. Por ejemplo:
- Los formatos de archivo que aún no son compatibles con JMP se pueden abrir utilizando paquetes externos de Python, parquet, hdf5, ...
- Permita que los usuarios de JMP utilicen GPU de escritorio a través de paquetes como pyopencl y pyCUDA.
- Capacidades estadísticas adicionales como agrupación de densidad jerárquica (HDBSCAN)
- Capacidades adicionales de trazado y gráficos con paquetes como matplotlib, plotly, ...
- Integración con otros sistemas de software a través de la interfaz Python. SAS, MatLab, R, ...
Los estadísticos y evaluadores de JMP se esfuerzan mucho en crear código que sea confiable, preciso y bien probado. Esa es la propuesta de valor. Nos centramos en las estadísticas para que usted pueda centrarse en su aplicación, en lugar de tener que reinventar la "rueda" estadística.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?No dudo que los estadísticos de JMP se esfuercen mucho en crear código confiable. Lo que dudo es la expectativa de mantener este foro libre de preguntas relacionadas con Python.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?¡Gracias, es muy amable! Es posible que hayamos encontrado una solución: https://numpy.org/doc/stable/reference/generated/numpy.cov.html
Editar: el título de esta publicación es engañoso. numpy.polyfit probablemente no sea adecuado para emular ' Vec Quadratic() '.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Damos la bienvenida a las preguntas sobre Python en los blogs de JMP. He estado respondiendo a muchas de ellas últimamente. Incluye código de muestra y debates sobre la mejor manera de utilizar Python en JMP para sacar el máximo provecho.
El comentario de @txnelson sobre preguntar a la comunidad Python es válido, al igual que preguntar a los blogs estadísticos. Aunque en lugar de preguntar cómo replicar 'Vec Quadratic()' de JSL, lo expresa en términos de preguntar cómo graficar los resultados que desea, cómo hacer las estadísticas que desea en Python.
En cuanto a responder a esta pregunta específica, no puedo ayudarte. No tengo conocimiento de cómo funciona internamente 'Vec Quadratic()'. Pero puedo decirles lo que dice el Índice de secuencias de comandos. La definición del índice de secuencias de comandos de Vec Quadratic( S, X ) indica que se evalúa como Vec Diag ( X * S * X ). La descripción de Vec Diag( X ) en el índice de Scripting es Devuelve los elementos diagonales de la matriz cuadrada como un vector. A menos que me esté perdiendo algo que parezca ser matemática matricial sencilla.
En cuanto a cómo llamo a 'Vec Quadriatic()' desde mi programa Python ejecutándose en JMP para poder procesar aún más los resultados... Ese es el tipo de pregunta que sería interesante.
Puede usar una matriz numpy para S y X y puede hacer Python Get(S), Python Get(X) para obtener los valores de la matriz numpy en el entorno JSL como una matriz JSL. Y puedes llamar a jmp.run_jsl( 'Vec Quadratic( S, X)' ). Luego, desde Python en JMP puede obtener los resultados de las columnas directamente desde la tabla de datos en Python. Consulte el índice de secuencias de comandos sobre los objetos jmp.DataTable y jmp.DataTable.Column.
Derivado del ejemplo JSL "Vec Quadratic()" en el 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));
''')
dando resultados
/*:
//:*/
S = Python Get(s);
X = Python Get(x);
show(Vec Quadratic(S, X));
/*:
Vec Quadratic(S, X) = [292, 528];
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?@Paul_Nelson , gracias. Ya sabía lo que hacía la función JSL 'Vec Quadratic()' antes de publicar. Disculpas por formular inadecuadamente mi pregunta en esta publicación. No todos los participantes en este foro son hablantes nativos de inglés. Y sólo para completar:
Tu comentario:
Aunque en lugar de preguntar cómo replicar 'Vec Quadratic()' de JSL...
Mi pregunta original:
¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?
¿Es el uso de "reproducir" lo que resulta ofensivo?
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?... notas que tiene algunos problemas con las manipulaciones de matrices:)
Después de ajustar los soportes, obtienes:
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())
... que se adapta a
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: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?@Ressel Creo que la parte confusa de su solicitud es que Vec Quadratic() simplemente realiza matemáticas matriciales como se describe en el Índice de secuencias de comandos. Los resultados de Vec Quadratic() son simplemente el resultado de operaciones matriciales.
Las fórmulas en sí, que dan los valores del 95%, son generadas por la plataforma Fit Y by X. 'Fit y By X' es también quien se encarga de crear la trama. Entonces, la pregunta, tal como la entiendo, es más precisa; ¿Cómo hago un ajuste bivariado de y por x con niveles de confianza en Python o numpy?
Creo que Vec Quadratic() es el enfoque equivocado ya que no creó la fórmula ni las constantes, es solo una operación matemática en la fórmula generada.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?@Paul_Nelson , esto es correcto, lo descubrí más tarde (y lo aproveché descaradamente para aceptar mi propia respuesta como solución). Con respecto a esto, así como a la redacción exacta de la pregunta, honestamente no lo tenía en mí. Cuanto más uno aprende... Muchas gracias por compartir y buen fin de semana.
(Ps: como empresa de software estadístico sofisticado, casi contaría con ingenieros sin talento computacional como parte del modelo de negocio. Para bien o para mal).
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Aplaudo la apertura de Jmp para Python.:)
Como menciona @Paul_Nelson , ahora con Jmp18, si falta una funcionalidad en JMP, cada usuario puede obtenerla fácilmente desde Python, con 2 o 3 líneas de código. increíblemente útil!
Por otro lado, algunos conocimientos de Wikipedia sobre manipulación de matrices, DOE, regresión, redes neuronales, etc. no son motivo de preocupación de que sean "robados".
Con la "funcionalidad" proveniente de paquetes Python actualizados y de última generación, serán las "habilidades sociales", la ausencia de errores, la interfaz intuitiva y la experiencia de usuario superior lo que hablará por JMP. y separarlo de la competencia:
Re: Lista de deseos - nueva Etiqueta: experiencia de usuario
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Quizas el
NormalContour = sqrt(ChiSquare Quantile( 0.95, 2 ));
La idea de Ellipse le indicará la dirección correcta. Hago fotografías, no estadísticas, así que puede que me haya equivocado. Pero para hacer la imagen de la elipse tuve que responder una pregunta similar.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?si le preguntas al copiloto:
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Además, creo que es natural que es poco probable que los usuarios que se dedican al trabajo de automatización y análisis de datos a través de JMP tengan un conocimiento firme de Python o de cualquier otro lenguaje de programación y scripting. JMP está intentando reclutar proactivamente a este tipo de usuario y hace (creo) que sea fácil entrar en scripting en JSL. Sin embargo, una vez que el usuario se desarrolla y aprende, se puede esperar que esto desencadene el deseo de adquirir conocimientos adicionales, al menos en algunos casos y después de superar la barrera inicial de comprender algunos conceptos computacionales básicos. Por supuesto, la primera intuición para este tipo de usuario será pedir ayuda a la comunidad, especialmente después de la integración de Python anunciada en JMP 18. Finalmente, el hecho de que un científico de datos profesional tenga la tarea de copiar lo que un estadístico no especializado ha desarrollado en JMP para su uso en un entorno empresarial real habla por sí solo. Aunque puede que lo esté entendiendo todo mal.
Re: Posibilidad remota: ¿Cómo utilizar numpy.polyfit para reproducir los resultados de Vec Quadratic()?Si alguien está interesado, el siguiente código Python parece reproducir exactamente lo que JMP está haciendo en términos de calcular el intervalo de confianza alrededor de una regresión. Este bloque de código se puede pegar directamente en un cuaderno Jupyter. Además de calcular las coordenadas Y del intervalo de confianza para cada X en la regresión lineal, también crea una gráfica, calcula el coeficiente de regresión, la intersección, las incertidumbres asociadas y tabula los resultados.
No creas que lo escribí yo mismo, pero sigue siendo útil para aprender.
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()
