Dask परिचय

Python में Dask के साथ Parallel Programming

James Fulton

Climate Informatics Researcher

Multiple cores से computations तेज़ करना

कंप्यूटर में कई कोर होते हैं
उन्हें उपयोग करने के लिए कोड लिखना पड़ता है
इसके लिए Dask पैकेज उपयोग कर सकते हैं
हमारी computations तेज़ी से पूरी होंगी

Concurrent programming

एक आरेख जो कार्यों की सूची और उन पर से गुजरता एक रास्ता दिखाता है.

Multi-threading

कार्यों की सूची, जिसे दो हिस्सों में बाँटा गया है.

Multi-threading

दो CPU कोर को भेजे जा रहे कार्यों के दो सेट.

Multi-threading

दोनों कार्य-सेट एक ही Python प्रोसेस के भीतर चल रहे हैं.

Parallel processing

अब दोनों कार्य-सेट दो अलग-अलग Python प्रोसेस से चल रहे हैं.

Parallel programming

Multi-threading

दो CPU कोर द्वारा चलाए गए दो कार्य-सेट, जो एक ही Python प्रोसेस के अंदर चलते हैं.

Parallel processing

दो CPU कोर द्वारा चलाए गए दो कार्य-सेट, जो दो अलग Python प्रोसेस के अंदर चलते हैं.

Lazy evaluation

जब तक परिणाम की ज़रूरत न हो, computations नहीं चलतीं
परिणाम निकालने के steps बाद के लिए सहेजे जाते हैं
Dask कार्यों को threads या processes में बाँटता है

Dask delayed

from dask import delayed

def my_square_function(x):
    return x**2


# Create delayed version of above function
delayed_square_function = delayed(my_square_function)

Dask delayed

from dask import delayed

def my_square_function(x):
    return x**2

# Create delayed version of above function
delayed_square_function = delayed(my_square_function)

# Use the delayed function with input 4
delayed_result = delayed_square_function(4)


# Print the delayed answer
print(delayed_result)

Delayed('my_square_function-7f71b132-70a9-457a-aa52-604e8c34f8a7')

Dask delayed

from dask import delayed

def my_square_function(x):
    return x**2

# Delay and use function
delayed_result = delayed(my_square_function)(4)

print(delayed_result)

Delayed('my_square_function-7f71b132-70a9-457a-aa52-604e8c34f8a7')

उत्तर compute करना

from dask import delayed

def my_square_function(x):
    return x**2

delayed_result = delayed(my_square_function)(4)

real_result = delayed_result.compute() # <- This line is where the calculation happens

# Print the answer
print(real_result)

Delayed objects पर operations का उपयोग

delayed_result1 = delayed(my_square_function)(4)

# Math operations return delayed object
delayed_result2 = (4 + delayed_result1) * 5

print(delayed_result2.compute())

Lazy evaluation

x_list = [30, 85, 14, 12, 27, 62, 89, 15, 78,  0]

sum_of_squares = 0

for x in x_list:
    # Square and add numbers
    sum_of_squares += delayed(my_square_function)(x)

Lazy evaluation

x_list = [30, 85, 14, 12, 27, 62, 89, 15, 78,  0]

sum_of_squares = 0

for x in x_list:
    # Square and add numbers
    sum_of_squares += delayed(my_square_function)(x)

result = sum_of_squares.compute()

# Print the answer
print(result)

Computation साझा करना

delayed_intermediate = delayed(my_square_function)(3)

# These two results both use delayed_intermediate
delayed_result1 = delayed_intermediate - 5
delayed_result2 = delayed_intermediate + 4

# delayed_3_squared will be computed twice
print('delayed_result1:', delayed_result1.compute())
print('delayed_result2:', delayed_result2.compute())

delayed_result1: 4
delayed_result2: 13

Computation साझा करना

import dask

# delayed_intermediate will be computed once
comp_result1, comp_result2 = dask.compute(delayed_result1, delayed_result2)

print('comp_result1:', comp_result1)
print('comp_result2:', comp_result2)

delayed_result1: 4
delayed_result2: 13

अभ्यास करते हैं!

Python में Dask के साथ Parallel Programming