Tiro lungo: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Ci scusiamo per la trasgressione, che è; ironicamente; un risultato diretto del mio progresso personale in JSL.
Uno scienziato informatico molto utile nella mia organizzazione sta cercando di tradurre qualcosa inizialmente scritto in JSL in Python. Nello specifico, la sfida è come riprodurre ciò che sta facendo la funzione JSL ' Vec Quadratic() '? Vedi anche la tabella di esempio allegata.
Sfondo:
L'applicazione JSL da tradurre crea colonne formula per gli intervalli di confidenza e previsione. Le formule vengono quindi utilizzate per calcolare i valori degli intervalli di confidenza e previsione per alcuni valori specificati dall'utente di x , ovvero variabili indipendenti.
Domande:
Schermate per l'orientamento:
- Cosa vogliamo ottenere in Python (risultati all'interno della cornice rossa)
- Come sono state generate le colonne mostrate sopra
Automazione e scriptingAnalisi e modellazione dei dati di baseRi: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Hai chiesto informazioni a riguardo alla comunità Python. Personalmente, sembra controproducente per la comunità JMP impegnarsi per aiutare ad allontanare qualcuno da JMP.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Vero da un lato. D’altra parte, però, Python è integrato in JMP18, il che suggerisce che ci devono essere persone che devono fare i conti con questa realtà. Speravo che qualcuno nella comunità fosse in grado di spiegare, poiché ritengo infinitamente più probabile che un utente JSL conosca l'equivalente Python di ' Vec Quadratic() ', piuttosto che viceversa. (E cosa mi dirà la comunità Python quando glielo chiederò?)
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Mentre l'oggetto jmp.DataTable consentirà ad alcuni utenti un percorso più semplice per esportare i dati JMP, l'integrazione migliorata di Python è focalizzata sui vantaggi per l'utente JMP.
- Fornisce un ambiente in cui gli utenti nuovi a JMP, ma che hanno familiarità con Python, possono essere immediatamente produttivi.
- La progettazione dell'integrazione Python si concentra sul miglioramento della capacità di JMP di fungere da fulcro del flusso di lavoro. Riducendo la necessità di lasciare JMP per portare a termine il lavoro. La speranza/desiderio è che l'ambiente JMP diventi più conveniente, più allettante, che il lavoro venga portato in JMP anziché esportato fuori da JMP. L'integrazione tra JMP e Python diventa maggiore della semplice aggregazione di JMP e Python. Per esempio:
- I formati di file non ancora supportati da JMP possono essere aperti utilizzando pacchetti Python esterni, parquet, hdf5, ...
- Consenti agli utenti JMP di utilizzare le GPU desktop tramite pacchetti come pyopencl e pyCUDA.
- Funzionalità statistiche aggiuntive come il clustering di densità gerarchica (HDBSCAN)
- Funzionalità aggiuntive di tracciamento e grafica con pacchetti come matplotlib, plotly, ...
- Integrazione con altri sistemi software tramite l'interfaccia Python. SAS, MatLab, R, ...
Gli statistici e i tester di JMP si impegnano molto nella creazione di un codice affidabile, accurato e ben testato. Questa è la proposta di valore. Ci concentriamo sulle statistiche in modo che tu possa concentrarti sulla tua applicazione, invece di dover reinventare la "ruota" statistica.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Non dubito che gli statistici di JMP si impegnino molto nella creazione di un codice affidabile. Ciò di cui dubito è l'aspettativa di mantenere questo forum libero da domande relative a Python.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Grazie, è molto gentile! È possibile che abbiamo trovato una soluzione: https://numpy.org/doc/stable/reference/generated/numpy.cov.html
Modifica: il titolo di questo intervento è fuorviante. numpy.polyfit probabilmente non è adatto per emulare ' Vec Quadratic() '.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Diamo il benvenuto alle domande su Python nei blog JMP. Ho risposto a molti ultimamente. Incluso codice di esempio e discussioni su come utilizzare al meglio Python in JMP per trarne il massimo vantaggio.
Il commento di @txnelson sulla richiesta alla comunità Python è valido, così come la richiesta ai blog statistici. Tuttavia, invece di chiedere come replicare "Vec Quadratic()" di JSL, lo esprimi in termini di chiedere come rappresentare graficamente i risultati desiderati, come eseguire le statistiche desiderate in Python.
Per quanto riguarda la risposta a questa domanda specifica, non posso aiutarti. Non sono a conoscenza di come funzioni internamente 'Vec Quadratic()'. Ma posso dirti cosa dice lo Scripting Index. La definizione dell'indice di scripting di Vec Quadratic( S, X ) afferma che viene valutato come Vec Diag ( X * S * X ). La descrizione di Vec Diag( X ) nell'indice di scripting è Restituisce gli elementi diagonali della matrice quadrata come vettore. A meno che non mi manchi qualcosa che sembri essere un semplice calcolo matriciale.
Per quanto riguarda come posso chiamare "Vec Quadriatic()" dal mio programma Python in esecuzione in JMP in modo da poter elaborare ulteriormente i risultati... Questo è il tipo di domanda che sarebbe interessante.
Puoi utilizzare un array numpy per S e X e puoi eseguire Python Get(S), Python Get(X) per ottenere i valori dell'array numpy nell'ambiente JSL come matrice JSL. E puoi chiamare jmp.run_jsl( 'Vec Quadratic( S, X)' ). Quindi da Python in JMP puoi ottenere i risultati delle colonne direttamente dalla tabella dati in Python. Vedere l'indice degli script sugli oggetti jmp.DataTable e jmp.DataTable.Column.
Derivato dall'esempio JSL "Vec Quadratic()' nello 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 risultati
/*:
//:*/
S = Python Get(s);
X = Python Get(x);
show(Vec Quadratic(S, X));
/*:
Vec Quadratic(S, X) = [292, 528];
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?@Paul_Nelson , grazie. Sapevo già cosa faceva la funzione JSL "Vec Quadratic()" prima di pubblicare. Mi scuso per aver formulato in modo inadeguato la mia domanda in questo post. Non tutti sono di madrelingua inglese in questo forum. E solo per completezza:
Il tuo commento:
Anche se invece di chiedere come replicare "Vec Quadratic()" di JSL ...
La mia domanda originale:
Come utilizzare numpy.polyfit per riprodurre i risultati Vec Quadratic()?
È l'uso del termine "riprodurre" ad essere offensivo?
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?... noti che presenta alcuni problemi con le manipolazioni delle matrici:)
dopo aver regolato le parentesi, ottieni:
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())
...che si adatta 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])
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?@Ressel Penso che la parte confusa della tua richiesta sia che Vec Quadratic() sta semplicemente eseguendo la matematica delle matrici come descritto dallo Scripting Index. Il risultato di Vec Quadratic() è semplicemente l'output delle operazioni sulla matrice.
Le formule stesse, che danno i valori del 95%, sono generate dalla piattaforma Fit Y by X. 'Fit y By X' è anche ciò che è responsabile della creazione della trama. Quindi la domanda, a quanto ho capito, è più accurata; Come posso eseguire un adattamento bivariato di y per x con livelli di confidenza in Python o numpy?
Penso che Vec Quadratic() sia il focus sbagliato poiché non ha creato la formula o le costanti, è solo un'operazione matematica nella formula generata.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?@Paul_Nelson , è corretto, cosa che ho capito solo più tardi (e sfruttato spudoratamente per accettare la mia risposta come soluzione). Per quanto riguarda questo e l'esatta formulazione della domanda, onestamente non ce l'avevo in me. Più si impara... Grazie mille per la condivisione e buon fine settimana.
(Ps: essendo una sofisticata società di software statistico, potresti quasi contare su ingegneri senza talento computazionale che facciano parte del modello di business. Nel bene e nel male.)
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Plaudo all'apertura di Jmp per Python:)
Come menziona @Paul_Nelson , ora con Jmp18, se manca una funzionalità in JMP, ogni utente può facilmente recuperarla da Python, con 2-3 righe di codice. incredibilmente utile!
D'altra parte, alcune conoscenze di Wikipedia sulla manipolazione delle matrici, DOE, regressione, reti neurali, ecc. Non hanno nulla di cui preoccuparsi se vengono "rubate".
Con le "funzionalità" provenienti da pacchetti Python aggiornati e all'avanguardia, saranno le "competenze trasversali", l'assenza di bug, l'interfaccia intuitiva, l' esperienza utente superiore a parlare a favore di JMP e separarlo dalla concorrenza:
Ri: Lista dei desideri - nuova etichetta: esperienza utente
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Forse il
NormalContour = sqrt(ChiSquare Quantile( 0.95, 2 ));
L'idea di Ellipse ti indicherà la giusta direzione. Faccio immagini, non statistiche, quindi potrei essere molto fuori strada. Ma per realizzare l'immagine dell'ellisse ho dovuto rispondere a una domanda simile.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?se chiedi a Copilot:
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Inoltre, penso che sia naturale che gli utenti che accedono al lavoro di analisi e automazione dei dati tramite JMP difficilmente abbiano una solida conoscenza di Python o di qualsiasi altro linguaggio di programmazione e scripting. JMP sta cercando in modo proattivo di reclutare questo tipo di utenti e rende (credo) facile passare allo scripting in JSL. Una volta che l'utente sviluppa e apprende, tuttavia, ci si può aspettare che ciò inneschi il desiderio di ulteriore conoscenza, almeno in alcuni casi e dopo aver superato la barriera iniziale della comprensione di alcuni concetti computazionali di base. Naturalmente la prima intuizione per questo tipo di utenti sarà quella di chiedere aiuto alla community, soprattutto dopo la pubblicizzata integrazione di Python in JMP 18. Infine, il fatto che un data scientist professionista abbia il compito di copiare ciò che uno statistico laico ha sviluppato in JMP per l'utilizzo in un contesto aziendale reale parla da solo. Anche se potrei sbagliare tutto.
Ri: Long shot: come utilizzare numpy.polyfit per riprodurre i risultati di Vec Quadratic()?Se qualcuno è interessato, il codice Python seguente sembra riprodurre esattamente ciò che sta facendo JMP in termini di calcolo dell'intervallo di confidenza attorno a una regressione. Questo blocco di codice può essere incollato direttamente in un notebook Jupyter. Oltre a calcolare le coordinate Y dell'intervallo di confidenza per ogni X nella regressione lineare, crea anche un grafico, calcola il coefficiente di regressione, l'intercetta, le incertezze associate e tabula i risultati.
Non credere di averlo scritto io stesso, ma è comunque utile per imparare.
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()
