mars
v0.10.0
A MARS é uma estrutura unificada baseada em tensor para computação de dados em larga escala que escala Numpy, Pandas, Scikit-Learn e muitas outras bibliotecas.
Documentação, 中文文档
Marte é fácil de instalar por
pip install pymarsQuando você deseja contribuir com o código para Marte, você pode seguir as instruções abaixo para instalar o Marte para o desenvolvimento:
git clone https://github.com/mars-project/mars.git
cd mars
pip install -e " .[dev] "Mais detalhes sobre a instalação de Marte podem ser encontrados na seção de instalação no documento de Marte.
Iniciando um novo tempo de execução localmente via:
> >> import mars
> >> mars . new_session ()Ou conectar -se a um cluster de Marte que já é inicializado.
> >> import mars
> >> mars . new_session ( 'http://<web_ip>:<ui_port>' )O Mars Tensor fornece uma interface familiar como Numpy.
| Numpy | Marte Tensor |
import numpy as np
N = 200_000_000
a = np . random . uniform ( - 1 , 1 , size = ( N , 2 ))
print (( np . linalg . norm ( a , axis = 1 ) < 1 )
. sum () * 4 / N ) | import mars . tensor as mt
N = 200_000_000
a = mt . random . uniform ( - 1 , 1 , size = ( N , 2 ))
print ((( mt . linalg . norm ( a , axis = 1 ) < 1 )
. sum () * 4 / N ). execute ()) |
3.14174502
CPU Times: Usuário 11.6 S, Sys: 8.22 S,
Total: 19.9 s
Hora da parede: 22,5 s
| 3.14161908
CPU Times: Usuário 966 ms, sys: 544 ms,
TOTAL: 1,51 s
Hora da parede: 3,77 s
|
Marte pode aproveitar vários núcleos, mesmo em um laptop, e pode ser ainda mais rápido para uma configuração distribuída.
Mars Dataframe fornece uma interface familiar, como os pandas.
| Pandas | Mars DataFrame |
import numpy as np
import pandas as pd
df = pd . DataFrame (
np . random . rand ( 100000000 , 4 ),
columns = list ( 'abcd' ))
print ( df . sum ()) | import mars . tensor as mt
import mars . dataframe as md
df = md . DataFrame (
mt . random . rand ( 100000000 , 4 ),
columns = list ( 'abcd' ))
print ( df . sum (). execute ()) |
CPU Times: Usuário 10.9 S, Sys: 2,69 S,
Total: 13,6 s
Hora da parede: 11 s
| CPU Times: Usuário 1,21 s, sys: 212 ms,
Total: 1,42 s
Hora da parede: 2,75 s
|
Marte Learn fornece uma interface familiar como o Scikit-Learn.
| Scikit-Learn | Marte aprende |
from sklearn . datasets import make_blobs
from sklearn . decomposition import PCA
X , y = make_blobs (
n_samples = 100000000 , n_features = 3 ,
centers = [[ 3 , 3 , 3 ], [ 0 , 0 , 0 ],
[ 1 , 1 , 1 ], [ 2 , 2 , 2 ]],
cluster_std = [ 0.2 , 0.1 , 0.2 , 0.2 ],
random_state = 9 )
pca = PCA ( n_components = 3 )
pca . fit ( X )
print ( pca . explained_variance_ratio_ )
print ( pca . explained_variance_ ) | from mars . learn . datasets import make_blobs
from mars . learn . decomposition import PCA
X , y = make_blobs (
n_samples = 100000000 , n_features = 3 ,
centers = [[ 3 , 3 , 3 ], [ 0 , 0 , 0 ],
[ 1 , 1 , 1 ], [ 2 , 2 , 2 ]],
cluster_std = [ 0.2 , 0.1 , 0.2 , 0.2 ],
random_state = 9 )
pca = PCA ( n_components = 3 )
pca . fit ( X )
print ( pca . explained_variance_ratio_ )
print ( pca . explained_variance_ ) |
Marte Learn também se integra a muitas bibliotecas:
O MARS Remote permite que os usuários executem funções em paralelo.
| Chamadas de função de baunilha | Marte Remote |
import numpy as np
def calc_chunk ( n , i ):
rs = np . random . RandomState ( i )
a = rs . uniform ( - 1 , 1 , size = ( n , 2 ))
d = np . linalg . norm ( a , axis = 1 )
return ( d < 1 ). sum ()
def calc_pi ( fs , N ):
return sum ( fs ) * 4 / N
N = 200_000_000
n = 10_000_000
fs = [ calc_chunk ( n , i )
for i in range ( N // n )]
pi = calc_pi ( fs , N )
print ( pi ) | import numpy as np
import mars . remote as mr
def calc_chunk ( n , i ):
rs = np . random . RandomState ( i )
a = rs . uniform ( - 1 , 1 , size = ( n , 2 ))
d = np . linalg . norm ( a , axis = 1 )
return ( d < 1 ). sum ()
def calc_pi ( fs , N ):
return sum ( fs ) * 4 / N
N = 200_000_000
n = 10_000_000
fs = [ mr . spawn ( calc_chunk , args = ( n , i ))
for i in range ( N // n )]
pi = mr . spawn ( calc_pi , args = ( fs , N ))
print ( pi . execute (). fetch ()) |
3.1416312
CPU Times: Usuário 32.2 S, Sys: 4,86 s,
Total: 37.1 s
Hora da parede: 12.4 s
| 3.1416312
CPU Times: Usuário 616 ms, sys: 307 ms,
Total: 923 ms
Hora da parede: 3,99 s
|
Consulte o DASK no Marte para obter mais informações.
O MARS suporta o modo ansioso, o que o torna amigável para o desenvolvimento e fácil de depurar.
Os usuários podem habilitar o modo ansioso por opções, definir opções no início do programa ou sessão de console.
> >> from mars . config import options
> >> options . eager_mode = TrueOu use um contexto.
> >> from mars . config import option_context
> >> with option_context () as options :
> >> options . eager_mode = True
> >> # the eager mode is on only for the with statement
>> > ...Se o modo ansioso estiver ativado, o tensor, o DataFrame etc será executado imediatamente por sessão padrão assim que for criada.
> >> import mars . tensor as mt
> >> import mars . dataframe as md
> >> from mars . config import options
> >> options . eager_mode = True
> >> t = mt . arange ( 6 ). reshape (( 2 , 3 ))
> >> t
array ([[ 0 , 1 , 2 ],
[ 3 , 4 , 5 ]])
> >> df = md . DataFrame ( t )
> >> df . sum ()
0 3
1 5
2 7
dtype : int64 Marte também tem profunda integração com Ray e pode ser executado com eficientemente e interage com o grande ecossistema de aprendizado de máquina e sistemas distribuídos construídos na parte superior do raio central.
Iniciando um novo Marte no Ray Runtime localmente via:
import mars
mars . new_session ( backend = 'ray' )
# Perform computationInteraja com o conjunto de dados de raios:
import mars . tensor as mt
import mars . dataframe as md
df = md . DataFrame (
mt . random . rand ( 1000_0000 , 4 ),
columns = list ( 'abcd' ))
# Convert mars dataframe to ray dataset
ds = md . to_ray_dataset ( df )
print ( ds . schema (), ds . count ())
ds . filter ( lambda row : row [ "a" ] > 0.5 ). show ( 5 )
# Convert ray dataset to mars dataframe
df2 = md . read_ray_dataset ( ds )
print ( df2 . head ( 5 ). execute ())Consulte Marte no Ray para obter mais informações.
Marte pode escalar para uma única máquina e escalar para um cluster com milhares de máquinas. É bastante simples migrar de uma única máquina para um cluster para processar mais dados ou obter um melhor desempenho.
Marte é fácil de dimensionar para um cluster iniciando diferentes componentes do Marte distribuído tempo de execução em diferentes máquinas no cluster.
Um nó pode ser selecionado como supervisor que integrou um serviço da Web, deixando outros nós como trabalhadores. O supervisor pode ser iniciado com o seguinte comando:
mars-supervisor -h < host_name > -p < supervisor_port > -w < web_port >Os trabalhadores podem ser iniciados com o seguinte comando:
mars-worker -h < host_name > -p < worker_port > -s < supervisor_endpoint >Depois que todos os processos de Marte são iniciados, os usuários podem executar
> >> sess = new_session ( 'http://<web_ip>:<ui_port>' )
> >> # perform computationConsulte Run on Kubernetes para obter mais informações.
Consulte Run On Yarn para obter mais informações.
Agradeço antecipadamente por suas contribuições!
