# പൈത്തൺ പ്രകടനം: നേറ്റീവ് നംപൈ ലൂപ്പുകൾ, കോൾബാക്കുകൾ, പരിവർത്തന ചെലവുകൾ

Published: 2026-10-17

സിപിയുവിൽ മാത്രം പ്രവർത്തിക്കുന്ന ഒരു സംഖ്യാപരമായ പരിശോധന, CPython ലൂപ്പുകൾ, NumPy ഗണിതം, ഒരു പൈത്തൺ കോൾബാക്ക് റാപ്പർ, ഒരു കംപൈൽ ചെയ്ത നംബ ലൂപ്പ് എന്നിവയിലൂടെ സമാന മൂല്യങ്ങളെ പിന്തുടരുന്നു. റെഡി-ഇൻപുട്ട് NumPy വലിയ മുന്നേറ്റം നേടി, എന്നാൽ പൈത്തൺ ലിസ്റ്റുകളിലേക്ക് പരിവർത്തനം ചെയ്യുകയും തിരികെ നൽകുകയും ചെയ്തപ്പോൾ ആ നേട്ടം ഏകദേശം തുല്യമായി കുറഞ്ഞു. ഈ എപ്പിസോഡ് എക്സിക്യൂഷൻ ബൗണ്ടറിയും ഒരു അപ്ലിക്കേഷന് ആവശ്യമായ ഫലം എങ്ങനെ അളക്കാമെന്നും വിശദീകരിക്കുന്നു.

Canonical: https://thedailydiff.dev/ml/video/2026-10-17-python-native-loops/

## ഈ വീഡിയോയിൽ ഉൾപ്പെടുന്ന കാര്യങ്ങൾ

- CPython ഉറവിടം ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു. ആവർത്തിച്ചുള്ള ഇൻ്റർപ്രെറ്റർ/ഒബ്ജക്റ്റ് വർക്കും ഒരു ടൈപ്പ് ചെയ്ത നേറ്റീവ് ന്യൂമെറിക് ലൂപ്പും വ്യത്യസ്ത എക്സിക്യൂഷൻ ക്രമീകരണങ്ങളാണ്.
- ന്യൂമെറിക് NumPy ഗണിതത്തിന് ടൈപ്പ് ചെയ്ത ബാച്ചുകളെ കംപൈൽ ചെയ്ത പ്രവർത്തനങ്ങളിലേക്ക് കൈമാറാൻ കഴിയും; ഗണിത ലൂപ്പ് ഇപ്പോഴും നിലവിലുണ്ട്, കൂടാതെ വ്യൂസിന് നോൺകണ്ടിഗ്യസ് ലേഔട്ടുകൾ ഉണ്ടാകാം.
- പരിവർത്തനവും ആവശ്യമായ ഔട്ട്പുട്ട് പ്രാതിനിധ്യവും അളക്കുക. ഈ റണ്ണിൽ, പൈത്തൺ ലിസ്റ്റുകളെ അറേകളാക്കി മാറ്റുകയും തിരികെ മാറ്റുകയും ചെയ്തത് വലിയ റെഡി-അറേ ലീഡിനെ ഇല്ലാതാക്കി.
- ചെറിയ വർക്ക്ലോഡുകൾക്ക് സാധാരണ പൈത്തൺ അനുയോജ്യമാകും, കാരണം നിശ്ചിത അറേ-കോൾ ചെലവുകൾക്ക് പ്രാധാന്യമുണ്ട്. എട്ട്-മൂല്യമുള്ള കോംപ്രിഹൻഷൻ ഈ അളന്ന താരതമ്യത്തിൽ വിജയിച്ചു.
- np.vectorize എന്നത് തുടർച്ചയായ എലമെൻ്റുകൾക്കായി പൈത്തൺ വിളിക്കുന്ന ഒരു സൗകര്യ റാപ്പർ ആണ്; ഒരു ബാച്ച് ഇൻ്റർഫേസ് മാത്രം നേറ്റീവ് സംഖ്യാപരമായ എക്സിക്യൂഷൻ സ്ഥാപിക്കുന്നില്ല.
- കംപൈൽ ചെയ്ത പൈത്തൺ-സിൻ്റക്സ് ലൂപ്പുകളും വേഗതയുള്ളതാകാം. കോളർക്ക് പ്രാധാന്യമുള്ളപ്പോൾ കോൾഡ് കംപൈലേഷൻ/സെറ്റപ്പ് ചെലവുകൾ ഉൾപ്പെടുത്തുക.
- നേറ്റീവ് എക്സിക്യൂഷൻ, CPU SIMD, മൾട്ടിത്രെഡിംഗ്, GPU ബാക്കെൻഡുകൾ എന്നിവ വ്യത്യസ്ത ആശയങ്ങളാണ്. ലഭ്യമായ CPU ഫീച്ചറുകൾ ഒരു പ്രത്യേക റണ്ണിൽ ഉപയോഗിച്ച ഇൻസ്ട്രക്ഷനുകൾ കണ്ടെത്താൻ കഴിയില്ല.

