🏌️ 🐂 ✍️ पायथन (+ सुब्बा) सी से तेज है - वास्तव में?! भाग 2. अभ्यास 👨🏾‍🚒 🤸🏽 👈🏾

यह सुन्न के बारे में लेख का दूसरा भाग है। पहला ऐतिहासिक परिचय और संक्षिप्त सुचना निर्देश पुस्तिका थी। यहाँ मैं हास्केल लेख " सी + + की तुलना में तेज़ " से थोड़ा संशोधित कार्य कोड प्रस्तुत करता हूं ; PHP की तुलना में धीमी "(यह विभिन्न भाषाओं / संकलक में एक एल्गोरिथ्म के कार्यान्वयन के प्रदर्शन की तुलना करता है) अधिक विस्तृत बेंचमार्क, ग्राफ़ और स्पष्टीकरण के साथ। मैं अभी यह कहना चाहूंगा कि मैंने लेख ओह देखा , यह धीमा C / C ++ और, सबसे अधिक संभावना है, यदि आप C कोड में ये बदलाव करते हैं, तो तस्वीर थोड़ी बदल जाएगी, लेकिन इस मामले में भी, अजगर इस संस्करण में भी C की गति को पार कर सकता है अपने आप में उल्लेखनीय है।

अजगर की सूची को एक सुस्पष्ट सरणी के साथ बदला गया (और, तदनुसार, v0[:] v0.copy() , क्योंकि संख्यात्मक रूप से a[:] नकल के बजाय view लौटाता है)।

प्रदर्शन व्यवहार की प्रकृति को समझने के लिए, मैंने सरणी में तत्वों की संख्या से एक "स्कैन" किया।

पायथन कोड में, मैंने time.monotonic को time.monotonic साथ बदल दिया, क्योंकि यह अधिक सटीक है (मोनोटोनिक के लिए 1us बनाम 1ms)।

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

1) कैश संकलन डिस्क पर परिणाम:

 @njit(cache=True) def lev_dist(s1: AnyStr, s2: AnyStr) -> int:

तब संकलन कार्यक्रम के पहले कॉल पर होगा, और बाद में कॉल डिस्क से खींची जाएगी।

2) हस्ताक्षर इंगित करें

संकलन उस समय होगा जब अजगर फ़ंक्शन की परिभाषा को पार्स करता है, और पहली शुरुआत पहले से ही तेज होगी।

मूल स्ट्रिंग संचरित होती है (अधिक सटीक, बाइट्स), लेकिन तार के लिए समर्थन हाल ही में जोड़ा गया है, इसलिए हस्ताक्षर काफी राक्षसी है (नीचे देखें)। हस्ताक्षर आमतौर पर सरल लिखे जाते हैं:

 @njit(nb.int64(nb.uint8[:], nb.uint8[:])) def lev_dist(s1, s2):

लेकिन फिर आपको पहले से बाइट्स को एक खस्ता सरणी में बदलना होगा:

 s1_py = [int(x) for x in b"a" * 15000] s1 = np.array(s1_py, dtype=np.uint8)

या

 s1 = np.full(15000, ord('a'), dtype=np.uint8)

और आप बाइट्स को छोड़ सकते हैं और इस रूप में हस्ताक्षर निर्दिष्ट कर सकते हैं:

 @njit(nb.int64(nb.bytes(nb.uint8, nb.1d, nb.C), nb.bytes(nb.uint8, nb.1d, nb.C))) def lev_dist(s1: AnyStr, s2: AnyStr) -> int:

बाइट्स के लिए निष्पादन की गति और uint8 से सुन्न सरणी (इस मामले में) समान है।

3) कैश को प्रीहीट करें

  s1 = b"a" * 15 # 15  15000 s2 = s1 s3 = b"b" * 15 exec_time = -clock() print(lev_dist(s1, s2)) print(lev_dist(s1, s3)) exec_time += clock() print(f"Finished in {exec_time:.3f}s", file=sys.stderr)

फिर संकलन पहली कॉल पर होगा, और दूसरा पहले से ही तेज होगा।

पायथन कोड

 #!/usr/bin/env python3 import sys import time from numba import njit import numpy as np, numba as nb from time import perf_counter as clock @njit(nb.int64(nb.uint8[::1], nb.uint8[::1])) def lev_dist(s1, s2): m = len(s1) n = len(s2) # Edge cases. if m == 0: return n elif n == 0: return m v0 = np.arange(n + 1) v1 = v0.copy() for i, c1 in enumerate(s1): v1[0] = i + 1 for j, c2 in enumerate(s2): subst_cost = v0[j] if c1 == c2 else (v0[j] + 1) del_cost = v0[j + 1] + 1 ins_cost = v1[j] + 1 min_cost = min(subst_cost, del_cost, ins_cost) v1[j + 1] = min_cost v0, v1 = v1, v0 return v0[n] if __name__ == "__main__": fout = open('py.txt', 'w') for n in 1000, 2000, 5000, 10000, 15000, 20000, 25000: s1 = np.full(n, ord('a'), dtype=np.uint8) s2 = s1 s3 = np.full(n, ord('b'), dtype=np.uint8) exec_time = -clock() print(lev_dist(s1, s2)) print(lev_dist(s1, s3)) exec_time += clock() print(f'{n} {exec_time:.6f}', file=fout)

