mars
v0.10.0
Mars ist ein Tensor-basiertes einheitliches Framework für große Datenberechnung, die Numpy, Pandas, Scikit-Learn und viele andere Bibliotheken skaliert.
Dokumentation, 中文文档
Mars ist einfach zu installieren durch
pip install pymarsWenn Sie Code zum Mars beitragen möchten, können Sie die folgenden Anweisungen befolgen, um Mars für die Entwicklung zu installieren:
git clone https://github.com/mars-project/mars.git
cd mars
pip install -e " .[dev] "Weitere Details zur Installation von Mars finden Sie im Abschnitt "Installation" im Mars -Dokument.
Eine neue Laufzeit vor Ort starten über:
> >> import mars
> >> mars . new_session ()Oder eine Verbindung zu einem Mars -Cluster herstellen, der bereits initialisiert ist.
> >> import mars
> >> mars . new_session ( 'http://<web_ip>:<ui_port>' )Der Mars -Tensor bietet eine vertraute Oberfläche wie Numpy.
| Numpy | Mars -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 -Zeiten: Benutzer 11.6 s, sys: 8.22 s,
Gesamt: 19,9 s
Wandzeit: 22,5 s
| 3.14161908
CPU -Zeiten: Benutzer 966 MS, SYS: 544 MS,
Gesamt: 1,51 s
Wandzeit: 3.77 s
|
Der Mars kann mehrere Kerne selbst auf einem Laptop nutzen und kann für eine verteilte Einstellung sogar noch schneller sein.
Mars DataFrame bietet eine vertraute Schnittstelle wie 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 -Zeiten: Benutzer 10.9 s, sys: 2.69 s,
Gesamt: 13,6 s
Wandzeit: 11 s
| CPU -Zeiten: Benutzer 1.21 s, sys: 212 ms,
Gesamt: 1,42 s
Wandzeit: 2,75 s
|
Mars Learn bietet eine vertraute Schnittstelle wie Scikit-Learn.
| Scikit-Learn | Mars lernen |
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 integriert sich auch in viele Bibliotheken:
Mit Mars Remote können Benutzer parallel Funktionen ausführen.
| Vanillefunktionsaufrufe | Mars Fernbedienung |
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 -Zeiten: Benutzer 32.2 s, sys: 4.86 s,
Gesamt: 37,1 s
Wandzeit: 12,4 s
| 3.1416312
CPU -Zeiten: Benutzer 616 ms, sys: 307 ms,
Gesamt: 923 ms
Wandzeit: 3,99 s
|
Weitere Informationen finden Sie in Dask auf dem Mars.
Der Mars unterstützt den eifrigen Modus, der es freundlich für die Entwicklung und einfach zu debuggen macht.
Benutzer können den eifrigen Modus nach Optionen aktivieren, Optionen zu Beginn des Programms oder der Konsolensitzung festlegen.
> >> from mars . config import options
> >> options . eager_mode = TrueOder einen Kontext verwenden.
> >> 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
>> > ...Wenn der eifrige Modus eingeschaltet ist, wird Tensor, DataFrame usw. sofort standardmäßig ausgeführt, sobald er erstellt wurde.
> >> 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 Der Mars hat auch eine tiefe Integration in Ray und kann Ray effizient laufen und mit dem großen Ökosystem des maschinellen Lernens und verteilten Systemen interagieren, die auf dem Kernstrahl basieren.
Starten eines neuen Mars auf Ray Runtime lokal über:
import mars
mars . new_session ( backend = 'ray' )
# Perform computationInteragieren Sie mit dem Ray -Datensatz:
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 ())Weitere Informationen finden Sie unter Mars on Ray.
Der Mars kann zu einer einzigen Maschine skalieren und mit Tausenden von Maschinen zu einem Cluster skalieren. Es ist ziemlich einfach, von einer einzelnen Maschine zu einem Cluster zu migrieren, um mehr Daten zu verarbeiten oder eine bessere Leistung zu erzielen.
Der Mars ist leicht zu einem Cluster zu skalieren, indem verschiedene Komponenten der Mars -verteilten Laufzeit auf verschiedenen Maschinen im Cluster gestartet werden.
Ein Knoten kann als Supervisor ausgewählt werden, der einen Webdienst integriert hat und andere Knoten als Arbeiter hinterlassen. Der Vorgesetzte kann mit dem folgenden Befehl gestartet werden:
mars-supervisor -h < host_name > -p < supervisor_port > -w < web_port >Arbeiter können mit dem folgenden Befehl gestartet werden:
mars-worker -h < host_name > -p < worker_port > -s < supervisor_endpoint >Nachdem alle Mars -Prozesse gestartet wurden, können Benutzer ausführen
> >> sess = new_session ( 'http://<web_ip>:<ui_port>' )
> >> # perform computationWeitere Informationen finden Sie unter Kubernetes.
Weitere Informationen finden Sie unter Garn.
Vielen Dank im Voraus für Ihre Beiträge!
