Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloSfondo
* Utilizzo di Python nell'ambiente di scripting JMP19.
* Creazione di un dataframe (df) da pandas a partire da una tabella dati JMP esistente (dt).
* Esecuzione di una funzione che richiede l'input di df e restituisce un nuovo risultato di df. Chiamiamola df_results.
* Trasferimento dei risultati alla colonna della tabella dati JMP.
Funziona, ma ci sono due cose che mi fanno sospettare di non farlo correttamente. Innanzitutto, ricevo un avviso nell'output del log locale. E poi, la prima volta che lo eseguo su un numero molto elevato di righe, ci vuole molto tempo. Il timer del mio codice indicava 25 secondi per 100.000 righe. Se lo rieseguo, la seconda volta ci vogliono 3 secondi. Ho impostato il timer in modo che mi fornisca dettagli su ogni passaggio, così da poter scoprire se una riga di codice impiegava la maggior parte del tempo.
Questa è la singola riga di codice che mi fa dubitare. Ci sono voluti 25 secondi per 100.000 righe SOLO la prima volta che è stata compilata la colonna inizialmente costante (o nulla, ho provato entrambe). Poi è diventato quasi 10 volte più veloce a ogni successiva esecuzione.
dt[NomeColonna] = df_results[NomeColonna]
Questo è il messaggio di avviso nel registro incorporato
FutureWarning: il trattamento delle chiavi come posizioni da parte di Series.__getitem__ è deprecato. In una versione futura, le chiavi intere saranno sempre trattate come etichette (in linea con il comportamento dei DataFrame). Per accedere a un valore in base alla posizione, utilizzare `ser.iloc[pos]`
Inoltre, ho eseguito questa operazione per un totale di 4 colonne diverse da 2 dataframe diversi. Tutte hanno mostrato lo stesso comportamento (e avviso). Lento alla prima esecuzione. Veloce a ogni ripetizione. Differenza trascurabile tra la colonna 1, 2, 3 o 4.
Questo è solo un sottoinsieme di una tabella di grandi dimensioni con 1,3 milioni di righe. Quindi, 25 secondi x 4 colonne diventeranno più di 250 secondi x 4 colonne se non riesco a capire come ottenere velocità maggiori al primo tentativo.
Grazie
Automazione e scriptingRe: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloIn JMP 18 era necessario costruire una tabella dati colonna per colonna a partire da un data frame. JMP 19 supporta il protocollo del data frame portatile, quindi è sufficiente una riga di codice per passare da un dt a un df e una riga di codice per passare da df a dt in memoria.
È importante ricordare che la prima volta che uno script Python viene eseguito in JMP, Python stesso deve essere inizializzato. La prima volta che si importa un pacchetto, questo deve essere caricato, possibilmente includendo librerie condivise o compilazione di bytecode dei file .py.
L'avviso proviene dal pacchetto pandas. Per cancellare l'avviso è necessario eseguire il comando ser.iloc[pos] suggerito. La tabella dati JMP dt può essere indicizzata tramite indice di colonna a partire da 0 o tramite nome di colonna. L'indice sarebbe più veloce poiché eviterebbe confronti tra stringhe.
Aiuto -> Indice scripting Categoria 'Python', jmp.from_dataframe. Esempio 'JMP in Pandas'.
import jmp
import jmputils
try:
if not jmputils.is_installed('pandas'):
jmputils.jpip('install', 'pandas', echo=False)
except Exception as e:
print(f'Install failed with exception: {e}')
import pandas as pd
dt = jmp.open(jmp.SAMPLE_DATA + "Big Class.jmp")
pandas_df = (pd.api.interchange.from_dataframe(dt))
print(pandas_df)
...
# new dt_result data table from dataframe df_result
dt_result = jmp.from_dataframe( df_result )
# or continue to do the loop on columns if you need to update the original data table from the resulting dataframe.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloE qual è il modo più veloce per riempire una singola colonna JMP con nuovi valori da Python?
ad esempio per una tabella dati con 100.000 righe?
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloGrazie Paul, implementerò jmp.from_dataframe per tornare alle tabelle dati ed evitare l'errore.
L'altra parte della mia domanda riguardava il motivo di una differenza di velocità così grande, e per rispondere dovevo assicurarmi di poter causare in modo affidabile la risposta di calcolo LENTA. All'inizio non ci sono riuscito. Tutte le esecuzioni, anche la prima dopo aver aperto JMP e caricato Python, erano decisamente veloci. Poi ho capito che potrebbe esserci una differenza critica. Se AGGIUNGO una nuova colonna (manualmente, non l'avevo ancora inserita nel codice) ed eseguo il codice, l'aggiornamento di quella nuova colonna sarà lento SOLO per la prima volta.
Come test, ho aggiornato 4 colonne, 3 delle quali preesistenti e la quarta appena creata. Ci è voluto 1 secondo per aggiornare 100.000 righe della colonna 1, un altro secondo per aggiornare la colonna 2, un altro per aggiornare la colonna 3 e infine 19 secondi per aggiornare la colonna 4.
Ho creato un'altra tabella e un'altra "nuova" quarta colonna. Se SALVO E CHIUDO la tabella dati con la nuova colonna, poi RIAPRO, poi eseguo il codice... la nuova quarta colonna si aggiorna in circa 1 secondo, veloce quanto ##1, 2 e 3. Fondamentalmente, se salvo solo, ma NON CHIUDO E RIAPRO la tabella dati con la nuova quarta colonna, poi eseguo il codice, ci vorranno comunque circa 19 secondi per aggiornare la colonna 4.
Questo mi fa capire che la velocità è dovuta a qualche stranezza nella gestione della memoria di JMP.
Non so se questo sia un problema che può/deve essere risolto, e forse lo è ancora solo se non uso il passaggio "from_dataframe". È un comportamento molto strano che sono contento di essere riuscito a ricreare. Ora posso provare la versione migliore del codice e vedere se il problema persiste.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloUno dei miei colleghi ha fatto notare che in JSL ci sono Start Data Update e End Data Update, quindi...
jmp.run_jsl( 'dt << Begin Data Update;' )
# your python code filling new column
...
jmp.run_jsl( 'dt << End Data Update;' )
Molto probabilmente vorremo supportare questa funzionalità da Python. Probabilmente utilizzeremo un blocco with per sospendere gli aggiornamenti dell'interfaccia utente della tabella quando si riempie/aggiorna un gran numero di righe.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloSarebbe come impostare l'intera colonna utilizzando dt[index] avvolto con jsl Begin Data Update
jmp.run_jsl( 'dt << Begin Data Update;' )
dt[ index ] = list_like_object # numpy array, list, dataframe column,...
jmp.run_jsl( 'dt << End Data Update;' )
Oppure rendendo invisibile la tabella dati finché non la si riempie, per poi renderla visibile.
import jmp
dt = jmp.DataTable('Powered By Python', 40, visibility='Invisible')
...
# fill table
...
jmp.globals['jdt'] = dt # set jdt in JSL to reference dt
jmp.run_jsl('::jdt << Show Window(1);')
Il parametro di visibilità facoltativo può essere JMP 19 e versioni successive. jmp.globals[ ] è una funzionalità 19.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolojmp.run_jsl('dt << Begin Data Update;' ) presuppone che dt sia la variabile JSL per la tabella in JSL e quindi anche sul lato Python. Ad esempio, come nel caso di un comando Python Send(dt); da JSL, ma non necessariamente lo stesso se la tabella è stata creata da Python.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloGrazie mille per la spiegazione.
Quindi, il codice:
dt[ index ] = list_like_object
In Pitone riempie la colonna passo dopo passo ? Qual è la causa del problema di velocità?
Sembra simile a
dt[ 0, columnname] = [values ...]
in JSL , che riempie la colonna in un unico passaggio e non necessita di essere racchiuso da dt << Inizio/fine aggiornamento dati
Buono a sapersi. Dove posso trovare ulteriore documentazione sui dettagli?
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloNon so quanti utenti sappiano quanto sia essenziale
dt << Begin Data Update;
serve per scrivere del buon codice. Ma sono sicuro che molti utenti non lo sanno.
Desiderio correlato da @bswedlove per ogni riga():
per ogni riga (aggiornamento dati=1, ...)
Ottima idea quella di istituzionalizzare una soluzione, per far scomparire il problema per l'utente (la soluzione c'è sempre).
Vale per JSL e Python.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolo" La tabella dati JMP dt può essere indicizzata tramite indice di colonna a partire da 0 o tramite nome di colonna. L'indice sarebbe più veloce poiché eviterebbe confronti tra stringhe. "
Sto cercando di riscrivere il codice utilizzando gli indici, ma non riesco a trovare la sintassi equivalente per determinare l'indice della colonna della tabella dati da un nome che ho per i dataframe.
dfColumnIndex = df.get_loc['NomeColonnaDataFrame']
dtColumnIndex = ???
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolo@jthi , come si chiamava "aggiungere del codice per risolvere un problema che non esiste"?
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloNel caso in cui df sia stato creato da un dt, si presumerebbe che abbiano lo stesso indice. Se hai aggiunto colonne al data frame o una non era l'origine dell'altra, allora usare dt['col_name'] = è probabilmente l'unica soluzione. Non dovrebbe essere così costoso rispetto a un indice, ma è un confronto tra stringhe e indicizzazione numerica diretta.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloTutto questo avviene grazie alla magia dei Protocol Buffer di Python, dove i dati vengono mappati in memoria tra i blocchi di memoria supportati. Potrebbe non essere necessario il bracketing con Begin | End Data Update, ma se non è possibile mappare l'intera colonna in una sola volta, ricorrerà all'iterazione sui valori, quindi il bracketing con le istruzioni Data Update è una buona soluzione di sicurezza.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloHo eseguito numerosi esperimenti e utilizzato metodi diversi. Alcuni hanno generato avvisi. Altri no. Il più semplice sembrava essere quello di creare un dt dal df e poi utilizzare il dt per trasferire i dati. Non ho mai generato un errore.
Tuttavia, per quanto riguarda il problema di velocità... l'UNICA cosa che faceva la differenza era se stavo cercando di scrivere valori in una colonna appena creata o se stavo cercando di scrivere valori in una colonna esistente al momento dell'apertura (o creazione) della tabella dati. Le colonne appena create si aggiornavano estremamente lentamente. Le colonne preesistenti si aggiornavano molto velocemente.
Risultati dell'ultimo testo su 100.000 righe. 4 parametri esistevano già e 5 nuove colonne sono state aggiunte prima di eseguire questo codice. Sono state aggiornate 9 colonne in totale.
#Tutti questi 'xfer' utilizzavano la sintassi dt['colname'] = dt_results['colname']. Non sono stati coinvolti DataFrame dopo che DF è stato utilizzato per creare dt_results.
Tempo di creazione del passaggio df_results: 0,3434 secondi
Tempo di trasferimento del parametro 1: 0,1795 secondi
Tempo di trasferimento del parametro 2: 0,1758 secondi
Tempo di creazione di Step df_results: 0,0231 secondi #Questo è un nuovo set di risultati restituiti da diverse funzioni df.
Tempo di trasferimento del parametro 3: 0,1838 secondi
Tempo di trasferimento del parametro 4: 0,1890 secondi
#Il codice qui era: dt['NewCol1Test'] = df_results[stringnameofcolumn]
FutureWarning: il trattamento delle chiavi come posizioni da parte di Series.__getitem__ è deprecato. In una versione futura, le chiavi intere saranno sempre trattate come etichette (in linea con il comportamento dei DataFrame). Per accedere a un valore in base alla posizione, utilizzare `ser.iloc[pos]`
df a dt con nomi tempo di trasferimento: 15,8251 secondi
#Il codice qui era: dt['NewCol2Test'] = df_results.iloc[:,dfColumnIndex]
FutureWarning: il trattamento delle chiavi come posizioni da parte di Series.__getitem__ è deprecato. In una versione futura, le chiavi intere saranno sempre trattate come etichette (in linea con il comportamento dei DataFrame). Per accedere a un valore in base alla posizione, utilizzare `ser.iloc[pos]`
#Non so perché quell'avviso è stato comunque visualizzato quando ho usato iloc
df a dt con tempo di trasferimento iloc: 16,0874 secondi
#Il codice qui era: dt['NewCol3Test'] = dt_results[dfColumnIndex]
tempo di trasferimento dell'indice dt al nome dt: 14,5659 secondi
#Il codice qui era: dt[NewColumnIndex] = dt_results[dfColumnIndex]
tempo di trasferimento da indice dt a indice dt: 14,4699 secondi
#Il codice qui era:
jmp.run_jsl('dt << Inizia aggiornamento dati;')
dt['NewCol5Test'] = dt_results[dfColumnIndex]
jmp.run_jsl('dt << Fine aggiornamento dati;')
#Risultato avviso/errore:
"Nome non risolto: dt in accesso o valutazione di 'dt', dt/*###*/
alla riga 1
Nome non risolto: dt nell'accesso o nella valutazione di 'dt', dt/*###*/
alla riga 1"
#Questa stampa era in realtà sulla stessa riga del secondo messaggio di errore 'alla riga 1'.
indici dt a dt w racchiusi nel tempo di trasferimento dell'aggiornamento di inizio/fine: 14,3627 secondi
#Riepilogo finale del tempo di esecuzione su 100.000 righe.
Tempo di esecuzione totale: 77,0904 secondi
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolosalva i tuoi dati (*) prima di eseguire questo codice una seconda volta (**) - oppure abilita l'aggiornamento dei dati di inizio/fine!
import jmp
import numpy as np
dt = jmp.open(jmp.SAMPLE_DATA + "Wafer Stacked.jmp")
jmp.globals['jdt'] = dt
jmp.run_jsl('Graph Builder( Variables( Y( :defects ) ), Elements( Bar( Y, Label( "Label by Value" ) ) ))');
# jmp.run_jsl('jdt << Begin Data Update;')
dt[ 5 ] = [np.random.randint(1000)]*177875
# jmp.run_jsl('jdt << End Data Update;')
(*) Sto scherzando, non perderai i tuoi dati: prenditi un caffè e aspetta che JMP finisca.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolo
@hogi ha scritto:
... una seconda volta (**)
(**) TS - 00251136
@Dahlia_Watkins ha notato che a volte sono necessarie 2 esecuzioni del codice per risolvere il problema di velocità.
Sembra un "problema" di tempistica.
Forse: quando esegui il codice per la prima volta, il grafico non viene creato finché Python non termina l'aggiornamento dei dati riga per riga.
modificare:
In realtà, il grafico non è necessario come elemento interattivo per rallentare l'aggiornamento dei dati Python.
Ulteriori esempi senza elementi interattivi possono essere trovati nei post seguenti.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloHo aggiunto l'argomento a Attenzione: Luoghi in cui Jmp fa qualcosa di inaspettato
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloPer il problema originale: "accesso ai dati lento SE c'è una nuova colonna"
ecco un esempio illustrativo:
import jmp
dt = jmp.DataTable('dt_new', 50000)
col = dt.new_column("newCol")
# --------- cut here to make it slow - why? -------------
dt[ 0 ] = [1]*50000
Suddiviso in 2 passaggi, JMP impiegherà diversi secondi per aggiornare le 50.000 voci.
sconcertante:
Quando si eseguono entrambi i blocchi in un'unica esecuzione, JMP non presenta alcun problema.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloOltre alle soluzioni alternative menzionate nel post di @Paul_Nelson , pensavo ce ne fossero altre, come:
- Utilizzare JSL per creare la colonna/la tabella dati
- Utilizzare JSL per riempire la colonna con valori fittizi
- usa JSL per salvare la tabella dati, chiuderla e riaprirla
Molti di loro sembrano belli a prima vista, ma sono fuorvianti.
L'elevata velocità è dovuta semplicemente al fatto che gli stessi valori vengono scritti nuovamente nella colonna e JMP non attiva un "avviso di aggiornamento dati":
per esempio
jmp.globals['jdt'] = dt
jmp.run_jsl('''
nc = n cols(jdt);
Column(jdt,nc) << set each value(1)
''');
nc = dt.ncols
data = [1]*50000
dt[ nc - 1 ] =data
lo stesso miracolo tramite Python:
# 1st: slow
nc = dt.ncols
dt[ nc - 1 ] = range(50000)
# fast ! (same values!)
dt[ nc - 1 ] = range(50000)
# new values: slow again
dt[ nc - 1 ] = [5]*50000
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloÈ possibile impostare un trigger per ricevere una notifica quando JMP ritiene che i dati siano stati aggiornati.
import jmp
dt = jmp.open(jmp.SAMPLE_DATA + "Big Class.jmp")
jmp.run_jsl('''
New Column( "trigger",
Formula(
If( Row() == 1,
Try( Caption( Char( ::i=::i+1 ) ), ::i = 1 )
);
:age;i
)
)
''')
dt[ 1 ] = range(40)
dt[ 1 ] = range(40) # no data update !
dt[ 1 ] = [2]*40
# for loop without begin/end data update -> finished before JMP notices the data update
jmp.run_jsl('''
for each row(:age = row());
wait(5);
''')
# for loop without begin/end data update - and some delay to give JMP the time to notice:
jmp.run_jsl('''
for each row(:age = 2*row();wait(0))
''')
Quindi, in effetti, non si verifica alcun "aggiornamento dei dati" quando i valori originali e quelli nuovi sono identici.
Implementato per combattere i loop infiniti? Fantastico!
Interessante,
import jmp
dt = jmp.open(jmp.SAMPLE_DATA + "Wafer Stacked.jmp")
jmp.run_jsl('''
delete symbols(::i)
New Column( "trigger",
Formula(
If( Row() == 1,
Try( Caption( Char( ::i=::i+1 ) ), ::i = 1 )
);
:Y_Die;i
)
)
''')
nr = dt.nrows
dt[ 4 ] = range(nr)
ci vuole più di 1 minuto - E conta fino a 2.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcolo
@Paul_Nelson wrote:
...
Most likely we will want to do support this from Python. Probably using a with block to suspend the UI updates of the table when filling / updating large number of rows.
ottima idea!
Si prega di prestare attenzione a riattivare l'interattività anche quando Python genera un errore nel blocco "with".
In alternativa:
Aggiungere un indicatore alla griglia dati per mostrare quando l'interattività è disabilitata perché c'era un
iniziare l'aggiornamento dei dati senza terminarlo .
Indicatore: interattività disabilitata per questa tabella dati
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloRisultati dei post precedenti - compressi in:
import jmp
# open data table and wait for the "Interactivity Manager" to get active
jmp.run_jsl('''
dt = new table("test", add rows(100000), new column ("col"));
Python send(dt);
wait(0) // disable the delay to make it fast
'''
);
nr=dt.nrows
# Python data update: slow!
dt[ 0 ] = range(nr)
# --- run step by step: -----
# same values: fast
dt[ 0 ] = range(nr)
#new values: slow
dt[ 0 ] = [1]*nr
Aggiornare una colonna JSL tramite Python è molto lento.
Eccezioni:
- accesso in scrittura subito dopo la creazione/apertura della tabella dati (prima che sia attivo un qualche tipo di "Interactivity Manager")
- nessun aggiornamento (i valori non cambiano)
e le soluzioni alternative menzionate nel post di @Paul_Nelson :
- tabelle di dati privati
- Aggiornamento dei dati Python racchiuso da Aggiornamento dati inizio/fine JSL()
Accesso rapido ai dati Python, solo con il supporto di JSL ; )
Immagino che i problemi siano abbastanza gravi da essere risolti nella prossima versione ".x"...
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloIn realtà, nel secondo caso, deve essere una tabella privata, visibility='Private'. La tabella 'Invisible' ha comunque un'interfaccia grafica, anche se è nascosta, e come tale è ancora lenta a causa degli aggiornamenti dell'interfaccia grafica che avvengono nella tabella dati a ogni modifica di cella.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloSì, è significativo. Stiamo effettivamente cercando una soluzione. Vogliamo che le prestazioni di Python siano tali che gli utenti vogliano eseguirlo da Python senza dover ricorrere a metodi magici backdoor per ottenere prestazioni migliori.
Sono sorpreso che questo non sia apparso in JMP 18 o durante i test EA di JMP 19. L'oggetto jmp.DataTable, al suo interno, è la tabella dati JSL. L'oggetto Python è solo un riferimento alla tabella dati JMP sottostante, e stiamo chiamando i metodi interni della tabella dati JMP, ed è per questo che run_jsl('dt << Begin Data Update') fa la differenza. L'unico scopo del codice jmp.run_jsl(''' '''') era consentire la chiamata a JSL da Python per cose che non abbiamo ancora implementato, o come in questo caso, correggere una svista nelle prestazioni di aggiornamento delle colonne.
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloSono felice che il problema sia stato risolto.
Perché non è stato rilevato prima?
Immagino che molti utenti utilizzino Python per l'importazione/cura dei dati, prima di trasferirli su JMP, senza intervenire sui dati tramite Python. Se usano Python get(dt)[JSL] o from_dataframe() [Python], non avranno questo problema.
Avvertenza: trasferimento colonna per colonna come in Introduzione all'integrazione di Python in JMP 18.
In questo caso, dipende dalle dimensioni della tabella dati. Se la tabella è sufficientemente piccola, le nuove colonne vengono aggiunte prima dell'attivazione del "Gestione interattività".
Quando abbiamo rilevato il problema, abbiamo avuto accesso a JMP19EA e siamo stati felici di vedere che potevamo accelerare la generazione della tabella tramite from_dataframe() , con l'ulteriore vantaggio di un codice molto più semplice.
D'altro canto: il problema si presenta quando Python viene utilizzato per aggiornare singole colonne di una tabella dati JMP esistente, come in JMPyFacade: Bridging JMP and Python for Seamless Engaging Analysis . Da esperto di JSL, @jthi ha sicuramente aggiunto la necessaria soluzione alternativa Private-Table-merge data, senza troppi problemi ; )
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloInformazioni condivise oggi nello Scripters Club:
il problema di velocità con
dt[ index ] = list_like_object
verrà risolto in JMP 19.0.3 : )
Re: Python in JMP: best practice per la conversione da colonna dataframe a colonna datatable e implicazioni sulla velocità di calcoloDisponibile ora:
