Julia ist eine leistungsstarke Programmiersprache mit vielen nützlichen numerischen Analysewerkzeugen, die eingebaut sind. Es ist einfach zu schreiben und verfügt über ein schnell wachsendes Ökosystem nützlicher Pakete für wissenschaftliches Rechnen, maschinelles Lernen und vieles mehr. Julia ist wie JMP ein unschätzbares Werkzeug für Wissenschaftler, Forscher und Ingenieure.
Julia ist für ihre einfache Interoperabilität mit anderen Programmiersprachen bekannt, und ich war neugierig, wie schwierig es wäre, Julia von JSL anzurufen. Wenn es möglich wäre (es geht!), Ich sehe viel Potenzial darin, Julia von JSL anzurufen. Sie könnten interaktive JMP-Benutzeroberflächen erstellen, die hochleistungsfähige Julia-Programme aufrufen. Sie könnten Modelle in Julia erstellen und Ergebnisse in JMP darstellen oder umgekehrt. Sie könnten die langsamen Teile Ihres JMP-Workflows in Julia erledigen.
Ich werde zwei Methoden zum Aufrufen von Julia von JSL aus erörtern. Die erste Methode verwendet JSL, um Python aufzurufen, um Julia aufzurufen. Bei der zweiten Methode betten wir Julia in eine in C geschriebene Dynamic-Link-Library (DLL) ein.
Beachten Sie, dass ich nicht viel über die Programmierung in Julia berichten werde. Wenn Sie neugierig sind, mehr über Julia zu erfahren, schauen Sie sich ihre an Dokumentation . Es gibt auch Lernmaterialien von Julia Akademie .
Aufruf von Julia über Python
Python in JSL
JMP 14 fügte JSL-Befehle für die direkte Verbindung mit Python hinzu. Hier ist ein einfaches Beispiel aus dem Scripting-Index:
// 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
Wenn wir Julia von Python aus anrufen könnten, könnten wir Julia von JSL aus anrufen. PyJulia ist ein Python-Paket, mit dem Sie genau das tun können. Lassen Sie es uns einrichten. Hinweis: Ich konnte erfolgreich Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 und JMP 16.1 auf dem Mac verwenden.
Unter der Annahme einer funktionierenden Python-Installation sieht die Einrichtung wie folgt aus:
Falls noch nicht geschehen, installieren Sie Julia. Anweisungen finden Sie unter Plattformspezifische Anweisungen für offizielle Binärdateien . Downloads der neuesten Version sind unter verfügbar Julia-Download-Seite .
Folgen Sie als nächstes der Anweisungen um PyJulia zu installieren.
Wenn Sie in der Lage sind, PyJulia's zu verwenden Gebrauchsanweisung In einer regulären Python-Sitzung können Sie loslegen!
PyJulia in JSL
Jetzt müssen Sie in JSL zuerst Julia in Ihrer Python-Sitzung initialisieren. Stellen Sie sicher, dass Sie den Pfad zu Ihrer ausführbaren Julia-Datei als Laufzeit-Schlüsselwortargument wie unten angegeben übergeben.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
Von hier aus können Sie verwenden Python einreichen um einen beliebigen Julia-Code auszuführen.
// 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]
Wenn Sie andere Julia-Pakete installiert haben, können Sie per Python-Import darauf zugreifen. Hier habe ich Pandas.jl, DataFrames.jl und Lasso.jl verwendet, um ein höhengerechtes Lasso auf Big Class.jmp auszuführen. Dann verwende ich JMP Graph Builder, um den tatsächlichen vs. vorhergesagten Wert darzustellen.
// 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>
Ein tatsächliches vs. vorhergesagtes Graph Builder-Diagramm mit in Julia berechneten Ergebnissen
Julia in eine DLL einbetten
Es ist auch möglich Julia einbetten im C-Code. Ich werde einige triviale Beispiele vorstellen, aber ich bin sicher, dass jemand, der sich mit C besser auskennt, dies weiter ausführen könnte.
DLL laden
Der Schlüssel hier ist der von JSL DLL laden Funktion. Eine großartige Ressource zum Erlernen der Verwendung DLL laden ist dieses Papier . Als einfaches Beispiel können wir die folgende C-Funktion in einer Datei namens test.c nehmen
// test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
}
Und zu einer DLL kompilieren
# On Mac
gcc -shared -o test.dylib test.c
# On Windows
gcc -shared -o test.dll test.c
Dann können wir in JMP die C-Funktion aufrufen
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
Werfen wir nun einen Blick auf eine DLL mit eingebetteter Julia. Wir werden eine Funktion erstellen, die den Sinus ihrer Eingabe berechnet, wobei die Eingabe in Grad erfolgt.
// call_julia.c
#include <julia.h>
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;
}
Führen Sie das Folgende aus, um auf einem Mac zu kompilieren, wo $JULIA_DIR ist eine Umgebungsvariable mit dem Pfad zu Ihrer Julia-Binärdatei. Bei mir war das /Applications/Julia-1.7.app/Contents/Resources/julia. Ich habe das nicht unter Windows ausprobiert, aber etwas Ähnliches sollte funktionieren.
# 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
Jetzt können wir anrufen sinInDegrees im 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;
Fazit
JSLs Python und DLL laden Schnittstellen ermöglichen es uns, über JMP hinauszugehen und Julia anzurufen. Es hat einige Versuche und Irrtümer gedauert, um dies zum Laufen zu bringen, aber sobald es eingerichtet ist, funktioniert es ziemlich gut. Ich habe in diesem Beitrag einige einfache Beispiele gezeigt, aber ich sehe das Potenzial, neue und interessante Anwendungen mit JMP und Julia zusammen zu erstellen.
Danke fürs Lesen. Ich hoffe, ich habe Sie informiert und neugierig gemacht.
Eine Anmerkung zu den Versionen
Ich konnte Julia nur mit Julia 1.5 und Julia 1.8 Beta auf dem Mac dazu bringen, mit Python zu arbeiten. Ich hatte keinen Erfolg mit Julia über Python unter Windows, aber ich habe nicht so viele Versionen wie auf dem Mac ausprobiert. Ich habe JMP 16 für alle meine Tests verwendet.
