पायथन में वैश्वीकरण

| | | | | | | | | |

किसी भी एल्गोरिदम की समय जटिलता यह तय करने में बहुत महत्वपूर्ण है कि कोई एप्लिकेशन विश्वसनीय है या नहीं। रीयल-टाइम आउटपुट को लागू करने के लिए जितनी जल्दी हो सके एक बड़ा एल्गोरिदम चलाना बहुत महत्वपूर्ण है। ऐसा करने के लिए, पाइथन के पास लूप लिखने के बिना डेटा के पूरे सरणी पर त्वरित रूप से संचालन करने के लिए कई मानक गणित कार्य हैं। ऐसा ही एक पुस्तकालय है जिसमें ऐसा फ़ंक्शन शामिल है numpy । आइए देखें कि वैश्वीकरण के मामले में हम इस मानक फ़ंक्शन का उपयोग कैसे कर सकते हैं।

सदिशीकरण क्या है?
वेक्टराइजेशन का उपयोग लूप का उपयोग किए बिना पायथन कोड को गति देने के लिए किया जाता है। ऐसे फ़ंक्शन का उपयोग करने से आपके कोड निष्पादन समय को कम करने में मदद मिल सकती है। एक वेक्टर पर विभिन्न ऑपरेशन किए जाते हैं, जैसे कि वैक्टर का डॉट उत्पाद, जिसे डॉट उत्पाद के रूप में भी जाना जाता है, क्योंकि यह एक एकल आउटपुट, बाहरी उत्पादों का उत्पादन करता है जिसके परिणामस्वरूप एक वर्ग माप मैट्रिक्स में। वैक्टर की लंबाई के एक्स की लंबाई के बराबर, एक तत्व से गुणा, जो उत्पाद का उत्पादन करता है सूचकांक का तत्व और मैट्रिक्स का आयाम अपरिवर्तित रहता है।

हम करेंगे देखें कि कैसे शास्त्रीय तरीके सामान्य कार्यों से अधिक समय लेते हैं, उनके प्रसंस्करण समय की गणना करते हैं।

बाहरी (ए, बी): दो वैक्टर के बाहरी उत्पाद की गणना करें।
गुणा (a, b): दो सरणियों का मैट्रिक्स उत्पाद।
डॉट (a, b): दो सरणियों का डॉट उत्पाद।
शून्य ((n, m)): शून्य से भरे हुए आकार और प्रकार का मैट्रिक्स लौटाएं।
process_time (): वर्तमान प्रक्रिया के सिस्टम और उपयोगकर्ता CPU समय के योग का मान (आंशिक सेकंड में) लौटाएं। इसमें नींद के दौरान बीता हुआ समय शामिल नहीं है।

डॉट उत्पाद:
डॉट उत्पाद — यह एक बीजीय संक्रिया है जिसमें समान लंबाई के दो सदिशों को गुणा किया जाता है ताकि यह एक संख्या उत्पन्न करे। डॉट उत्पाद को अक्सर आंतरिक उत्पाद के रूप में संदर्भित किया जाता है। इस उत्पाद के परिणामस्वरूप एक अदिश संख्या होती है। आइए एक ही लंबाई के a और b के दो आव्यूहों पर विचार करें, पहले आव्यूह को स्थानांतरित करके डॉट उत्पाद किया जाता है, और फिर गुणन निष्पादित किया जाता है गणितीय मैट्रिक्स का a ' (स्थानांतरित a) और b, द्वारा जैसा कि नीचे दिए गए चित्र में दिखाया गया है।

दृश्य प्रतिनिधित्व डॉट उत्पाद का —

नीचे पायथन कोड है:


# Dot product

आयात <कोड वर्ग = "सादा"> समय

<कोड वर्ग = "कीवर्ड"> आयात <कोड वर्ग = "सादा"> numpy

import array


# 8 बाइट्स इंट

<पी> कोड क्लास = "सादा"> ए <कोड क्लास = "कीवर्ड"> = <कोड class = "सादा"> array.array (
`q` )

< कोड वर्ग = "कीवर्ड"> के लिए <कोड वर्ग = "सादा"> i <कोड वर्ग = "कीवर्ड"> में > <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान"> 100000 <कोड वर्ग = "पीएलए in">):

a.append (i);


b = array. सरणी ( ` q` )

के लिए <कोड वर्ग = "सादा"> मैं <कोड वर्ग = "कीवर्ड"> में <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा" > ( 100000 , 200000 ):

b.append (i)


# क्लासिक डॉट उत्पाद कार्यान्वयन वैक्टर

tic = समय।process_time ()

