Julia ist eine leistungsstarke Programmiersprache mit vielen integrierten, nützlichen Werkzeugen für die numerische Analyse. Sie ist leicht zu erlernen und verfügt über ein schnell wachsendes Ökosystem an nützlichen Paketen 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 bekannt für seine einfache Interoperabilität mit anderen Programmiersprachen, und ich war neugierig, wie schwierig es wäre, Julia aus JSL aufzurufen. Wenn es möglich ist (und das ist es!), sehe ich großes Potenzial darin, Julia aus JSL aufzurufen. Man könnte interaktive JMP-Benutzeroberflächen erstellen, die hochperformante Julia-Programme aufrufen. Man könnte Modelle in Julia erstellen und die Ergebnisse in JMP visualisieren oder umgekehrt. Man könnte die rechenintensiven Teile des JMP-Workflows in Julia ausführen.
Ich werde zwei Methoden zum Aufruf von Julia aus JSL erläutern. Die erste Methode verwendet JSL, um Python und anschließend Julia aufzurufen. Bei der zweiten Methode betten wir Julia in eine in C geschriebene Dynamic-Link Library (DLL) ein.
Ich werde hier nicht näher auf die Programmierung in Julia eingehen. Wenn Sie mehr über Julia erfahren möchten, empfehle ich Ihnen die Dokumentation . Lernmaterialien dazu finden Sie auch bei der Julia-Akademie .
Julia über Python aufrufen
Python in JSL
JMP 14 hat JSL-Befehle für die direkte Interaktion mit Python hinzugefügt. Hier ist ein einfaches Beispiel aus dem Skriptindex:
// 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 aufrufen könnten, dann könnten wir Julia auch von JSL aus aufrufen. PyJulia ist ein Python-Paket, das genau das ermöglicht. Legen wir los! Hinweis: Ich habe Julia 1.5.4, Python 3.9.5, PyJulia 0.5.7 und JMP 16.1 erfolgreich auf einem Mac verwendet.
Bei einer funktionierenden Python-Installation sieht die Einrichtung wie folgt aus:
Falls noch nicht geschehen, installieren Sie Julia. Anweisungen dazu finden Sie unter Plattformspezifische Anweisungen für offizielle Binärdateien . Die neueste Version steht auf der Julia-Downloadseite zum Download bereit.
Folgen Sie anschließend den Anweisungen zur Installation von PyJulia.
Wenn Sie die Nutzungshinweise von PyJulia in einer regulären Python-Sitzung anwenden können, sind Sie bestens gerüstet!
PyJulia in JSL
In JSL müssen Sie zunächst Julia in Ihrer Python-Sitzung initialisieren. Achten Sie darauf, den Pfad zu Ihrer Julia-Programmdatei als Laufzeitargument wie unten gezeigt zu übergeben.
Python Init();
// Initialize julia
Python Submit(
"\[
from julia import Julia
Julia(runtime="/usr/local/bin/julia")
]\");
Von hier aus können Sie mit Python Submit beliebigen Julia-Code ausfü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]
Falls Sie weitere Julia-Pakete installiert haben, können Sie diese per Python-Import einbinden. Hier habe ich Pandas.jl, DataFrames.jl und Lasso.jl verwendet, um eine Lasso-Anpassung für die Körpergröße auf BigClass.jmp durchzuführen. Anschließend nutze ich den JMP Graph Builder, um die tatsächlichen Werte den vorhergesagten Werten gegenüberzustellen.
// 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>Ein Diagramm mit Ist- und Soll-Werten aus dem Graph Builder, dessen Ergebnisse in Julia berechnet wurden.</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">Einbetten von Julia in eine DLL</FONT><BR /> Es ist auch möglich, <A href="https://docs.julialang.org/en/v1/manual/embedding/" target="_self" rel="nofollow noopener noreferrer">Julia in C-Code einzubetten</A> . Ich werde einige einfache Beispiele aufzeigen, aber jemand mit besseren C-Kenntnissen kann das sicher noch weiter ausführen.</P> <P><STRONG><FONT size="4">LoadDLL</FONT></STRONG><BR /> Der Schlüssel liegt hier in der <FONT face="courier new,courier">LoadDLL</FONT> -Funktion von JSL. Eine hervorragende Ressource zum Erlernen der Verwendung <FONT face="courier new,courier">von LoadDLL</FONT> ist <A href="https://www.lexjansen.com/nesug/nesug10/ad/ad04.pdf" target="_blank" rel="noopener nofollow noreferrer">dieses Dokument</A> . Als einfaches Beispiel können wir die folgende C-Funktion in einer Datei namens test.c betrachten.</P> // test.c
double myMultiply(double num1, double num2)
{
return num1 * num2;
} Und kompilieren Sie zu einer DLL
# 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
Schauen wir uns nun eine DLL mit eingebettetem Julia-Code an. Wir erstellen eine Funktion, die den Sinus ihres Eingabewerts berechnet, wobei der Eingabewert in Grad angegeben wird.
// 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;
}
Führen Sie den folgenden Befehl aus, um Julia unter macOS zu kompilieren. Dabei ist `$JULIA_DIR` eine Umgebungsvariable, die den Pfad zu Ihrer Julia-Binärdatei enthält. Bei mir war das `/Applications/Julia-1.7.app/Contents/Resources/julia`. Ich habe es nicht unter Windows getestet, aber ein ähnlicher Befehl 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 sineInDegrees in JSL aufrufen!
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; Abschluss
Die Python- und LoadDLL- Schnittstellen von JSL ermöglichen es uns, über JMP hinauszugehen und Julia aufzurufen. Es bedurfte einiger Versuche, bis dies funktionierte, aber sobald es eingerichtet ist, läuft es recht gut. Ich habe in diesem Beitrag einige einfache Beispiele gezeigt, sehe aber das Potenzial, mit der Kombination von JMP und Julia neue und interessante Anwendungen zu entwickeln.
Vielen Dank fürs Lesen. Ich hoffe, ich konnte Sie informieren und Ihre Neugier auf weitere Entdeckungen wecken.
Ein Hinweis zu den Versionen
Ich konnte Julia nur mit den Versionen 1.5 und 1.8 Beta auf einem Mac über Python zum Laufen bringen. Unter Windows hatte ich keinen Erfolg mit Julia über Python, allerdings habe ich dort auch nicht so viele Versionen getestet wie auf dem Mac. Für alle Tests verwendete ich JMP 16.
