Beranda>Terkait pemrograman>ular piton
Unduh

Membangun

Mars adalah kerangka kerja terpadu berbasis tensor untuk perhitungan data skala besar yang menskalakan numpy, panda, scikit-learn dan banyak perpustakaan lainnya.

Dokumentasi, 中文文档

Instalasi

Mars mudah dipasang 

pip install pymars

Instalasi untuk pengembang

Ketika Anda ingin menyumbangkan kode ke Mars, Anda dapat mengikuti instruksi di bawah ini untuk menginstal Mars untuk pengembangan: 

git clone https://github.com/mars-project/mars.git
cd mars
pip install -e " .[dev] "

Rincian lebih lanjut tentang menginstal Mars dapat ditemukan di bagian instalasi di dokumen Mars.

Tinjauan Arsitektur

Memulai

Memulai runtime baru secara lokal melalui: 

 > >> import mars
> >> mars . new_session ()

Atau menghubungkan ke cluster Mars yang sudah diinisialisasi. 

 > >> import mars
> >> mars . new_session ( 'http://<web_ip>:<ui_port>' )

Tensor Mars

Mars Tensor menyediakan antarmuka yang akrab seperti Numpy.

Numpy Tensor 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
CPU Times: pengguna 11.6 s, sys: 8.22 s,
           Total: 19,9 s
Waktu dinding: 22,5 s

3.14161908
CPU Times: pengguna 966 ms, sys: 544 ms,
           Total: 1,51 s
Waktu dinding: 3.77 s

Mars dapat memanfaatkan banyak inti, bahkan di laptop, dan bahkan bisa lebih cepat untuk pengaturan terdistribusi.

Mars DataFrame

Mars DataFrame menyediakan antarmuka yang akrab seperti panda.

Panda 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: Pengguna 10.9 S, SYS: 2.69 s,
           Total: 13.6 s
Waktu dinding: 11 s

CPU Times: Pengguna 1.21 S, SYS: 212 MS,
           Total: 1.42 s
Waktu dinding: 2.75 s

Mars belajar

Mars Learn menyediakan antarmuka yang akrab seperti scikit-learn.

Scikit-learn Mars belajar 
 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 juga terintegrasi dengan banyak perpustakaan:

  • Tensorflow
  • Pytorch
  • Xgboost
  • Lightgbm
  • JOBLIB
  • Statsmodels

Remote Mars

Mars Remote memungkinkan pengguna untuk menjalankan fungsi secara paralel.

Panggilan fungsi vanilla Remote Mars 
 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: Pengguna 32.2 s, sys: 4.86 s,
           Total: 37.1 s
Waktu dinding: 12.4 s

3.1416312
CPU Times: pengguna 616 ms, sys: 307 ms,
           Total: 923 ms
Waktu dinding: 3.99 s

Dask on Mars

Lihat Dask on Mars untuk informasi lebih lanjut.

Mode yang bersemangat

Mars mendukung mode bersemangat yang membuatnya ramah untuk berkembang dan mudah debug.

Pengguna dapat mengaktifkan mode yang bersemangat berdasarkan opsi, mengatur opsi di awal program atau sesi konsol. 

 > >> from mars . config import options
> >> options . eager_mode = True

Atau gunakan konteks. 

 > >> 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
>> >     ...

Jika mode yang bersemangat aktif, Tensor, DataFrame dll akan segera dieksekusi dengan sesi default setelah dibuat. 

 > >> 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 di Ray

Mars juga memiliki integrasi yang mendalam dengan Ray dan dapat berjalan secara efisien dan berinteraksi dengan ekosistem besar pembelajaran mesin dan sistem terdistribusi yang dibangun di atas sinar inti.

Memulai Mars baru di Ray Runtime secara lokal melalui: 

 import mars
mars . new_session ( backend = 'ray' )
# Perform computation

Berinteraksi dengan dataset 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 ())

Lihat Mars di Ray untuk informasi lebih lanjut.

Mudah untuk diukur dan diukur

Mars dapat skala ke dalam satu mesin, dan berskala ke satu cluster dengan ribuan mesin. Cukup mudah untuk bermigrasi dari satu mesin ke satu cluster untuk memproses lebih banyak data atau mendapatkan kinerja yang lebih baik.

Penempatan logam telanjang

MARS mudah untuk diukur ke sebuah cluster dengan memulai komponen yang berbeda dari runtime terdistribusi Mars pada mesin yang berbeda di cluster.

Node dapat dipilih sebagai pengawas yang mengintegrasikan layanan web, meninggalkan node lain sebagai pekerja. Pengawas dapat dimulai dengan perintah berikut: 

mars-supervisor -h < host_name > -p < supervisor_port > -w < web_port >

Pekerja dapat dimulai dengan perintah berikut: 

mars-worker -h < host_name > -p < worker_port > -s < supervisor_endpoint >

Setelah semua proses Mars dimulai, pengguna dapat berjalan 

 > >> sess = new_session ( 'http://<web_ip>:<ui_port>' )
> >> # perform computation

Penempatan Kubernetes

Lihat jalankan di Kubernet untuk informasi lebih lanjut.

Penyebaran benang

Lihat Run on Yarn untuk informasi lebih lanjut.

Terlibat

  • Baca panduan pengembangan.
  • Bergabunglah dengan Slack Workgroup kami: Slack.
  • Bergabunglah dengan milis: Kirim email ke [email protected].
  • Harap laporkan bug dengan mengirimkan masalah GitHub.
  • Kirim Kontribusi Menggunakan Permintaan Tarik.

Terima kasih sebelumnya atas kontribusi Anda!

Memperluas
Informasi Tambahan
Aplikasi Terkait
Direkomendasikan untuk Anda
Informasi Terkait Semua