mars
v0.10.0
Mars es un marco unificado basado en tensor para el cálculo de datos a gran escala que escala Numpy, Pandas, Scikit-Learn y muchas otras bibliotecas.
Documentación, 中文文档
Marte es fácil de instalar por
pip install pymarsCuando desee contribuir con código a Marte, puede seguir las instrucciones a continuación para instalar Marte para el desarrollo:
git clone https://github.com/mars-project/mars.git
cd mars
pip install -e " .[dev] "Se pueden encontrar más detalles sobre la instalación de Marte en la sección de instalación en el documento de Marte.
Comenzar un nuevo tiempo de ejecución localmente a través de:
> >> import mars
> >> mars . new_session ()O conectarse a un clúster de Marte que ya está inicializado.
> >> import mars
> >> mars . new_session ( 'http://<web_ip>:<ui_port>' )Mars Tensor proporciona una interfaz familiar como Numpy.
| Numpy | Tensor de Marte |
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
Times de CPU: usuario 11.6 s, sys: 8.22 s,
Total: 19.9 s
Tiempo de pared: 22.5 s
| 3.14161908
Times de CPU: usuario 966 MS, SYS: 544 MS,
Total: 1.51 s
Tiempo de pared: 3.77 s
|
Marte puede aprovechar múltiples núcleos, incluso en una computadora portátil, y podría ser aún más rápido para una configuración distribuida.
Mars DataFrame proporciona una interfaz familiar como los pandas.
| Pandas | Marte 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 ()) |
Times de CPU: usuario 10.9 s, sys: 2.69 s,
Total: 13.6 s
Tiempo de pared: 11 s
| Times de CPU: usuario 1.21 S, SYS: 212 ms,
Total: 1.42 s
Tiempo de pared: 2.75 s
|
Mars Learn proporciona una interfaz familiar como Scikit-Learn.
| Lear | 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 también se integra con muchas bibliotecas:
Mars Remote permite a los usuarios ejecutar funciones en paralelo.
| Llamadas a la función de vainilla | Remoto de Marte |
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
Times de CPU: usuario 32.2 S, SYS: 4.86 S,
Total: 37.1 s
Tiempo de pared: 12.4 s
| 3.1416312
Times de CPU: usuario 616 MS, SYS: 307 ms,
Total: 923 ms
Tiempo de pared: 3.99 s
|
Consulte Dask en Marte para obtener más información.
Mars apoya el modo ansioso que lo hace amigable para desarrollar y fácil de depurar.
Los usuarios pueden habilitar el modo ansioso por opciones, establecer opciones al comienzo del programa o la sesión de la consola.
> >> from mars . config import options
> >> options . eager_mode = TrueO usar un 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
>> > ...Si el modo ansioso está activado, Tensor, DataFrame, etc. se ejecutará inmediatamente por sesión predeterminada una vez que se cree.
> >> 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 Mars también tiene una profunda integración con Ray y puede funcionar con Ray de manera eficiente e interactuar con el gran ecosistema de aprendizaje automático y sistemas distribuidos construidos en la parte superior del rayo central.
Comenzar un nuevo Marte en Ray Runtime localmente a través de:
import mars
mars . new_session ( backend = 'ray' )
# Perform computationInteractuar con el conjunto de datos de rayos:
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 en Ray para obtener más información.
Marte puede escalar en una sola máquina y escalar a un clúster con miles de máquinas. Es bastante simple migrar de una sola máquina a un clúster para procesar más datos o obtener un mejor rendimiento.
Mars es fácil de escalar a un clúster iniciando diferentes componentes del tiempo de ejecución distribuido de Mars en diferentes máquinas del clúster.
Se puede seleccionar un nodo como supervisor que integró un servicio web, dejando a otros nodos como trabajadores. El supervisor se puede iniciar con el siguiente comando:
mars-supervisor -h < host_name > -p < supervisor_port > -w < web_port >Los trabajadores pueden iniciarse con el siguiente comando:
mars-worker -h < host_name > -p < worker_port > -s < supervisor_endpoint >Después de que se inician todos los procesos de Marte, los usuarios pueden ejecutarse
> >> sess = new_session ( 'http://<web_ip>:<ui_port>' )
> >> # perform computationConsulte Ejecutar en Kubernetes para obtener más información.
Consulte Ejecutar el hilo para obtener más información.
¡Gracias de antemano por sus contribuciones!