## അധ്യായങ്ങൾ

- 0:00 എന്തുകൊണ്ടാണ് ഒരേ CPU വേഗത്തിൽ പൂർത്തിയാക്കുന്നത്?
- 0:52 ഒരു പൈത്തൺ ലൂപ്പ് ഏത് ജോലിയാണ് ആവർത്തിക്കുന്നത്?
- 1:38 NumPy ലൂപ്പ് എങ്ങോട്ട് മാറ്റുന്നു?
- 2:13 വേഗതയെന്നാൽ GPU ആണോ അതോ നിരവധി CPU കോറുകളാണോ?
- 2:49 അതിശയകരമായ വേഗത വർദ്ധനവ് എപ്പോഴാണ് അപ്രത്യക്ഷമാകുന്നത്?
- 3:28 ഏത് അതിരുകളാണ് ബെഞ്ച്മാർക്കിൽ ഉൾപ്പെടേണ്ടത്?
- 4:00 കംപൈൽ ചെയ്ത പൈത്തൺ ലൂപ്പ് വേഗതയുള്ളതാകുമോ?
- 4:56 np.vectorize യഥാർത്ഥത്തിൽ എന്താണ് എക്സിക്യൂട്ട് ചെയ്യുന്നത്?
- 5:41 നിങ്ങളുടെ കോഡിൽ എന്താണ് മാറ്റേണ്ടത്?

## വിവർത്തനം ചെയ്ത ട്രാൻസ്ക്രിപ്റ്റ്

യഥാർത്ഥ ഇംഗ്ലീഷ് ആഖ്യാനത്തിൽ നിന്ന് വിവർത്തനം ചെയ്തത്. ലഭ്യമായ ഓഡിയോയും അടിക്കുറിപ്പുകളും YouTube നിയന്ത്രിക്കുന്നു.

### എന്തുകൊണ്ടാണ് ഒരേ CPU വേഗത്തിൽ പൂർത്തിയാക്കുന്നത്?

0:00 വേഗത ലഭിക്കാൻ പൈത്തണിന് ഒരു പുതിയ ഭാഷ ആവശ്യമാണെന്ന് നിങ്ങൾ കരുതുന്നു. ലൂപ്പ് മാറിയതിന് ശേഷം അതേ CPU ഞങ്ങളുടെ ബാച്ച് വേഗത്തിൽ പ്രവർത്തിപ്പിച്ചു. ജോലി എങ്ങോട്ട് പോയി? വേഗത വർദ്ധനവ് എപ്പോഴാണ് അപ്രത്യക്ഷമാകുന്നത്? ഏത് കുറുക്കുവഴിയാണ് പൈത്തണിനെ തിരികെ കൊണ്ടുവരുന്നത്? ഇത് ദി ഡെയ്ലി ഡിഫ് ആണ്, അണിയറയിൽ. ആ കുറുക്കുവഴി ശ്രദ്ധിക്കുക. CPython ആണ് സ്റ്റാൻഡേർഡ് പൈത്തൺ ഇംപ്ലിമെൻ്റേഷൻ.