डॉट <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "मान"> 0.0 <कोड वर्ग = "पीएलए में">;


के लिए i in < में / कोड> <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (ए)):

<कोड वर्ग = "सादा"> बिंदु <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> एक [i] <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> ख [i]


toc = time.process_time ()


प्रिंट <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "dot_product =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "फ़ंक्शंस"> str <कोड क्लास = "सादा"> (डॉट));

Print ( "Computation Time =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान" > 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (टोक <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> टिक)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "स्ट्रिंग"> "एमएस" <कोड वर्ग = "सादा">) कोड>



<कोड वर्ग = "सादा"> n_tic <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय .process_time ()

n_dot_product = numpy.dot (a, b)

n_toc <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय।process_time ()


Print <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "n_dot_product =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "functions"> str (n_dot_product))

Print ( <कोड वर्ग = "स्ट्रिंग"> "गणना समय =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान"> 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (n_toc <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> n_tic)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = " string"> "ms" )

बाहर निकलें:

dot_product = 833323333350000.0 गणना समय = 35.59449199999999ms n_dot_p roduct = 833323333350000 संगणना समय = 0.159900000002225ms 

बाहरी उत्पाद:
टेन्सर उत्पाद दो निर्देशांक सदिशों का कहलाता है बाहरी कार्य । आयाम nx 1 और mx 1 के साथ दो वैक्टर a और b पर विचार करें, तो वेक्टर का बाहरी उत्पाद होता है एक आयताकार मैट्रिक्स nxm । यदि दो वैक्टर का आयाम समान है, तो परिणामी मैट्रिक्स एक वर्ग मैट्रिक्स होगा, जैसा कि चित्र में दिखाया गया है।

बाहरी उत्पाद का दृश्य प्रतिनिधित्व —

नीचे पायथन कोड है:


<तालिका सीमा = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

# आउटडोर उत्पाद

import time

import numpy

आयात <कोड वर्ग = "सादा"> सरणी


<कोड वर्ग = "सादा"> एक <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> array.array ( `i` )

<कोड वर्ग = "कीवर्ड" > के लिए फ़ंक्शंस"> श्रेणी <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान"> 200 <कोड वर्ग = "सादा">):

<कोड वर्ग = "अपरिभाषित रिक्त स्थान" > <कोड वर्ग = "सादा"> a.append (मैं);


b = array. सरणी ( ` i` )

के लिए <कोड वर्ग = "सादा"> मैं <कोड वर्ग = "कीवर्ड"> में <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा" > ( 200 , 400 ):

b.append (i)


# क्लासिक बाहरी उत्पाद वेक्टर कार्यान्वयन

< कोड वर्ग = "सादा"> टिक <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = " सादा"> समय।process_time ()

बाहरी_उत्पाद <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> numpy.zeros (( <कोड वर्ग = "मान"> 200 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 200 <कोड वर्ग = "सादा">))


for i in कोड> <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> ( a)):

for j in <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा" > (बी)):

<कोड वर्ग = "सादा" > बाहरी_उत्पाद [i] [j] <कोड वर्ग = "कीवर्ड"> = < कोड वर्ग = "सादा"> एक [i] <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> बी [जे]


<कोड वर्ग = "सादा"> toc <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय।process_time ()


Print ( <कोड वर्ग = "स्ट्रिंग"> "बाहरी_उत्पाद =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str < / कोड> <कोड वर्ग = "सादा"> (बाहरी_उत्पाद));

<कोड वर्ग = "कीवर्ड"> प्रिंट <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "गणना समय =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान" > 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (टोक <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> टिक)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "स्ट्रिंग"> "एमएस" <कोड वर्ग = "सादा">) code>


n_tic = time.process_time ()

external_product = numpy.outer (a, b)

n_toc = time.process_time ()

<कोड वर्ग = "कीवर्ड"> प्रिंट <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "बाहरी_उत्पाद =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> (बाहरी_उत्पाद));

Print ( "Computation Time =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान" > 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (n_toc <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> n_tic)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "स्ट्रिंग"> "एमएस" <कोड वर्ग = "सादा">) कोड>


बाहर निकलें:

outer_product = [[0. 0. 0. ..., 0. 0. 0.] [200.201.02. ..., 397. 398. 399.] [400। 402. 404. ... , 794. 796. 798.] ..., [39400। 39597. 39794. ... , 78209. 78406. 78603। ] [39600। 39798. 39996. ... , 78606. 78804. 79002।] [39800। 39999. 40198. ..., 79202. 79401।]] गणना समय = 39.821617ms बाहरी_उत्पाद = [[0 0 0 ..., 0 0 0] [200 201 202 ..., 397 398 399] [400 402 404 ..., 794 79 6 798] ..., [39400 39597 39794 ..., 78209 78406 78603] [39600 39798 39996 ..., 78606 78804 79002] [39800 39999 40198 ..., 79003 79202 79401]] गणना समय = 0.2809480000000031ms 

