Giulia è un linguaggio di programmazione ad alte prestazioni con numerosi strumenti di analisi numerica integrati. È facile da usare e vanta un ecosistema in rapida crescita di pacchetti utili per il calcolo scientifico, l'apprendimento automatico e molto altro. Julia, come JMP, è uno strumento prezioso per scienziati, ricercatori e ingegneri.
Julia è nota per la sua facile interoperabilità con altri linguaggi di programmazione, ed ero curioso di sapere quanto sarebbe stato difficile richiamare Julia da JSL. Se fosse possibile (e lo è!), vedo un grande potenziale nel richiamare Julia da JSL. Si potrebbero creare interfacce utente interattive per JMP che richiamano programmi Julia ad alte prestazioni. Si potrebbero creare modelli in Julia e visualizzare i risultati in JMP, o viceversa. Si potrebbero eseguire le parti più lente del flusso di lavoro di JMP in Julia.
Illustrerò due metodi per richiamare Julia da JSL. Il primo metodo utilizza JSL per richiamare Python, che a sua volta richiama Julia. Nel secondo metodo, integriamo Julia in una libreria a collegamento dinamico (DLL) scritta in C.
Tieni presente che non tratterò molto la programmazione in Julia. Se sei curioso di saperne di più su Julia, consulta la sua documentazione . Sono disponibili anche materiali didattici su Accademia Julia .
Chiamare Julia tramite Python
Python in JSL
JMP 14 ha aggiunto i comandi JSL per l'interfacciamento diretto con Python. Ecco un semplice esempio tratto dall'indice degli script:
// Initialize the Python interface
PythonInit();
// Submit some Python code to run as a JSL string
PythonSubmit("\[message = 'The quick brown fox jumps over the lazy dog']\");
// message is now a variable in Python and can be accessed from JSL with PythonGet()
getStr = PythonGet(message);
Show(getStr);
// Terminate the Python interface
PythonTerm();
PyJulia
Se potessimo richiamare Julia da Python, allora potremmo farlo anche da JSL. PyJulia è un pacchetto Python che permette proprio questo. Vediamo come configurarlo. Nota: sono riuscito a farlo funzionare con Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 e JMP 16.1 su Mac.
Supponendo che Python sia installato correttamente, la configurazione è la seguente:
Se non l'hai ancora fatto, installa Julia. Per le istruzioni, visita la pagina Istruzioni specifiche per la piattaforma per i binari ufficiali . Puoi scaricare l'ultima versione dalla pagina di download di Julia .
Successivamente, segui le istruzioni per installare PyJulia.
Se riesci a seguire le istruzioni d'uso di PyJulia in una normale sessione Python, sei a posto!
PyJulia in JSL
Ora, in JSL, devi prima inizializzare Julia nella tua sessione Python. Assicurati di passare il percorso del tuo eseguibile Julia come argomento con parola chiave runtime, come mostrato di seguito.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
Da qui, è possibile utilizzare Python Invia per eseguire qualsiasi codice Julia.
// Import the main module. This is Julia's workspace.
Python Submit("\[
from julia import Main
Main.xs = [1,2,3] # xs belongs to julia
sines = Main.eval("sin.(xs)") # This returns the sine of each element in xs
]\");
show(PythonGet(sines)); // [0.841470984807897 0.909297426825682 0.141120008059867]
Se hai installato altri pacchetti Julia, puoi accedervi tramite l'importazione Python. Qui ho usato Pandas.jl, DataFrames.jl e Lasso.jl per eseguire un algoritmo di adattamento del lasso per l'altezza su Big Class.jmp. Poi ho usato JMP Graph Builder per tracciare il grafico dei valori effettivi rispetto a quelli previsti.
// Convert datatable to julia dataframe
// Must convert it to a julia Pandas dataframe first
dt = open("$SAMPLE_DATA/Big Class.jmp");
Pythonsend(dt);
Python Submit(
"\[
from julia import Pandas
from julia import DataFrames
from julia import Lasso
Main.dt = dt
predicted = Main.eval("""
using Lasso
df = DataFrames.DataFrame(Pandas.DataFrame(dt))
m = fit(LassoModel, @formula(height ~ sex + weight), df)
predict(m, df)
""")
]\");
// Back to JMP where we plot Actual vs. Predicted
predicted = pythonget("predicted");
dt << newColumn("Predicted height", <
<SETVALUES></SETVALUES>
<P class="lia-align-center" style="text-align: center;" style="text-align: center;"><FONT size="2"><EM>Un grafico di Graph Builder che confronta i risultati effettivi con quelli previsti, calcolati in Julia.</EM></FONT></P> <P><SPAN class="lia-inline-image-display-wrapper lia-image-align-center" image-alt="plot.png" style="width: 385px;"><span class="lia-inline-image-display-wrapper" image-alt="plot.png" style="width: 385px;"><img src="https://us.v-cdn.net/6038925/uploads/images/41854i1D3222BA026053FF/plot.png" role="button" title="plot.png" alt="plot.png" /></span><SPAN class="lia-inline-image-caption" onclick="event.preventDefault();">plot.png</SPAN></SPAN></P> <BR /> <P><FONT size="5">Incorporare Julia in una DLL</FONT><BR /> È anche possibile <A href="https://docs.julialang.org/en/v1/manual/embedding/" target="_self" rel="nofollow noopener noreferrer">integrare Julia</A> nel codice C. Condividerò alcuni esempi banali, ma sono sicuro che qualcuno con maggiore familiarità con il C potrebbe approfondire ulteriormente l'argomento.</P> <P><STRONG><FONT size="4">CaricaDLL</FONT></STRONG><BR /> La chiave qui sta nella funzione <FONT face="courier new,courier">CaricaDLL</FONT> di JSL. Un'ottima risorsa per imparare a usare <FONT face="courier new,courier">CaricaDLL</FONT> è <A href="https://www.lexjansen.com/nesug/nesug10/ad/ad04.pdf" target="_blank" rel="noopener nofollow noreferrer">questo documento</A> . Come semplice esempio, possiamo prendere la seguente funzione C in un file chiamato test.c</P> // test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
} E compilare in una DLL
# On Mac
gcc -shared -o test.dylib test.c
# On Windows
gcc -shared -o test.dll test.c
Quindi in JMP possiamo chiamare la funzione C
dll = loadDLL(convertfilepath("/path/to/my/test.dylib"));
dll << declareFunction("myMultiply",
Convention( STDCALL ),
Arg(Double, "num1"),
Arg(Double, "num2"),
Returns( Double )
);
show(dll << myMultiply(Pi(), 100));
dll << unloadDLL; Julia DLL
Ora diamo un'occhiata a una DLL con del codice Julia incorporato. Creeremo una funzione che calcola il seno del suo input, dove l'input è espresso in gradi.
// call_julia.c
#include
double sineInDegrees(double degrees)
{
// required: setup the Julia context
jl_init();
// You can evaluate Julia code from strings
jl_value_t *factor = jl_eval_string("pi/180");
double factor_unboxed = jl_unbox_float64(factor);
double radians = degrees * factor_unboxed;
// You can call Julia functions directly
jl_function_t *func = jl_get_function(jl_base_module, "sin");
jl_value_t *argument = jl_box_float64(radians);
jl_value_t *ret = jl_call1(func, argument);
double ret_unboxed = jl_unbox_float64(ret);
jl_atexit_hook(0);
return ret_unboxed;
}
Esegui il comando seguente per la compilazione su Mac, dove $JULIA_DIR è una variabile d'ambiente che contiene il percorso del tuo eseguibile di Julia. Nel mio caso, il percorso era /Applications/Julia-1.7.app/Contents/Resources/julia. Non ho provato su Windows, ma un procedimento simile dovrebbe funzionare.
# On Mac
gcc -shared -o call_julia.dylib call_julia.c -fPIC -I$JULIA_DIR/include/julia -L$JULIA_DIR/lib -Wl,-rpath,$JULIA_DIR/lib -ljulia
Ora possiamo chiamare senoInGradi in JSL!
dll = loadDLL(convertfilepath("/path/to/my/call_julia.dylib"));
dll << declareFunction("sineInDegrees",
Convention( STDCALL ),
Arg( Double, "degrees" ),
Returns( Double )
);
show(dll << sineInDegrees(90)); // 1
dll << unloadDLL; Conclusione
Le interfacce Python e CaricaDLL di JSL ci permettono di andare oltre JMP e di interagire con Julia. Ci sono voluti alcuni tentativi ed errori per far funzionare il tutto, ma una volta configurato, funziona piuttosto bene. In questo post ho mostrato alcuni semplici esempi, ma vedo il potenziale per creare nuove e interessanti applicazioni combinando JMP e Julia.
Grazie per aver letto. Spero di avervi fornito informazioni utili e di avervi incuriosito a saperne di più.
Una nota sulle versioni
Sono riuscito a far funzionare Julia tramite Python solo con Julia 1.5 e la beta di Julia 1.8 su Mac. Non ho avuto successo nell'utilizzo di Julia tramite Python su Windows, ma non ho provato tante versioni come su Mac. Ho utilizzato JMP 16 per tutti i miei test.
