klongpy
0.6.8
Klongpy é uma adaptação do Python da língua Klong Array, conhecida por suas operações vetorizadas de alto desempenho que alavancam o poder de Numpy. Abraçando uma filosofia de "baterias incluía", Klongpy combina módulos embutidos com o amplo ecossistema de Python, facilitando o rápido desenvolvimento de aplicativos com a sintaxe sucinta de Klong.
Klongpy, portanto, permanece como uma ferramenta robusta, misturando a simplicidade de Klong com as extensas capacidades do Python, adequadas para uma ampla gama de tarefas computacionais.
pip3 install " klongpy[full] "Klongpy é um tempo de execução do idioma da matriz e um conjunto de ferramentas poderosas para criar análises de dados de alto desempenho e aplicativos de computação distribuídos. Alguns dos recursos incluem:
Explore Klongpy com esses exemplos. Cada trecho destaca um aspecto único de Klong, demonstrando sua versatilidade em vários cenários de programação.
Antes de começarmos, você pode estar se perguntando: por que a sintaxe é tão concisa?
A resposta é que ela é baseada na programação da linguagem do estilo APL e há uma boa razão para que sua natureza compacta seja realmente útil.
Estilo de linguagem de matriz permite descrever o que você deseja que o computador faça e permite que o computador descubra como fazê -lo. Isso o liberta dos detalhes enquanto deixa o computador descobrir como ir o mais rápido possível.
Menos código para escrever e execução mais rápida.
Apenas para que os exemplos a seguir façam mais sentido quando você vê as saídas REPL, existem algumas regras rápidas sobre as funções de Klong. As funções levam apenas até 3 parâmetros e sempre são chamadas de x, y e z.
Uma função com
A razão pela qual as funções de Klong pegam apenas 3 parâmetros e nomeá -las para você é a congregação e a compactação.
$ 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
? > Vamos começar com o básico e criar uma matemática mais interessante. Expressões são avaliadas da direita para a esquerda: 3*2 e depois + 5
?> 5+3*2
11
Klongpy é mais sobre matrizes de coisas, então vamos definir a soma e a contagem de funções sobre uma matriz:
?> sum::{+/x} :" sum + over / the array x
:monad
?> sum([1 2 3])
6
?> count::{#x}
:monad
?> count([1 2 3])
3
Agora que conhecemos a soma e o número de elementos, podemos calcular a média:
?> avg::{sum(x)%count(x)} :" average is the sum divided by the number of elements
:monad
?> avg([1 2 3])
2
Vamos nos aprofundar em operações mais interessantes sobre os elementos da matriz. Há realmente grandes diferenças de desempenho na maneira como você aborda o problema e é importante ver a diferença.
Para o simples caso de números quadrados em uma lista, vamos tentar algumas soluções:
?> {x*x}'[1 2 3 4 5] :" square each element as we iterate over the array
[1 4 9 16 25]
A abordagem vetorizada fará uma multiplicação de elemento a granel:
?> a::[1 2 3 4 5];a*a :" a*a multiplies the arrays
[1 4 9 16 25]
A abordagem vetorizada será muito mais rápida. Vamos aumentar o tamanho da matriz e o tempo:
$> .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
Os vetores vencem por 182X! Por que? Porque quando você realiza uma operação de vetor em massa, a CPU pode executar a matemática com muito menos sobrecarga e executa muito mais operações por vez, porque ela tem todo o cálculo apresentado a ele de uma só vez.
A Klongpy pretende fornecer ferramentas que permitem que você explore convenientemente esta propriedade de vetorização - e vá rápido!
Menos código para escrever e mais rápido para calcular.
Klongpy se integra perfeitamente ao Python, para que as forças de ambos possam ser combinadas. É fácil usar Klongpy da Python e vice -versa.
Por exemplo, digamos que temos alguns dados no Python em que queremos operar em Klongpy. Podemos usar diretamente o intérprete no Python e executar funções nos dados que colocamos no contexto 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: 3Não faz sentido escrever código em Klong que já existe em outras bibliotecas. Podemos acessá -los diretamente através das funções Python INPORT (.py e .pyf).
Que tal usarmos o Numpy FFT?
?> .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]
Agora você pode usar o Numpy ou outras bibliotecas para fornecer funções complexas, enquanto o Klongpy permite preparar e processar rapidamente os vetores.
Há muito mais que podemos fazer com a interop, mas vamos seguir em frente por enquanto!
A Klongpy aproveita uma loja colunar de alto desempenho chamada DuckDB, que usa operações de matriz numpy zero cópia nos bastidores. Esse banco de dados permite uma interopagem rápida entre Klongpy e DuckDB (as matrizes não são copiadas) para que os aplicativos possam gerenciar matrizes em Klongpy e, em seguida, executar instantaneamente o SQL nos dados para obter informações mais profundas.
É fácil criar uma tabela e um banco de dados para consultar:
?> .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
A Comunicação Inter Process (IPC) permite criar programas e serviços Klongpy distribuídos e interconectados.
Klongpy trata as conexões IPC com servidores como funções. Essas funções permitem ligar para o servidor e solicitar coisas que ele tem em sua memória - elas podem ser outras funções ou valores, etc. Por exemplo, você pode solicitar uma referência a uma função remota e obterá uma função local que, quando a chama, é executada no servidor com seus argumentos. Essa abordagem geral de "proxy remoto" permite que você escreva o código do seu cliente da mesma maneira que se todo o código estivesse em execução localmente.
Para ver isso em ação, vamos configurar um cenário simples em que o servidor tem uma função "AVG" e o cliente deseja chamá -lo.
Inicie um servidor em um terminal:
?> avg::{(+/x)%#x}
:monad
?> .srv(8888)
1
Inicie o cliente e faça a conexão com o servidor como 'f'. Para passar os parâmetros para uma função remota, formamos uma matriz do símbolo da função seguido pelos parâmetros (por exemplo: 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
Vamos ser extravagantes e fazer um proxy local para a função remota:
?> 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
Como as funções remotas podem demorar um pouco, podemos embrulhá -las com um invólucro assíncrono e que ele ligue para o nosso retorno de chamada quando concluído:
?> afn::.async(myavg;{.d("Avg calculated: ");.p(x)})
async::monad
?> afn(!100)
Avg calculated: 49.5
1
Além do IPC, também podemos expor dados por meio de um servidor da Web padrão. Esse recurso permite que você tenha outras maneiras de servir conteúdo que pode expor detalhes interessantes sobre algum cálculo ou apenas um servidor da Web simples por outros motivos.
Vamos criar um arquivo chamado web.kg com o código a seguir que adiciona um manipulador de índice:
.py("klongpy.web")
data::!10
index::{x; "Hello, Klong World! ",data}
.web(8888;:{},"/",index;:{})
.p("ready at http://localhost:8888")
Podemos executar este servidor da web da seguinte forma:
$ kgpy web.kg
ready at http://localhost:8888Em outro terminal:
$ curl http://localhost:8888
[ ' Hello, Klong World! ' 0 1 2 3 4 5 6 7 8 9]Esses exemplos foram projetados para ilustrar a abordagem "baterias incluídas", facilidade de uso e diversas aplicações de Klongpy, tornando -a uma escolha versátil para várias necessidades de programação.
Confira a pasta Exemplos para obter mais informações.
pip3 install klongpyEscolha o seu binário pré -construído de Cupy ou da fonte. Observe que o suporte do ROCM ao Cupy é experimental e provavelmente terá problemas.
'cupy' => construir a partir da fonte 'cuda12x' => "cupy-cuda12x" 'cuda11x' => "cupy-cuda11x" 'cuda111' => "cupy-cuda111" 'cUDA110' => "cupy-cuda110" 'cUDA102'> "" "cupy-rocm-5-0" 'rocm-4-3' => "cupy-rocm-4-3"
pip3 install " klongpy[cupy] "pip3 install " klongpy[full] "Klongpy é um superconjunto da língua Klong Array. Atualmente, ele passa todos os testes de integração fornecidos pela Klong, além de suítes adicionais.
Como Cupy não é 100% compatível com o Numpy, atualmente existem algumas lacunas em Klongpy entre os dois back -end. Notavelmente, as strings são suportadas em matrizes Cupy, de modo que o suporte à GPU da Klongpy atualmente é limitado à matemática.
O trabalho contínuo primário inclui:
Klongpy é efetivamente um superconjunto da língua Klong, mas tem algumas diferenças importantes:
clone git https://github.com/briangu/klongpy.git cd klongpy python3 setup.py desenvolver
python3 -m unittestAgradecimentos enormes a Nils M Holm por seu trabalho em Klong e por fornecer as fundações para este projeto interessante.