C कोड (clang -O3 -march = देशी)

 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <time.h> static long lev_dist (const char *s1, unsigned long m, const char *s2, unsigned long n) { // unsigned long m, n; unsigned long i, j; long *v0, *v1; long ret, *temp; /* Edge cases. */ if (m == 0) { return n; } else if (n == 0) { return m; } v0 = malloc (sizeof (long) * (n + 1)); v1 = malloc (sizeof (long) * (n + 1)); if (v0 == NULL || v1 == NULL) { fprintf (stderr, "failed to allocate memory\n"); exit (-1); } for (i = 0; i <= n; ++i) { v0[i] = i; } memcpy (v1, v0, sizeof(long) * (n + 1)); for (i = 0; i < m; ++i) { v1[0] = i + 1; for (j = 0; j < n; ++j) { const long subst_cost = (s1[i] == s2[j]) ? v0[j] : (v0[j] + 1); const long del_cost = v0[j + 1] + 1; const long ins_cost = v1[j] + 1; #if !defined(__GNUC__) || defined(__llvm__) if (subst_cost < del_cost) { v1[j + 1] = subst_cost; } else { v1[j + 1] = del_cost; } #else v1[j + 1] = (subst_cost < del_cost) ? subst_cost : del_cost; #endif if (ins_cost < v1[j + 1]) { v1[j + 1] = ins_cost; } } temp = v0; v0 = v1; v1 = temp; } ret = v0[n]; free (v0); free (v1); return ret; } int main () { char s1[25001], s2[25001], s3[25001]; int lengths[] = {1000, 2000, 5000, 10000, 15000, 20000, 25000}; FILE *fout; fopen_s(&fout, "c.txt", "w"); for(int j = 0; j < sizeof(lengths)/sizeof(lengths[0]); j++){ int len = lengths[j]; int i; clock_t start_time, exec_time; for (i = 0; i < len; ++i) { s1[i] = 'a'; s2[i] = 'a'; s3[i] = 'b'; } s1[len] = s2[len] = s3[len] = '\0'; start_time = clock (); printf ("%ld\n", lev_dist (s1, len, s2, len)); printf ("%ld\n", lev_dist (s1, len, s3, len)); exec_time = clock () - start_time; fprintf(fout, "%d %.6f\n", len, ((double) exec_time) / CLOCKS_PER_SEC); fprintf (stderr, "Finished in %.3fs\n", ((double) exec_time) / CLOCKS_PER_SEC); } return 0; }

तुलना विंडोज़ (विंडोज़ 10 x64, पायथन 3.7.3, सुंबा 0.45.1, क्लैग 9.0.0, इंटेल m5-6y54 स्काईलेक) के तहत की गई थी: और लिनक्स के नीचे (डेबियन 4.9.30, पायथॉन 3.7.4, सुंबा 0.45.1)। clang 9.0.0)।

X सरणी का आकार है, y सेकंड में समय है।

विंडोज रैखिक पैमाने:

विंडोज लॉगरिदमिक स्केल:

लिनक्स रैखिक स्केल:

लिनक्स लॉगरिदमिक स्केल

इस समस्या में, कई प्रतिशत के स्तर पर क्लैंग की तुलना में गति में वृद्धि प्राप्त की गई थी, जो आमतौर पर सांख्यिकीय त्रुटि से अधिक है।

मैंने बार-बार विभिन्न कार्यों पर यह तुलना की है और, एक नियम के रूप में, यदि सुंबा कुछ गति कर सकता है, तो यह गति सी के साथ त्रुटि सीमांकन के एक गति के भीतर इसे गति देता है (कोडांतरक आवेषण का उपयोग किए बिना)।

मैं दोहराता हूं कि यदि आप ओह से C में कोड में परिवर्तन करते हैं , तो यह धीमी C / C ++ स्थिति बदल सकती है।

मुझे टिप्पणियों और प्रश्नों को सुनने में खुशी होगी।

PS जब सरणियों के हस्ताक्षर निर्दिष्ट करते हैं, तो पंक्तियों / स्तंभों को स्पष्ट रूप से निर्धारित करना बेहतर होता है:
ताकि सुंबा 'C' (si) इस या 'A' (si / फोरट्रान ऑटो-रिकग्निशन) के बारे में न सोचें - किसी कारण से यह एक आयामी सरणियों के लिए भी प्रदर्शन को प्रभावित करता है, इसके लिए इस तरह का एक मूल वाक्यविन्यास है: uint8[:,:] इस ' A '(ऑटो डिटेक्शन), nb.uint8[:, ::1] ' C '(si), np.uint8[::1, :] ' F '(फोरट्रान) है।

 @njit(nb.int64(nb.uint8[::1], nb.uint8[::1])) def lev_dist(s1, s2):

पायथन (+ सुब्बा) सी से तेज है - वास्तव में?! भाग 2. अभ्यास

More articles: