web-dev-qa-db-fra.com

Lier R et Julia?

Julia semble très prometteuse pour un calcul rapide et sain sur le plan de la syntaxe (par exemple ici ), mais je soupçonne que ce ne sera pas n'importe où près de R en termes de flux de travail statistique global pendant un certain temps. Je voudrais donc l'utiliser là où C++ est principalement utilisé dans les programmes R: pour optimiser les portions lentes de code. Avant d'investir du temps dans l'apprentissage de Julia, je suis curieux de savoir quelles sont les installations permettant d'incorporer des extraits de code Julia dans le code R.

Alors:

  • Quelles sont les installations disponibles pour relier R et Julia?
  • À quel point sont-ils robustes et bien pensés, sur une échelle de zéro à Rcpp?

Je veux appeler Julia depuis R, tout comme Rcpp permet d'appeler C++ à partir de R en ce moment. Je ne veux pas appeler R de Julia. (Donc RCall.jl ne fonctionnerait pas)

rjulia
123
Ari B. Friedman

Le paquet RJulia R semble assez bien maintenant de R. R CMD check s'exécute sans avertissement ni erreur (si Julia est correctement installé).

À mon avis, le plus grand TODO est de faire en sorte que Julia retourne des listes nommées qui constituent la structure de données générale flexible vraiment basique dans R.

Notez que Doug Bates m'a alerté sur RCall une interface bidirectionnelle de Julia vers R (c'est-à-dire, l'autre direction que R vers Julia). Doug a également recommandé de cibler Julia 0.4.0 plutôt que les versions stables actuelles de Julia.

36
Martin Mächler

Moi aussi je regarde Julia depuis que Doug Bates m'a envoyé un avertissement en janvier . Mais comme @ gsk3, je le mesure sur une "échelle Rcpp" car je voudrais passer des objets R riches à Julia. Et cela ne semble pas du tout pris en charge en ce moment.

Julia a une interface C agréable et simple. Cela nous donne donc quelque chose comme .C(). Mais comme récemment discuté sur r-devel, vous ne voulez vraiment pas .C(), dans la plupart des cas vous voulez plutôt .Call() afin de passer des variables SEXP réelles représentant de vrais objets R. Donc en ce moment je vois peu de place pour Julia de R à cause de cette limitation.

Peut-être qu'une interface indirecte utilisant tcp/ip à Rserve pourrait être un premier démarrage avant que Julia ne mûrisse un peu et que nous obtenions une interface C++ appropriée. Ou nous utilisons quelque chose basé sur Rcpp pour passer de R à C++ avant d'entrer dans une couche intermédiaire [que quelqu'un devrait écrire] à partir de laquelle nous transmettons des données à Julia, tout comme l'API R réelle ne propose qu'une couche C. Je ne sais pas.

Et à la fin de la journée, il faudra peut-être faire preuve de patience. J'ai commencé à regarder R vers 1996 ou 1997 lorsque Fritz Leisch a fait les premières annonces sur le newsgroup comp.os.linux.announce. Et R avait des installations assez limitées à l'époque (mais la pleine promesse du langage S, bien sûr, si nous savions que nous avions un gagnant). Et quelques années plus tard, j'étais prêt à en faire mon principal langage de modélisation. A cette époque, le CRAN avait encore bien moins de 100 colis ...

Julia pourrait bien y arriver. Mais pour l'instant, je soupçonne que beaucoup d'entre nous vont faire du travail dans R, et avoir juste quelques aperçus curieux sur Julia.

54
Dirk Eddelbuettel

Le plan de développement de Julia, comme je l'ai décrit dans cette réponse est de permettre la compilation de code Julia dans des bibliothèques partagées, appelables à l'aide de C ABI. Une fois que cela se produit, il sera aussi facile d'appeler du code Julia à partir de R que d'appeler du code C/C++. Il y a cependant une bonne quantité de travail requis avant que cela ne devienne possible.

46
StefanKarpinski

Une mise à jour rapide. Depuis que cette question a été posée, il y a eu les débuts d'un package Julia qui permet d'appeler des programmes R depuis Julia.

Plus ici: https://github.com/lgautier/Rif.jl

21
aviks

Quelqu'un a vu ce projet?

https://github.com/armgong/RJulia

Assez nouveau mais semble faire exactement ce qui est demandé!

12
Adam

J'ai créé récemment un package R appelé JuliaCall, qui intègre Julia dans R. Le package est sur CRAN.

https://cran.r-project.org/web/packages/JuliaCall/index.html

https://github.com/Non-Contradiction/JuliaCall

L'utilisation du package est la suivante:

library(JuliaCall)
Julia <- Julia_setup()
Julia_command("a = sqrt(2)"); Julia_eval("a")
Julia_eval("sqrt(2)")
Julia_call("sqrt", 2)
Julia_eval("sqrt")(2)

Comme vous pouvez le voir, vous pouvez envoyer des chaînes de commande et appeler des fonctions Julia très facilement.

Et il y a aussi des packages R qui enveloppent les packages Julia en utilisant JuliaCall, par exemple,

  • convexjlr pour la programmation convexe disciplinée en R utilisant Convex.jl, qui est également sur CRAN.
  • ipoptjlr , une interface R pour Interior Point OPTimizer (IPOPT) utilisant le package Julia Ipopt.jl.

Bienvenue pour tout commentaire sur JuliaCall !!

8
Consistency

Il existe également la package XRJulia de XR famille de packages visant à e [~ # ~] x [~ # ~] tendance [~ # ~] r [~ # ~] par John Chambers (l'un des créateurs de R). Il utilise une approche un peu différente (JSON) pour transférer des données entre Julia et R puis rJulia et des packages similaires.

6
vh-d

Vous pourriez également vouloir vérifier ma tentative: Le JuliaConnector R-package.

Son objectif est d'importer des fonctions de Julia directement dans R de sorte qu'elles puissent être utilisées comme des fonctions R dans le code R. Les valeurs de retour des fonctions Julia sont converties en structures de données R, qui peuvent être utilisées dans R et également renvoyées à Julia. Cela fonctionne déjà de manière stable pour les structures de données de base. Le package n'est encore que la version 0.1, mais je le développe activement et le plan est d'avoir un produit prêt pour la production d'ici la fin de 2019. Pour une nouvelle intégration de Julia et R, il est également possible de rappeler de Julia à R en passant des fonctions R comme fonctions de rappel.

Semblable à XRJulia, le JuliaConnectoR s'appuie sur TCP, mais il est orienté fonctionnellement et utilise un format de streaming personnalisé optimisé au lieu de messages JSON basés sur du texte comme le fait XRJulia. Un avantage de communiquer par TCP est la stabilité par rapport aux différentes versions de Julia et R. Ceci est beaucoup plus difficile à maintenir avec une intégration au niveau des interfaces C comme RCall et JuliaCall.

Le package fonctionne avec Julia ≥ 0,7 et une large gamme de versions R.

2
esel