0:17 ഇത് നിങ്ങളുടെ ഉറവിടം ബൈറ്റ്കോഡിലേക്ക് കംപൈൽ ചെയ്യുന്നു, തുടർന്ന് ആ നിർദ്ദേശങ്ങൾ ഒരു ഇൻ്റർപ്രെട്ടറിൽ പ്രവർത്തിപ്പിക്കുന്നു. NumPy എന്നത് ഒരു സംഖ്യാപരമായ ലൈബ്രറിയാണ്, അതിൻ്റെ അറേകളിൽ പ്രഖ്യാപിച്ച ഡാറ്റാ ടൈപ്പോടുകൂടിയ മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അതിൻ്റെ ബിൽറ്റ്-ഇൻ ഗണിതത്തിന് ഒരു മുഴുവൻ ബാച്ചിനെയും കംപൈൽ ചെയ്ത പ്രവർത്തനങ്ങളിലേക്ക് കൈമാറാൻ കഴിയും. ഒരു ദശലക്ഷം ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യങ്ങൾ എടുക്കുക, ഓരോന്നിനും സ്ക്വയർ ചെയ്യുക, തുടർന്ന് യഥാർത്ഥ മൂല്യം ചേർക്കുക. എല്ലാ പതിപ്പുകൾക്കും ഒരേ മൂല്യങ്ങൾ ലഭിക്കുകയും പൊരുത്തപ്പെടുന്ന ഉത്തരങ്ങൾ ഉത്പാദിപ്പിക്കുകയും ചെയ്യുന്നു. റൗണ്ടിംഗ് വ്യത്യാസങ്ങൾ റേസിൻ്റെ പുറത്ത് നിർത്താൻ മതിയായ ചെറിയ മൂല്യങ്ങളാണിവ.

0:40 ഈ മെഷീനിൽ, കോംപ്രിഹൻഷന് ഏകദേശം മുപ്പത്തിമൂന്ന് മില്ലിസെക്കൻഡ് എടുത്തു. NumPy-ന് ഒരു മില്ലിസെക്കൻഡിൽ കുറവ് എടുത്തു. രണ്ടും CPU-ൽ പ്രവർത്തിച്ചു. ഇതൊരു വർക്ക്ലോഡിന് ഉപയോഗപ്രദമായ തെളിവാണ്, ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയ്ക്ക് ഒരു ഭയങ്കരമായ ചരമക്കുറിപ്പാണ്. സാധാരണ ലൂപ്പിൽ നിന്ന് ആരംഭിക്കുക. പ്രോഗ്രാമിംഗ് ഭാഷ. സാധാരണ ലൂപ്പിൽ നിന്ന് ആരംഭിക്കുക.

### ഒരു പൈത്തൺ ലൂപ്പ് ഏത് ജോലിയാണ് ആവർത്തിക്കുന്നത്?

0:53 പൈത്തൺ അടുത്ത മൂല്യം എടുക്കുന്നു, ഗണിതം നടത്തുന്നു, ഉത്തരം ചേർക്കുന്നു. തുടർന്ന് അത് വീണ്ടും ചെയ്യുന്നു. ഗുണനം വിലകുറഞ്ഞതാണ്. അടുത്ത ഗുണനം ക്രമീകരിക്കുന്നതും അതിനു ചുറ്റുമുള്ള പൈത്തൺ ഒബ്ജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതും എല്ലാ തവണയും അധിക ജോലി ചേർക്കുന്നു. ഇതാണ് പരീക്ഷിച്ച ഫംഗ്ഷൻ്റെ യഥാർത്ഥ ഡിസസെംബ്ലി. ഇറ്ററേഷൻ, ഗുണനം, സങ്കലനം എന്നിവ ബൈറ്റ്കോഡ് നിർദ്ദേശങ്ങളായി പ്രത്യക്ഷപ്പെടുന്നു. പൈത്തൺ പതിപ്പുകളും ഇൻ്റർപ്രെട്ടറുകളും വ്യത്യസ്ത തിരഞ്ഞെടുപ്പുകൾ നടത്തുന്നു.

1:14 ഈ സമയങ്ങൾ സ്ക്രീനിൽ കാണുന്ന പതിപ്പിന്റേതാണ്, അതായത് പൈത്തൺ 3.10. ഒരു പൈത്തൺ ലിസ്റ്റ് ഒബ്ജക്റ്റുകളിലേക്കുള്ള റഫറൻസുകൾ സംഭരിക്കുന്നു, അതിനാൽ വ്യത്യസ്ത തരം കാര്യങ്ങൾക്ക് ഒരു ലിസ്റ്റ് പങ്കിടാൻ കഴിയും. ഞങ്ങളുടെ ഗണിത ജോലിയിലുടനീളം സംഖ്യകൾ ഉപയോഗിക്കുന്നു. ഇത് ആവർത്തനപരമായ സേവനം ആവശ്യപ്പെടുമ്പോൾ ഒരു പൊതു ക്രമീകരണത്തിന് പണം നൽകുന്നു. ഒരു ദശലക്ഷം തവണ ഒരേ കാപ്പി ഓർഡർ ചെയ്യുന്നതും ഓരോ കപ്പിനും പുതിയ ഫോം പൂരിപ്പിക്കുന്നതും സങ്കൽപ്പിക്കുക. കാപ്പി മെഷീൻ നന്നായി പ്രവർത്തിക്കുന്നു.

1:36 പേപ്പർവർക്കുകൾക്ക് അതിൻ്റേതായ ഒരു കരിയർ വികസിച്ചു.

### NumPy ലൂപ്പ് എങ്ങോട്ട് മാറ്റുന്നു?

1:38 NumPy കരാർ മാറ്റുന്നു. ഈ അറേയിൽ ഒരു പ്രഖ്യാപിത തരം ഉള്ള സ്ഥിര വലുപ്പമുള്ള ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു. ഞങ്ങളുടെ അറേ തുടർച്ചയായതാണ്, അതിനാൽ അതിൻ്റെ മൂല്യങ്ങൾ മെമ്മറിയിൽ ഒരുമിച്ച് ഇരിക്കുന്നു. കാഴ്ചകൾക്ക് മറ്റ് ലേഔട്ടുകൾ ഉണ്ടാകാം. ഗണിത പ്രവർത്തനം ഏത് തരം ഡാറ്റയാണ് ലഭിക്കുന്നതെന്ന് അറിയുന്നു. കോൾ ബാച്ചിനെ ഒരു നേറ്റീവ് ഓപ്പറേഷനിലേക്ക് കൈമാറുന്നു. കംപൈൽ ചെയ്ത കോഡിനുള്ളിൽ ഒരു ലൂപ്പ് ഇപ്പോഴും മൂല്യങ്ങൾ സന്ദർശിക്കുന്നു. ആ ജോലിയിലുടനീളം ടൈപ്പിനെക്കുറിച്ചുള്ള അറിവ് വീണ്ടും ഉപയോഗിക്കാൻ ഇതിന് കഴിയും.

2:00 ജോലി കൈമാറുന്നയാൾ പൈത്തൺ ആയി തുടരുന്നു. ഇറ്റാമർ ടർണർ ട്രൂറിംഗ് പൈത്തൺ സ്പീഡിൽ ഈ വ്യത്യാസം വിശദീകരിക്കുന്നു. ബാച്ച് ഇൻ്റർഫേസുകൾ, നേറ്റീവ് ഇംപ്ലിമെൻ്റേഷനുകൾ, പ്രോസസർ വെക്റ്റർ നിർദ്ദേശങ്ങൾ എന്നിവ വ്യത്യസ്ത കാര്യങ്ങളാണ്. ഫംഗ്ഷൻ നാമം വളരെ കുറഞ്ഞ തെളിവുകൾ നൽകുന്നു.

### വേഗതയെന്നാൽ GPU ആണോ അതോ നിരവധി CPU കോറുകളാണോ?

2:13 ഈ ഫലം CPU-ൽ NumPy ഉപയോഗിച്ചു. CuPy പോലുള്ള ഒരു GPU ബാക്കെൻഡ് അറേകൾക്കും പ്രവർത്തനങ്ങൾക്കും വ്യത്യസ്തമായ ഒരു സ്ഥലം തിരഞ്ഞെടുക്കുന്നു. ഒരു GPU വാങ്ങുന്നത് ഈ സാധാരണ പൈത്തൺ ലൂപ്പിനെ അത് പ്രവർത്തിച്ചിരുന്നിടത്ത് തന്നെ പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു. CPU വെക്റ്റർ നിർദ്ദേശങ്ങൾക്ക് നിരവധി മൂല്യങ്ങൾ ഒരുമിച്ച് പ്രോസസ്സ് ചെയ്യാൻ കഴിയും. പിന്തുണയ്ക്കുന്ന കെർണലുകൾ തിരഞ്ഞെടുക്കുന്നതിനുള്ള സംവിധാനം NumPy-നുണ്ട്. ഞങ്ങളുടെ റൺടൈം ലഭ്യമായ ഫീച്ചറുകൾ റിപ്പോർട്ട് ചെയ്യുന്നു, പക്ഷേ ഈ എക്സ്പ്രഷൻ്റെ നിർദ്ദേശങ്ങൾ കണ്ടെത്തുന്നുമില്ല. മുഴുവൻ അളന്ന നേട്ടവും വെക്റ്റർ നിർദ്ദേശങ്ങൾക്ക് നൽകുന്നത് തെളിവുകളെ അമിതമായി വിൽക്കുന്നതിന് തുല്യമാകും.

2:40 GPU ഷോപ്പിംഗ് കാർട്ട് അടച്ചിടാം. ഒരു വാങ്ങൽ റദ്ദാക്കുന്ന ഒരു പ്രകടന പരിഹാരത്തിൽ അതിയായ സംതൃപ്തിയുണ്ട്. നിർഭാഗ്യവശാൽ, ബെഞ്ച്മാർക്ക് തുടരുന്നു.

### അതിശയകരമായ വേഗത വർദ്ധനവ് എപ്പോഴാണ് അപ്രത്യക്ഷമാകുന്നത്?

2:49 എട്ട് മൂല്യങ്ങളുള്ളപ്പോൾ, കോംപ്രിഹൻഷൻ വിജയിച്ചു. ചെറിയ ജോലിയെക്കാൾ അറേ മെഷീനറിയെ വിളിക്കുന്നതിന് കൂടുതൽ ചിലവായി. വലിയ റെഡി അറേകൾ മുന്നിട്ടുനിന്നു. ഞങ്ങൾ ആവർത്തിച്ചുള്ള പരീക്ഷണങ്ങളും ഒരു വാം ചെയ്ത പ്രോസസ്സും ഉപയോഗിച്ചു. പുതിയ പൈത്തൺ ബിൽഡുകൾക്ക് ക്രോസ്ഓവർ മാറ്റാൻ കഴിയും. തുടർന്ന് ആപ്ലിക്കേഷന് എന്താണ് വേണ്ടതെന്ന് മാറ്റുക. ഒരു പൈത്തൺ ലിസ്റ്റിൽ നിന്ന് ആരംഭിച്ച് ഒരു പുതിയ പൈത്തൺ ലിസ്റ്റിൽ അവസാനിപ്പിക്കുക. NumPy ഇൻപുട്ടിനെ ഒരു അറേയാക്കി മാറ്റുകയും ഉത്തരത്തെ പൈത്തൺ

3:11 ഒബ്ജക്റ്റുകളാക്കി മാറ്റുകയും വേണം. നിങ്ങളുടെ ആപ്ലിക്കേഷന് അവ ആവശ്യമാണെങ്കിൽ ആ ഘട്ടങ്ങൾ ബില്ലിൽ ഉൾപ്പെടുത്തണം. ഒരു ദശലക്ഷം മൂല്യങ്ങളിൽ, ആ പൂർണ്ണമായ പാതയ്ക്ക് ഏകദേശം ഇരുപത്തിയെട്ട് മില്ലിസെക്കൻഡ് എടുത്തു. കോംപ്രിഹൻഷനും ഏകദേശം ഇരുപത്തിയെട്ട് എടുത്തു. ഞങ്ങളുടെ നാടകീയമായ ലീഡ് ഏകദേശം തുല്യമായി മാറി. വേഗതയുള്ള ഭാഗം യഥാർത്ഥമായിരുന്നു. ഡാറ്റയെ അതിൻ്റെ സംഖ്യാപരമായ രൂപത്തിൽ നിലനിർത്താൻ അനുവദിക്കുന്നതിനെ ആശ്രയിച്ചായിരുന്നു നേട്ടം.

### ഏത് അതിരുകളാണ് ബെഞ്ച്മാർക്കിൽ ഉൾപ്പെടേണ്ടത്?

3:28 ഡാറ്റയെ പിന്തുടരുക. അടുത്ത പ്രവർത്തനം ഒരു അറേ സ്വീകരിക്കുകയാണെങ്കിൽ, അറേ നിലനിർത്തുക. നിങ്ങൾ ലിസ്റ്റുകൾക്കും അറേകൾക്കും ഇടയിൽ ആവർത്തിച്ച് പരിവർത്തനം ചെയ്യുകയാണെങ്കിൽ, ആ ക്രോസിംഗുകൾ അളക്കുക. വിലകൂടിയ കൈമാറ്റത്തിന് മുമ്പ് നിർത്തുന്നത് തെറ്റായ ചോദ്യത്തിന് കൃത്യമായ സംഖ്യകൾ നൽകുന്നു. ഈ അറേയെ ഗുണിക്കുന്നത് ഒരു താൽക്കാലിക ഫലം സൃഷ്ടിക്കുന്നു. യഥാർത്ഥ മൂല്യങ്ങൾ ചേർക്കുന്നത് ഔട്ട്പുട്ട് സൃഷ്ടിക്കുന്നു. നേറ്റീവ് എക്സിക്യൂഷന് ഇപ്പോഴും മെമ്മറിയും ഡാറ്റാ കൈമാറ്റവും ആവശ്യമാണ്.

3:47 ചില പ്രവർത്തനങ്ങൾ ഒരു ഔട്ട്പുട്ട് ബഫർ സ്വീകരിക്കുന്നു, നിങ്ങളുടെ കോഡിന് അത് സുരക്ഷിതമായി വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുമ്പോൾ അലോക്കേഷനുകൾ കുറയ്ക്കുന്നു. സുരക്ഷിതമായി വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുമ്പോൾ അലോക്കേഷനുകൾ കുറയ്ക്കുന്നു. ഒരു മനോഹരമായ വരിക്ക് നിരവധി വലിയ ബഫറുകൾ ഓർഡർ ചെയ്യാൻ കഴിയും. പൈത്തൺ സ്പീഡും ഈ പ്രശ്നം ചൂണ്ടിക്കാണിക്കുന്നു. നിങ്ങളുടെ സൗന്ദര്യബോധത്തോട് അലോക്കേറ്റർ അത്ഭുതകരമായി നിസ്സംഗത പുലർത്തുന്നു.

### കംപൈൽ ചെയ്ത പൈത്തൺ ലൂപ്പ് വേഗതയുള്ളതാകുമോ?

4:00 നിങ്ങൾക്ക് ലൂപ്പ് സിൻ്റക്സ് നിലനിർത്താനും അതിൻ്റെ എക്സിക്യൂഷൻ മാറ്റാനും കഴിയും. Numba പിന്തുണയ്ക്കുന്ന സംഖ്യാപരമായ പൈത്തൺ ഫംഗ്ഷനുകളെ നേറ്റീവ് കോഡിലേക്ക് കംപൈൽ ചെയ്യാൻ കഴിയും. ഇവിടെ ഞങ്ങളുടെ ടെസ്റ്റിലെ ലൂപ്പ് അതിൻ്റെ കംപൈലർ ഡെക്കറേറ്ററോടുകൂടി. അത് ഇപ്പോഴും 'for' എന്ന് പറയുന്നു. വിലകൂടിയ ഇൻ്റർപ്രെട്ടർ പാത മാറ്റിയിട്ടുണ്ട്. കംപൈലേഷന് ശേഷം, ഈ ലൂപ്പിന് റെഡി അറേകൾക്കൊപ്പം അര മില്ലിസെക്കൻഡിൽ കുറവ് എടുത്തു. കംപൈലേഷൻ തന്നെ ഈ റണ്ണിൽ ഏകദേശം ഒരു സെക്കൻഡ് എടുത്തു. ആ സെറ്റപ്പ് ചെലവ് ആവർത്തിച്ചുള്ള സമയങ്ങളിൽ നിന്ന് ഒഴിവാക്കി,

4:22 അതിനാൽ ഒരു ചെറിയ ഒറ്റത്തവണ ജോലിയ്ക്ക് വ്യത്യസ്ത താരതമ്യം അർഹമാണ്. Numba-യുടെ സ്വന്തം ഗൈഡ് വ്യക്തമായ ലൂപ്പുകൾ കാണിക്കുന്നതിൽ സന്തോഷിക്കുന്നു. ഹോട്ട് പാത്ത് കണ്ടെത്തുന്നതിന് മുമ്പ് ഒരു ഭാഷാ മൈഗ്രേഷൻ ആരംഭിക്കുന്നത് ഒരു പ്രൊഫൈലർ തുറക്കുന്നത് ഒഴിവാക്കാനുള്ള സങ്കീർണ്ണമായ ഒരു മാർഗ്ഗമാണ്. ആദ്യം സമയം എന്ത് ഉപയോഗിക്കുന്നു എന്ന് കണ്ടെത്തുക. നെറ്റ്‌വർക്ക് കാത്തിരിപ്പുകൾ, ഒബ്ജക്റ്റ് പാഴ്സിംഗ്, ബൾക്ക് ഗണിതം എന്നിവയ്ക്ക് വ്യത്യസ്ത പരിഹാരങ്ങൾ ആവശ്യമാണ്. കണക്കുകൂട്ടലും ഡാറ്റയും അനുയോജ്യമാകുമ്പോൾ നേറ്റീവ് അറേ പ്രവർത്തനങ്ങൾ സഹായിക്കുന്നു.

4:43 നിങ്ങളുടെ കോളർക്ക് യഥാർത്ഥത്തിൽ ആവശ്യമുള്ള ഫലം അളക്കുക. ഇനി ആ കുറുക്കുവഴി. നിങ്ങൾക്ക് ഒരു പൈത്തൺ ഫംഗ്ഷൻ ഉണ്ട്, അത് ഒരു അറേ സ്വീകരിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു. വെക്ടറൈസ് എന്ന് പേരുള്ള ഒരു റാപ്പർ നഷ്ടപ്പെട്ട പ്രകടന ബട്ടൺ പോലെ തോന്നുന്നു. അതിൻ്റെ ഡോക്യുമെൻ്റേഷനിൽ ഒരു പ്രധാന വാക്യം കാത്തിരിക്കുന്നു.

### np.vectorize യഥാർത്ഥത്തിൽ എന്താണ് എക്സിക്യൂട്ട് ചെയ്യുന്നത്?

4:56 NumPy പറയുന്നു, അതിൻ്റെ വെക്ടറൈസ് റാപ്പർ പ്രധാനമായും സൗകര്യത്തിനായി നൽകിയിട്ടുള്ളതാണ്. അതിൻ്റെ നടപ്പാക്കൽ അടിസ്ഥാനപരമായി ഒരു for ലൂപ്പാണ്. റാപ്പർ ബാച്ചുകൾ സ്വീകരിക്കുന്നു, പക്ഷേ അടുത്തടുത്ത എലമെൻ്റുകൾക്കായി നിങ്ങളുടെ പൈത്തൺ ഫംഗ്ഷൻ വിളിച്ചുകൊണ്ടിരിക്കുന്നു. ഇൻ്റർഫേസ് ചെറുതായി. എക്സിക്യൂഷൻ അതിർത്തി തിരക്കിലായിരുന്നു. പൈത്തൺ കോൾബാക്കിലൂടെ അതേ മൂല്യങ്ങൾ തിരികെ വരുന്നത് കാണുക. റെഡി അറേകൾ ഉപയോഗിച്ച്, ഈ പതിപ്പിന് ഏകദേശം എൺപത്തിയേഴ് മില്ലിസെക്കൻഡ് എടുത്തു. ഞങ്ങളുടെ കോംപ്രിഹൻഷനെക്കാൾ വേഗത കുറവായിരുന്നു അത്.

5:18 ഒരു ഉപയോഗപ്രദമായ ബ്രോഡ്കാസ്റ്റിംഗ് റാപ്പർക്ക് നിങ്ങൾ നീക്കം ചെയ്യാൻ ശ്രമിക്കുന്ന ഓരോ എലമെൻ്റ് ജോലിയും നിലനിർത്താൻ കഴിയും. ഒരു ബാച്ച് ഇൻ്റർഫേസിൻ്റെ പിന്നിലെ ഇംപ്ലിമെൻ്റേഷൻ പരിശോധിക്കുക, അനുയോജ്യമായ ഡാറ്റയെ അതിൻ്റെ ഉപയോഗപ്രദമായ രൂപത്തിൽ നിലനിർത്തുക, താരതമ്യത്തിൽ പരിവർത്തനം ഉൾപ്പെടുത്തുക. കോളറുടെ സ്ഥാനത്ത് നിന്ന് നേറ്റീവ്, കോൾബാക്ക്, കംപൈൽ ചെയ്ത ലൂപ്പുകൾ സമാനമായി തോന്നിയേക്കാം. വെക്ടറൈസ് എന്ന പേര് നിങ്ങളുടെ സ്റ്റോപ്പ് വാച്ച് ഒരിക്കലും ഒപ്പിടാത്ത ഒരു വാഗ്ദാനം നൽകി. സൗകര്യമാണ് നിങ്ങൾക്ക് ആവശ്യമെങ്കിൽ അത് നിലനിർത്തുക. പ്രകടനത്തിനായി, പ്രവർത്തിക്കുന്ന ലൂപ്പ് പരിശോധിക്കുക.

### നിങ്ങളുടെ കോഡിൽ എന്താണ് മാറ്റേണ്ടത്?

5:41 ഒരു അളന്ന സംഖ്യാപരമായ ഹോട്ട് പാത്ത് ബാച്ച് ചെയ്യുന്നതിന് എൻ്റെ വിധി SHIP IT എന്നാണ്. സാധാരണ ലൂപ്പുകൾ നന്നായി പ്രവർത്തിക്കുമ്പോൾ അവ നിലനിർത്തുക. ജോലി എവിടെ നടക്കുന്നു, അടുത്ത കോളർക്ക് എന്താണ് വേണ്ടതെന്ന് പരിശോധിക്കുക. സബ്സ്ക്രൈബ് ചെയ്യുക, ബെൽ അടിക്കുക, നിങ്ങൾ അത് മറ്റൊരു രീതിയിൽ സ്റ്റാമ്പ് ചെയ്യുമായിരുന്നെങ്കിൽ കമൻ്റുകളിൽ എന്നോട് പറയുക. മറ്റൊരു രീതിയിൽ സ്റ്റാമ്പ് ചെയ്യുമായിരുന്നെങ്കിൽ കമൻ്റുകളിൽ എന്നോട് പറയുക. ഇന്നത്തെ വ്യത്യാസം ഇതാണ്. ഞാൻ Axrisi-ൽ നിന്നുള്ള Niko ആണ്. ഉത്തരവാദിത്തത്തോടെ ലയിപ്പിക്കുക.

## ഉറവിടങ്ങൾ

- [Universal functions (ufunc) basics — NumPy 2.2](https://numpy.org/doc/2.2/user/basics.ufuncs.html) — NumPy
- [The N-dimensional array — NumPy 2.2](https://numpy.org/doc/2.2/reference/arrays.ndarray.html) — NumPy
- [numpy.vectorize — convenience and performance notes](https://numpy.org/doc/2.2/reference/generated/numpy.vectorize.html) — NumPy
- [CPU/SIMD optimizations — NumPy 2.2](https://numpy.org/doc/2.2/reference/simd/index.html) — NumPy
- [dis — Disassembler for Python bytecode](https://docs.python.org/3.10/library/dis.html) — Python Software Foundation
- [CPython 3.10.12 list representation](https://github.com/python/cpython/blob/v3.10.12/Include/cpython/listobject.h) — CPython contributors
- [The limits of Python vectorization as a performance technique](https://pythonspeed.com/articles/vectorization-python-alternatives/) — Itamar Turner-Trauring / Python⇒Speed
- [Performance Tips](https://numba.readthedocs.io/en/stable/user/performance-tips.html) — Numba
- [Basics of CuPy](https://docs.cupy.dev/en/stable/user_guide/basic.html) — CuPy