तत्व के अनुसार उत्पाद:
दो आव्यूहों का तत्ववार गुणन — यह एक बीजीय संक्रिया है जिसमें पहले आव्यूह के प्रत्येक अवयव को बाद के आव्यूह के संगत तत्व से गुणा किया जाता है। मैट्रिक्स के आयाम समान होने चाहिए।
दो मैट्रिक्स a और b पर विचार करें, a — में एलिमेंट इंडेक्स; ये हैं i और j, तो a (i, j) को b (i, j) से गुणा किया जाता है , क्रमशः, जैसा कि नीचे चित्र में दिखाया गया है।

बुद्धिमान उत्पाद तत्व का दृश्य प्रतिनिधित्व —

नीचे पायथन कोड है:


<कोड वर्ग = "टिप्पणियां" > # तत्व-वार गुणन

<कोड वर्ग = "कीवर्ड"> आयात <कोड वर्ग = "सादा"> समय

<कोड वर्ग = "कीवर्ड"> आयात < /कोड> <कोड वर्ग = "सादा"> सुन्न

<कोड वर्ग = "कीवर्ड"> आयात <कोड वर्ग = "सादा"> सरणी /p>

a = कोड> <कोड वर्ग = "सादा"> सरणी। सरणी ( <कोड वर्ग = "स्ट्रिंग"> `i` <कोड वर्ग = "सादा">)

<कोड वर्ग = "कीवर्ड"> के लिए श्रेणी <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान"> 50000 < कोड वर्ग = "सादा">):

<कोड वर्ग = "सादा"> a.append (i);


b = array. सरणी ( ` i` )

के लिए <कोड वर्ग = "सादा"> मैं <कोड वर्ग = "कीवर्ड"> में <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा" > ( 50000 , 100000 ):

b.append (i)


# क्लासिक आइटम-दर-आइटम उत्पाद वेक्टर कार्यान्वयन

<कोड वर्ग = "सादा"> वेक्टर <कोड वर्ग = "कीवर्ड"> = < कोड वर्ग = "सादा"> numpy.zeros (( 50000 ))


tic = time.process_time ()

<कोड वर्ग = "सादा"> मैं <कोड वर्ग = "कीवर्ड"> में <कोड वर्ग = "कार्य"> श्रेणी <कोड वर्ग = "सादा"> ( len (a)):

वेक्टर [i] <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> एक [i] <कोड वर्ग = "कीवर्ड"> * < कोड वर्ग = "सादा"> b [i]

<कोड वर्ग = "सादा"> toc <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय।process_time ()

<कोड वर्ग = "कार्य"> प्रिंट <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "तत्व के अनुसार उत्पाद = " + str (वेक्टर ));

<कोड वर्ग = "कीवर्ड"> प्रिंट <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "गणना समय =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान" > 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (टोक <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> टिक)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "स्ट्रिंग"> "एमएस" <कोड वर्ग = "सादा">) कोड>



<कोड वर्ग = "सादा"> n_tic <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय .process_time ()

वेक्टर <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> numpy.multiply (ए, बी)

<कोड वर्ग = "सादा"> n_toc <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> समय।process_time ()


Print <कोड वर्ग = "सादा"> ( <कोड वर्ग = "स्ट्रिंग"> "तत्व वार उत्पाद =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य "> str <कोड वर्ग = "सादा"> (वेक्टर));

Print ( "Computation Time =" <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "कार्य"> str <कोड वर्ग = "सादा"> ( <कोड वर्ग = "मान" > 1000 <कोड वर्ग = "कीवर्ड"> * <कोड वर्ग = "सादा"> (n_toc <कोड वर्ग = "कीवर्ड"> - <कोड वर्ग = "सादा"> n_tic)) <कोड वर्ग = "कीवर्ड"> + <कोड वर्ग = "स्ट्रिंग"> "एमएस" <कोड वर्ग = "सादा">) कोड>

बाहर निकलें:

< पूर्व>तत्ववार उत्पाद = [0.00000000e + 00 5.00010000e + 04 1.00004000e + 05 ..., 4.99955001e + 09 4.99970000e + 09 4.99985000e + 09] गणना समय = 23.516678000000013ms तत्व के अनुसार उत्पाद = [0 50001 100004। .., 704582713 704732708 704882705] गणना समय = 0.2250640000000248ms

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers

News


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method