mars
v0.10.0
Mars est un cadre unifié basé sur le tenseur pour le calcul de données à grande échelle qui évolue Numpy, Pandas, Scikit-Learn et de nombreuses autres bibliothèques.
Documentation, 中文文档
Mars est facile à installer
pip install pymarsLorsque vous souhaitez contribuer du code à Mars, vous pouvez suivre les instructions ci-dessous pour installer Mars pour le développement:
git clone https://github.com/mars-project/mars.git
cd mars
pip install -e " .[dev] "Plus de détails sur l'installation de Mars peuvent être trouvés dans la section d'installation dans le document Mars.
Démarrage d'un nouveau runtime localement via:
> >> import mars
> >> mars . new_session ()Ou se connecter à un cluster Mars qui est déjà initialisé.
> >> import mars
> >> mars . new_session ( 'http://<web_ip>:<ui_port>' )Mars Tensor fournit une interface familière comme Numpy.
| Nombant | Tenseur de Mars |
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 du CPU: utilisateur 11.6 s, sys: 8.22 s,
Total: 19,9 s
Temps de mur: 22,5 s
| 3.14161908
Times du CPU: utilisateur 966 ms, sys: 544 ms,
Total: 1,51 s
Temps de mur: 3,77 s
|
Mars peut tirer parti de plusieurs cœurs, même sur un ordinateur portable, et pourrait être encore plus rapide pour un réglage distribué.
Mars DataFrame fournit une interface familière comme les 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 ()) |
Times du CPU: utilisateur 10.9 S, SYS: 2.69 S,
Total: 13,6 s
Temps de mur: 11 s
| Times du CPU: utilisateur 1.21 S, SYS: 212 ms,
Total: 1,42 s
Temps de mur: 2,75 s
|
Mars Learn fournit une interface familière comme Scikit-Learn.
| Scikit-apprend | Mars apprend |
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_ ) |
Mars Learn s'intègre également à de nombreuses bibliothèques:
Mars Remote permet aux utilisateurs d'exécuter des fonctions en parallèle.
| Appels de fonction vanille | MARS RÉSILIE |
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 du CPU: utilisateur 32.2 s, sys: 4.86 s,
Total: 37,1 s
Temps de mur: 12.4 s
| 3.1416312
Times du CPU: utilisateur 616 ms, sys: 307 ms,
Total: 923 ms
Temps de mur: 3,99 s
|
Reportez-vous à Dask sur Mars pour plus d'informations.
Mars prend en charge le mode impatient, ce qui le rend convivial pour le développement et facile à déboguer.
Les utilisateurs peuvent activer le mode avide par options, définir des options au début de la session de programme ou de console.
> >> from mars . config import options
> >> options . eager_mode = TrueOu utilisez un contexte.
> >> 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 le mode avide est allumé, Tensor, DataFrame, etc. sera exécuté immédiatement par défaut une fois qu'il sera créé.
> >> 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 a également une intégration profonde avec Ray et peut fonctionner efficacement sur Ray et interagir avec le grand écosystème de l'apprentissage automatique et des systèmes distribués construits au-dessus du rayon central.
Démarrage d'un nouveau Mars sur Ray Runtime localement via:
import mars
mars . new_session ( backend = 'ray' )
# Perform computationInteragir avec l'ensemble de données Ray:
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 ())Reportez-vous à Mars sur Ray pour plus d'informations.
Mars peut évoluer en une seule machine et évoluer vers un cluster avec des milliers de machines. Il est assez simple de migrer d'une seule machine vers un cluster pour traiter plus de données ou obtenir de meilleures performances.
Mars est facile à évoluer vers un cluster en démarrant différents composants de l'exécution distribuée Mars sur différentes machines dans le cluster.
Un nœud peut être sélectionné comme superviseur qui a intégré un service Web, laissant d'autres nœuds en tant que travailleurs. Le superviseur peut être démarré avec la commande suivante:
mars-supervisor -h < host_name > -p < supervisor_port > -w < web_port >Les travailleurs peuvent être démarrés avec la commande suivante:
mars-worker -h < host_name > -p < worker_port > -s < supervisor_endpoint >Une fois tous les processus Mars démarrés, les utilisateurs peuvent fonctionner
> >> sess = new_session ( 'http://<web_ip>:<ui_port>' )
> >> # perform computationReportez-vous à Run sur Kubernetes pour plus d'informations.
Reportez-vous à Run sur le fil pour plus d'informations.
Merci d'avance pour vos contributions!
