klongpy
0.6.8
Klongpy est une adaptation python du langage du tableau Klong, connu pour ses opérations vectorisées haute performance qui exploitent la puissance de Numpy. Embrassant une philosophie "Batteries incluse", Klongpy combine des modules intégrés avec l'écosystème vaste de Python, facilitant le développement rapide des applications avec la syntaxe succincte de Klong.
Klongpy est ainsi un outil robuste, mélangeant la simplicité de Klong avec les grandes capacités de Python, adaptées à un large éventail de tâches de calcul.
pip3 install " klongpy[full] "Klongpy est à la fois un runtime de langage du tableau et un ensemble d'outils puissants pour créer une analyse de données hautes performances et des applications informatiques distribuées. Certaines des fonctionnalités incluent:
Explorez Klongpy avec ces exemples. Chaque extrait met en évidence un aspect unique de Klong, démontrant sa polyvalence dans divers scénarios de programmation.
Avant de commencer, vous vous demandez peut-être: pourquoi la syntaxe est-elle si laconique?
La réponse est qu'elle est basée sur la programmation du langage Array de style APL et il y a une bonne raison pour laquelle sa nature compacte est réellement utile.
Le style du langage de table vous permet de décrire ce que vous voulez que l'ordinateur fasse et il permet à l'ordinateur de comprendre comment le faire. Cela vous libère des détails tout en permettant à l'ordinateur de déterminer comment aller aussi vite que possible.
Moins de code pour écrire et une exécution plus rapide.
Juste pour que les exemples suivants aient plus de sens lorsque vous voyez les sorties REP, il y a quelques règles rapides sur les fonctions de klong. Les fonctions ne prennent que jusqu'à 3 paramètres et ils sont toujours appelés x, y et z.
Une fonction avec
La raison pour laquelle les fonctions de KLONG ne prennent que 3 paramètres et les nomment pour vous est à la fois la convidité et la compacité.
$ rlwrap kgpy
Welcome to KlongPy REPL v0.6.0
Author: Brian Guarraci
Web: http://klongpy.org
]h for help ; crtl-d or ]q to quit
? > Commençons par les bases et construisons des mathématiques plus intéressantes. Les expressions sont évaluées de droite à gauche: 3 * 2 puis + 5
?> 5+3*2
11
Klongpy est davantage sur les tableaux de choses, alors définissons la somme et comptons les fonctions sur un tableau:
?> sum::{+/x} :" sum + over / the array x
:monad
?> sum([1 2 3])
6
?> count::{#x}
:monad
?> count([1 2 3])
3
Maintenant que nous connaissons la somme et le nombre d'éléments, nous pouvons calculer la moyenne:
?> avg::{sum(x)%count(x)} :" average is the sum divided by the number of elements
:monad
?> avg([1 2 3])
2
Faisons des opérations plus intéressantes sur les éléments du tableau. Il y a de très grandes différences de performances dans la façon dont vous abordez le problème et il est important de voir la différence.
Pour le cas simple de numéros carrés dans une liste, essayons quelques solutions:
?> {x*x}'[1 2 3 4 5] :" square each element as we iterate over the array
[1 4 9 16 25]
L'approche vectorisée fera une multiplication par élément en vrac:
?> a::[1 2 3 4 5];a*a :" a*a multiplies the arrays
[1 4 9 16 25]
L'approche vectorisée va être beaucoup plus rapide. Passons à la taille du tableau et à l'heure:
$> .l("time")
:monad
$> a::!1000;#a
1
$> fast::{{a*a}'!1000}
:nilad
$> slow::{{{x*x}'a}'!1000}
:nilad
$> time(fast)
0.015867948532104492
$> time(slow)
2.8987138271331787
Les vecteurs gagnent en 182x! Pourquoi? Parce que lorsque vous effectuez une opération vectorielle en vrac, le CPU peut effectuer les mathématiques avec beaucoup moins de frais généraux et faire beaucoup plus d'opérations à la fois car il a le calcul entier présenté à la fois.
Klongpy vise à vous donner des outils qui vous permettent d'exploiter facilement cette propriété de vectorisation - et d'aller vite!
Moins de code à écrire et plus rapidement à calculer.
Klongpy s'intègre parfaitement à Python afin que les forces des deux puissent être combinées. Il est facile d'utiliser Klongpy de Python et vice versa.
Par exemple, disons que nous avons des données dans Python sur lesquelles nous voulons opérer dans Klongpy. Nous pouvons simplement utiliser directement l'interprète dans Python et exécuter des fonctions sur les données que nous mettons dans le contexte de Klongpy:
from klongpy import KlongInterpreter
import numpy as np
data = np . array ([ 1 , 2 , 3 , 4 , 5 ])
klong = KlongInterpreter ()
# make the data NumPy array available to KlongPy code by passing it into the interpreter
# we are creating a symbol in KlongPy called 'data' and assigning the external NumPy array value
klong [ 'data' ] = data
# define the average function in KlongPY
klong ( 'avg::{(+/x)%#x}' )
# call the average function with the external data and return the result.
r = klong ( 'avg(data)' )
print ( r ) # expected value: 3Il n'est pas logique d'écrire du code dans Klong qui existe déjà dans d'autres bibliothèques. Nous pouvons y accéder directement via les fonctions Python Inport (.py et .pyf).
Que diriez-vous d'utiliser la FFT Numpy?
?> .pyf("numpy";"fft");fft::.pya(fft;"fft")
:monad
?> signal::[0.0 1.0 0.0 -1.0] :" Example simple signal
[0.0 1.0 0.0 -1.0]
?> result::fft(signal)
[0j -2j 0j 2j]
Maintenant, vous pouvez utiliser Numpy ou d'autres bibliothèques pour fournir des fonctions complexes tandis que Klongpy vous permet de préparer et de traiter rapidement les vecteurs.
Il y a beaucoup plus que nous pouvons faire avec Interop, mais passons à autre chose pour le moment!
Klongpy exploite un magasin en colonnes hautes performances appelé DuckDB qui utilise des opérations de réseau Numpy à copie zéro dans les coulisses. Cette base de données permet une interopération rapide entre Klongpy et DuckDB (les tableaux ne sont pas copiés) afin que les applications puissent gérer les tableaux dans Klongpy, puis effectuer instantanément SQL sur les données pour des informations plus profondes.
Il est facile de créer une table et une base de données pour interroger:
?> .py("klongpy.db")
?> t::.table([["name" ["Alice" "Bob"]] ["age" [25 30]]])
name age
Alice 25
Bob 30
?> db::.db(:{},"T",t)
?> db("select * from T where age > 27")
name age
Bob 30
Inter Process Communication (IPC) vous permet de créer des programmes et services Klongpy distribués et interconnectés.
Klongpy traite les connexions IPC aux serveurs comme fonctions. Ces fonctions vous permettent d'appeler le serveur et de demander des choses qu'il a dans sa mémoire - elles peuvent être d'autres fonctions ou valeurs, etc. Par exemple, vous pouvez demander une référence à une fonction distante et vous obtiendrez une fonction locale qui, lorsque vous l'appelez, l'exécute sur le serveur avec vos artuémètres. Cette approche générale "proxy distant" vous permet d'écrire votre code client de la même manière que si tout le code s'exécutait localement.
Pour voir cela en action, configurons un scénario simple où le serveur a une fonction "AVG" et le client souhaite l'appeler.
Démarrez un serveur dans un terminal:
?> avg::{(+/x)%#x}
:monad
?> .srv(8888)
1
Démarrez le client et établissez la connexion au serveur comme «F». Afin de transmettre des paramètres à une fonction distante, nous formons un tableau du symbole de fonction suivi des paramètres (par exemple: avg,! 100)
?> f::.cli(8888) :" connect to the server
remote[localhost:8888]:fn
?> f(:avg,,!100) : call the remote function "avg" directly with the paramter !100
49.5
Passons en fantaisie et faisons un proxy local à la fonction distante:
?> myavg::f(:avg) :" reference the remote function by it's symbol :avg and assign to a local variable called myavg
remote[localhost:8888]:fn:avg:monad
?> myavg(!100) :" this runs on the server with !100 array passed to it as a parameter
49.5
Étant donné que les fonctions distantes peuvent prendre un certain temps, nous pouvons les envelopper avec un wrapper asynchrone et l'avoir appelé notre rappel une fois terminé:
?> afn::.async(myavg;{.d("Avg calculated: ");.p(x)})
async::monad
?> afn(!100)
Avg calculated: 49.5
1
En plus de l'IPC, nous pouvons également exposer des données via un serveur Web standard. Cette capacité vous permet d'avoir d'autres façons de servir du contenu qui peut exposer des détails intéressants sur certains calculs ou simplement un serveur Web simple pour d'autres raisons.
Créons un fichier appelé web.kg avec le code suivant qui ajoute un gestionnaire d'index:
.py("klongpy.web")
data::!10
index::{x; "Hello, Klong World! ",data}
.web(8888;:{},"/",index;:{})
.p("ready at http://localhost:8888")
Nous pouvons exécuter ce serveur Web comme suit:
$ kgpy web.kg
ready at http://localhost:8888Dans un autre terminal:
$ curl http://localhost:8888
[ ' Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]Ces exemples sont conçus pour illustrer l'approche «batteries incluses», la facilité d'utilisation et diverses applications de Klongpy, ce qui en fait un choix polyvalent pour divers besoins de programmation.
Consultez le dossier Exemples pour en savoir plus.
pip3 install klongpyChoisissez votre binaire préconçu en cupy ou à partir de la source. Remarque, le support ROCM pour Cupy est expérimental et aura probablement des problèmes.
'Cupy' => construire à partir de la source 'cuda12x' => "Cupy-Cuda12x" 'CUDA11X' => "Cupy-Cuda11x" 'CUDA111' => "Cupy-Cuda111" 'CUDA110' => "Cupy-Cuda110" 'CUDA102' => "Cupy-Cuda102" 'rocm-5-0' => " "Cupy-Rocm-5-0" 'ROCM-4-3' => "Cupy-Rocm-4-3"
pip3 install " klongpy[cupy] "pip3 install " klongpy[full] "Klongpy est un superset de la langue du tableau Klong. Il passe actuellement tous les tests d'intégration fournis par KLONG ainsi que des suites supplémentaires.
Étant donné que Cupy n'est pas 100% compatible avec Numpy, il y a actuellement quelques lacunes dans Klongpy entre les deux arrière-plans. Notamment, les chaînes sont prises en charge dans des réseaux de cupy, de sorte que le support GPU de Klongpy est actuellement limité aux mathématiques.
Le travail en cours principal comprend:
Klongpy est effectivement un superset de la langue klong, mais a quelques différences clés:
Git Clone https://github.com/briangu/klongpy.git cd klongpy python3 setup.py développe
python3 -m unittestUn grand merci à Nils M Holm pour son travail sur Klong et en fournissant les fondements de ce projet intéressant.
