ಪೈಥಾನ್ ಕಾರ್ಯಕ್ಷಮತೆ: ಸ್ಥಳೀಯ ನಂಪೈ ಲೂಪ್‌ಗಳು, ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳು ಮತ್ತು ಪರಿವರ್ತನೆ ವೆಚ್ಚಗಳು

ಈ ವೀಡಿಯೊ ಏನನ್ನು ಒಳಗೊಂಡಿದೆ

• CPython ಮೂಲವನ್ನು ಬೈಟ್‌ಕೋಡ್‌ಗೆ ಸಂಕಲಿಸುತ್ತದೆ. ಪುನರಾವರ್ತಿತ ಇಂಟರ್‌ಪ್ರಿಟರ್/ಆಬ್ಜೆಕ್ಟ್ ಕೆಲಸ ಮತ್ತು ಟೈಪ್ ಮಾಡಿದ ಸ್ಥಳೀಯ ಸಂಖ್ಯಾತ್ಮಕ ಲೂಪ್ ವಿಭಿನ್ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ವ್ಯವಸ್ಥೆಗಳಾಗಿವೆ.
• ಸಂಖ್ಯಾತ್ಮಕ ನಂಪೈ ಅಂಕಗಣಿತವು ಸಂಕಲಿತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಟೈಪ್ ಮಾಡಿದ ಬ್ಯಾಚ್‌ಗಳನ್ನು ಹಸ್ತಾಂತರಿಸಬಹುದು; ಅಂಕಗಣಿತದ ಲೂಪ್ ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಮತ್ತು ವೀಕ್ಷಣೆಗಳು ಅಸಂಖ್ಯಾತ ವಿನ್ಯಾಸಗಳನ್ನು ಹೊಂದಿರಬಹುದು.
• ಪರಿವರ್ತನೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಔಟ್‌ಪುಟ್ ಪ್ರಾತಿನಿಧ್ಯವನ್ನು ಅಳೆಯಿರಿ. ಈ ರನ್‌ನಲ್ಲಿ, ಪೈಥಾನ್ ಪಟ್ಟಿಗಳನ್ನು ಅರೇಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದು ಮತ್ತು ಹಿಂತಿರುಗಿಸುವುದು ದೊಡ್ಡ ಸಿದ್ಧ-ಅರೇ ಮುನ್ನಡೆಯನ್ನು ಅಳಿಸಿತು.
• ಸಣ್ಣ ಕೆಲಸದ ಹೊರೆಗಳು ಸಾಮಾನ್ಯ ಪೈಥಾನ್‌ಗೆ ಅನುಕೂಲಕರವಾಗಬಹುದು ಏಕೆಂದರೆ ಸ್ಥಿರ ಅರೇ-ಕಾಲ್ ವೆಚ್ಚಗಳು ಮುಖ್ಯವಾಗಿವೆ. ಎಂಟು-ಮೌಲ್ಯದ ಕಾಂಪ್ರಹೆನ್ಷನ್ ಈ ಅಳತೆಯ ಹೋಲಿಕೆಯನ್ನು ಗೆದ್ದಿದೆ.
• np.vectorize ಒಂದು ಅನುಕೂಲಕರ ರ‍್ಯಾಪರ್ ಆಗಿದ್ದು, ಇದು ಅನುಕ್ರಮ ಅಂಶಗಳಿಗಾಗಿ ಪೈಥಾನ್ ಅನ್ನು ಕರೆಯುತ್ತದೆ; ಬ್ಯಾಚ್ ಇಂಟರ್ಫೇಸ್ ಮಾತ್ರ ಸ್ಥಳೀಯ ಸಂಖ್ಯಾತ್ಮಕ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಸ್ಥಾಪಿಸುವುದಿಲ್ಲ.
• ಸಂಕಲಿತ ಪೈಥಾನ್-ಸಿಂಟ್ಯಾಕ್ಸ್ ಲೂಪ್‌ಗಳು ಸಹ ವೇಗವಾಗಿರಬಹುದು. ಕರೆ ಮಾಡುವವರಿಗೆ ಅವು ಮುಖ್ಯವಾಗಿದ್ದಾಗ ಶೀತ ಸಂಕಲನ/ಸೆಟಪ್ ವೆಚ್ಚಗಳನ್ನು ಸೇರಿಸಿ.
• ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ, CPU SIMD, ಮಲ್ಟಿಥ್ರೆಡಿಂಗ್ ಮತ್ತು GPU ಬ್ಯಾಕೆಂಡ್‌ಗಳು ಪ್ರತ್ಯೇಕ ವಿಚಾರಗಳಾಗಿವೆ. ಲಭ್ಯವಿರುವ CPU ವೈಶಿಷ್ಟ್ಯಗಳು ನಿರ್ದಿಷ್ಟ ರನ್‌ನಲ್ಲಿ ಬಳಸಿದ ಸೂಚನೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದಿಲ್ಲ.

ಅನುವಾದಿತ ಪ್ರತಿಲೇಖನ

ಮೂಲ ಇಂಗ್ಲಿಷ್ ನಿರೂಪಣೆಯಿಂದ ಅನುವಾದಿಸಲಾಗಿದೆ. ಲಭ್ಯವಿರುವ ಆಡಿಯೋ ಮತ್ತು ಶೀರ್ಷಿಕೆಗಳನ್ನು YouTube ನಿಯಂತ್ರಿಸುತ್ತದೆ.

ಒಂದೇ CPU ಏಕೆ ಬೇಗ ಮುಗಿಸಬಹುದು?

0:00 ಪೈಥಾನ್ ವೇಗವಾಗಿ ಬರಲು ಹೊಸ ಭಾಷೆ ಬೇಕು ಎಂದು ನೀವು ಭಾವಿಸುತ್ತೀರಿ. ಲೂಪ್ ಸ್ಥಳಾಂತರಗೊಂಡ ನಂತರ ಅದೇ CPU ನಮ್ಮ ಬ್ಯಾಚ್ ಅನ್ನು ವೇಗವಾಗಿ ಚಲಾಯಿಸಿತು. ಕೆಲಸ ಎಲ್ಲಿಗೆ ಹೋಯಿತು? ವೇಗ ಯಾವಾಗ ಮಾಯವಾಗುತ್ತದೆ? ಯಾವ ಶಾರ್ಟ್‌ಕಟ್ ಪೈಥಾನ್ ಅನ್ನು ಮರಳಿ ತರುತ್ತದೆ? ಇದು The Daily Diff, ತೆರೆಮರೆಯಲ್ಲಿ. ಆ ಶಾರ್ಟ್‌ಕಟ್ ಮೇಲೆ ಕಣ್ಣಿಡಿ. CPython ಪ್ರಮಾಣಿತ ಪೈಥಾನ್ ಅನುಷ್ಠಾನವಾಗಿದೆ.

0:17 ಇದು ನಿಮ್ಮ ಮೂಲವನ್ನು ಬೈಟ್‌ಕೋಡ್‌ಗೆ ಸಂಕಲಿಸುತ್ತದೆ, ನಂತರ ಆ ಸೂಚನೆಗಳನ್ನು an ನಲ್ಲಿ ಚಲಾಯಿಸುತ್ತದೆ. ಇಂಟರ್‌ಪ್ರಿಟರ್. ನಂಪೈ ಒಂದು ಸಂಖ್ಯಾತ್ಮಕ ಗ್ರಂಥಾಲಯವಾಗಿದ್ದು, ಇದರ ಅರೇಗಳು ಘೋಷಿತ ಡೇಟಾ ಪ್ರಕಾರದೊಂದಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಇದರ ಅಂತರ್ಗತ ಅಂಕಗಣಿತವು ಸಂಪೂರ್ಣ ಬ್ಯಾಚ್ ಅನ್ನು ಸಂಕಲಿತ ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ಹಸ್ತಾಂತರಿಸಬಹುದು. ಒಂದು ಮಿಲಿಯನ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಂಡು, ಪ್ರತಿಯೊಂದನ್ನು ವರ್ಗ ಮಾಡಿ, ನಂತರ ಮೂಲ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಿ. ಪ್ರತಿಯೊಂದು ಆವೃತ್ತಿಯು ಒಂದೇ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತದೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯ ಉತ್ತರಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ. ವೃತ್ತಿಪರ ಭಿನ್ನತೆಗಳನ್ನು ರೇಸ್‌ನಿಂದ ಹೊರಗಿಡಲು ಮೌಲ್ಯಗಳು ಸಾಕಷ್ಟು ಚಿಕ್ಕದಾಗಿವೆ. ಈ ಯಂತ್ರದಲ್ಲಿ, ಕಾಂಪ್ರಹೆನ್ಷನ್ ಸುಮಾರು ಮೂವತ್ಮೂರು ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು.

0:40 ನಂಪೈ ಒಂದು ಮಿಲಿಸೆಕೆಂಡ್‌ಗಿಂತ ಕಡಿಮೆ ಸಮಯ ತೆಗೆದುಕೊಂಡಿತು. ಎರಡೂ CPU ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದವು. ಇದು ಈ ಕೆಲಸದ ಹೊರೆಗೆ ಉಪಯುಕ್ತ ಸಾಕ್ಷ್ಯವಾಗಿದೆ, ಮತ್ತು ಒಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗೆ ಒಂದು ಭೀಕರ ಮರಣಪತ್ರವಾಗಿದೆ. ಸಾಮಾನ್ಯ ಲೂಪ್‌ನಿಂದ ಪ್ರಾರಂಭಿಸಿ. ಪೈಥಾನ್ ಮುಂದಿನ ಮೌಲ್ಯವನ್ನು ಪಡೆಯುತ್ತದೆ, ಅಂಕಗಣಿತವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಉತ್ತರವನ್ನು ಸೇರಿಸುತ್ತದೆ.

ಪೈಥಾನ್ ಲೂಪ್ ಯಾವ ಕೆಲಸವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ?

0:53 ನಂತರ ಅದು ಮತ್ತೆ ಹಾಗೆ ಮಾಡುತ್ತದೆ. ಗುಣಾಕಾರ ಅಗ್ಗವಾಗಿದೆ. ಮುಂದಿನ ಗುಣಾಕಾರವನ್ನು ಆಯೋಜಿಸುವುದು, ಮತ್ತು ಅದರ ಸುತ್ತಲಿನ ಪೈಥಾನ್ ವಸ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು, ಪ್ರತಿ ಬಾರಿಯೂ ಕೆಲಸವನ್ನು ಸೇರಿಸುತ್ತದೆ. ಇದು ಪರೀಕ್ಷಿಸಿದ ಕಾರ್ಯದ ನೈಜ ಡಿಸ್ಅಸೆಂಬ್ಲಿ ಆಗಿದೆ. ಪುನರಾವರ್ತನೆ, ಗುಣಾಕಾರ ಮತ್ತು ಸೇರ್ಪಡೆ ಬೈಟ್‌ಕೋಡ್ ಸೂಚನೆಗಳಾಗಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ. ಪೈಥಾನ್ ಆವೃತ್ತಿಗಳು ಮತ್ತು ಇಂಟರ್‌ಪ್ರಿಟರ್‌ಗಳು ವಿಭಿನ್ನ ಆಯ್ಕೆಗಳನ್ನು ಮಾಡುತ್ತವೆ. ಈ ಸಮಯಗಳು ತೆರೆಯ ಮೇಲಿನ ಆವೃತ್ತಿಗೆ ಸೇರಿವೆ, ಅದು ಪೈಥಾನ್ ಮೂರು ಪಾಯಿಂಟ್ ಹತ್ತು.

1:14 ಪೈಥಾನ್ ಪಟ್ಟಿಯು ವಸ್ತುಗಳಿಗೆ ಉಲ್ಲೇಖಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ವಿಭಿನ್ನ ರೀತಿಯ ವಿಷಯಗಳು ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹಂಚಿಕೊಳ್ಳಬಹುದು. ನಮ್ಮ ಅಂಕಗಣಿತದ ಕೆಲಸವು ಉದ್ದಕ್ಕೂ ಸಂಖ್ಯೆಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಇದು ಪುನರಾವರ್ತಿತ ಸೇವೆಯನ್ನು ವಿನಂತಿಸುವಾಗ ಸಾಮಾನ್ಯ ವ್ಯವಸ್ಥೆಗೆ ಪಾವತಿಸುತ್ತದೆ. ಒಂದೇ ಕಾಫಿಯನ್ನು ಒಂದು ಮಿಲಿಯನ್ ಬಾರಿ ಆರ್ಡರ್ ಮಾಡುವುದನ್ನು ಮತ್ತು ಪ್ರತಿ ಕಪ್‌ಗೆ ಹೊಸ ಫಾರ್ಮ್ ಅನ್ನು ಭರ್ತಿ ಮಾಡುವುದನ್ನು ಊಹಿಸಿ. ಕಾಫಿ ಯಂತ್ರವು ಉತ್ತಮವಾಗಿದೆ. ದಾಖಲೆಗಳು ತನ್ನದೇ ಆದ ವೃತ್ತಿಜೀವನವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿವೆ. ನಂಪೈ ಒಪ್ಪಂದವನ್ನು ಬದಲಾಯಿಸುತ್ತದೆ.

1:36 ಈ ಅರೇ ಒಂದು ಘೋಷಿತ ಪ್ರಕಾರದೊಂದಿಗೆ ಸ್ಥಿರ ಗಾತ್ರದ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ.

ನಂಪೈ ಲೂಪ್ ಅನ್ನು ಎಲ್ಲಿಗೆ ಸರಿಸುತ್ತದೆ?

1:38 ನಮ್ಮ ಅರೇ ಸತತವಾಗಿದೆ, ಆದ್ದರಿಂದ ಅದರ ಮೌಲ್ಯಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಒಟ್ಟಿಗೆ ಇರುತ್ತವೆ. ವೀಕ್ಷಣೆಗಳು ಇತರ ವಿನ್ಯಾಸಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಅಂಕಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಯು ಯಾವ ರೀತಿಯ ಡೇಟಾವನ್ನು ಪಡೆಯುತ್ತಿದೆ ಎಂದು ತಿಳಿದಿದೆ. ಕರೆ ಬ್ಯಾಚ್ ಅನ್ನು ಸ್ಥಳೀಯ ಕಾರ್ಯಾಚರಣೆಗೆ ಹಸ್ತಾಂತರಿಸುತ್ತದೆ. ಲೂಪ್ ಇನ್ನೂ ಸಂಕಲಿತ ಕೋಡ್‌ನೊಳಗೆ ಮೌಲ್ಯಗಳನ್ನು ಭೇಟಿ ಮಾಡುತ್ತದೆ. ಇದು ಆ ಕೆಲಸದ ಉದ್ದಕ್ಕೂ ಪ್ರಕಾರದ ಜ್ಞಾನವನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದು. ಪೈಥಾನ್ ಇನ್ನೂ ಕೆಲಸವನ್ನು ಹಸ್ತಾಂತರಿಸುವ ವ್ಯಕ್ತಿಯಾಗಿ ಉಳಿದಿದೆ. ಇಟಾಮರ್ ಟರ್ನರ್ ಟ್ರೂರಿಂಗ್ ಪೈಥಾನ್ ಸ್ಪೀಡ್‌ನಲ್ಲಿ ವ್ಯತ್ಯಾಸವನ್ನು ವಿವರಿಸುತ್ತಾರೆ.

2:00 ಬ್ಯಾಚ್ ಇಂಟರ್ಫೇಸ್‌ಗಳು, ಸ್ಥಳೀಯ ಅನುಷ್ಠಾನಗಳು ಮತ್ತು ಪ್ರೊಸೆಸರ್ ವೆಕ್ಟರ್ ಸೂಚನೆಗಳು ಪ್ರತ್ಯೇಕ ವಿಷಯಗಳಾಗಿವೆ. ಕಾರ್ಯದ ಹೆಸರಿನಲ್ಲಿ ಬಹಳ ಕಡಿಮೆ ಸಾಕ್ಷ್ಯಗಳಿವೆ. ಈ ಫಲಿತಾಂಶವು CPU ನಲ್ಲಿ ನಂಪೈ ಅನ್ನು ಬಳಸಿದೆ. CuPy ನಂತಹ GPU ಬ್ಯಾಕೆಂಡ್ ಅರೇಗಳು ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಗಳಿಗೆ ವಿಭಿನ್ನ ಮನೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. GPU ಖರೀದಿಸುವುದು ಈ ಸಾಮಾನ್ಯ ಪೈಥಾನ್ ಲೂಪ್ ಅನ್ನು ಅದು ಈಗಾಗಲೇ ಚಲಾಯಿಸಿದ ಸ್ಥಳದಲ್ಲಿಯೇ ಚಲಾಯಿಸುತ್ತದೆ.

ವೇಗ ಎಂದರೆ GPU ಅಥವಾ ಅನೇಕ CPU ಕೋರ್‌ಗಳೇ?

2:13 CPU ವೆಕ್ಟರ್ ಸೂಚನೆಗಳು ಹಲವಾರು ಮೌಲ್ಯಗಳನ್ನು ಒಟ್ಟಿಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು. ನಂಪೈ ಬೆಂಬಲಿತ ಕರ್ನಲ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ಯಂತ್ರೋಪಕರಣಗಳನ್ನು ಹೊಂದಿದೆ. ನಮ್ಮ ರನ್‌ಟೈಮ್ ಲಭ್ಯವಿರುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ, ಆದರೆ ಈ ಅಭಿವ್ಯಕ್ತಿಯ ಸೂಚನೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದಿಲ್ಲ. ವೆಕ್ಟರ್ ಸೂಚನೆಗಳಿಗೆ ಸಂಪೂರ್ಣ ಅಳತೆಯ ಲಾಭವನ್ನು ನೀಡುವುದು ಸಾಕ್ಷ್ಯವನ್ನು ಅತಿಯಾಗಿ ಮಾರುತ್ತದೆ. GPU ಶಾಪಿಂಗ್ ಕಾರ್ಟ್ ಅನ್ನು ಮುಚ್ಚಿಡಬಹುದು. ಖರೀದಿಯನ್ನು ರದ್ದುಗೊಳಿಸುವ ಕಾರ್ಯಕ್ಷಮತೆಯ ಪರಿಹಾರದ ಬಗ್ಗೆ ಏನೋ ಆಳವಾದ ತೃಪ್ತಿಕರ ಸಂಗತಿ ಇದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಬೆಂಚ್‌ಮಾರ್ಕ್ ಮುಂದುವರಿಯುತ್ತದೆ. ಎಂಟು ಮೌಲ್ಯಗಳೊಂದಿಗೆ, ಕಾಂಪ್ರಹೆನ್ಷನ್ ಗೆದ್ದಿತು. ಅರೇ ಯಂತ್ರೋಪಕರಣಗಳನ್ನು ಕರೆಯುವುದು ಸಣ್ಣ ಕೆಲಸಕ್ಕಿಂತ ಹೆಚ್ಚು ವೆಚ್ಚದಾಯಕವಾಗಿದೆ. ದೊಡ್ಡ ಸಿದ್ಧ ಅರೇಗಳು ಮುಂದಕ್ಕೆ ಸಾಗಿದವು.

2:40 ನಾವು ಪುನರಾವರ್ತಿತ ಪ್ರಯೋಗಗಳನ್ನು ಮತ್ತು ಬೆಚ್ಚಗಿನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಬಳಸಿದ್ದೇವೆ. ಹೊಸ ಪೈಥಾನ್ ನಿರ್ಮಾಣಗಳು ಕ್ರಾಸ್ಒವರ್ ಅನ್ನು ಬದಲಾಯಿಸಬಹುದು. ನಂತರ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಏನು ಬೇಕು ಎಂಬುದನ್ನು ಬದಲಾಯಿಸಿ.

ಮನೋಭಾವದ ವೇಗ ಯಾವಾಗ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ?

2:49 ಪೈಥಾನ್ ಪಟ್ಟಿಯಿಂದ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಹೊಸ ಪೈಥಾನ್ ಪಟ್ಟಿಯೊಂದಿಗೆ ಮುಗಿಸಿ. ನಂಪೈ ಇನ್‌ಪುಟ್ ಅನ್ನು ಅರೇ ಆಗಿ ಪರಿವರ್ತಿಸಬೇಕು ಮತ್ತು ಉತ್ತರವನ್ನು ಮತ್ತೆ ಪೈಥಾನ್ ವಸ್ತುಗಳಾಗಿ ಪರಿವರ್ತಿಸಬೇಕು. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಅವು ಅಗತ್ಯವಿದ್ದರೆ ಆ ಹಂತಗಳು ಬಿಲ್‌ನಲ್ಲಿ ಸೇರಿವೆ. ಒಂದು ಮಿಲಿಯನ್ ಮೌಲ್ಯಗಳಲ್ಲಿ, ಆ ಸಂಪೂರ್ಣ ಮಾರ್ಗವು ಸುಮಾರು ಇಪ್ಪತ್ತೆಂಟು ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಕಾಂಪ್ರಹೆನ್ಷನ್ ಸಹ ಸುಮಾರು ಇಪ್ಪತ್ತೆಂಟು ತೆಗೆದುಕೊಂಡಿತು. ನಮ್ಮ ನಾಟಕೀಯ ಮುನ್ನಡೆ ಸರಿಸುಮಾರು ಸಮಾನಕ್ಕೆ ಇಳಿಯಿತು. ವೇಗದ ಭಾಗವು ನೈಜವಾಗಿತ್ತು. ಪ್ರಯೋಜನವು ಡೇಟಾವನ್ನು ಅದರ ಸಂಖ್ಯಾತ್ಮಕ ರೂಪದಲ್ಲಿ ಉಳಿಸಲು ಬಿಡುವುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ಡೇಟಾವನ್ನು ಅನುಸರಿಸಿ.

3:11 ಮುಂದಿನ ಕಾರ್ಯಾಚರಣೆಯು ಅರೇ ಅನ್ನು ಸ್ವೀಕರಿಸಿದರೆ, ಅರೇ ಅನ್ನು ಇರಿಸಿ. ನೀವು ಪಟ್ಟಿಗಳು ಮತ್ತು ಅರೇಗಳ ನಡುವೆ ಪುನರಾವರ್ತಿತವಾಗಿ ಪರಿವರ್ತಿಸಿದರೆ, ಆ ದಾಟುವಿಕೆಗಳನ್ನು ಅಳೆಯಿರಿ. ದುಬಾರಿ ಹ್ಯಾಂಡ್‌ಆಫ್‌ಗೆ ಮೊದಲು ನಿಲ್ಲಿಸುವುದು ತಪ್ಪಾದ ಪ್ರಶ್ನೆಗೆ ನಿಖರವಾದ ಸಂಖ್ಯೆಗಳನ್ನು ನೀಡುತ್ತದೆ. ಈ ಅರೇ ಅನ್ನು ಗುಣಿಸುವುದು ತಾತ್ಕಾಲಿಕ ಫಲಿತಾಂಶವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಮೂಲ ಮೌಲ್ಯಗಳನ್ನು ಸೇರಿಸುವುದು ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

ಬೆಂಚ್‌ಮಾರ್ಕ್‌ನಲ್ಲಿ ಯಾವ ಗಡಿಗಳು ಸೇರಿವೆ?

3:28 ಸ್ಥಳೀಯ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗೆ ಇನ್ನೂ ಮೆಮೊರಿ ಮತ್ತು ಡೇಟಾ ಚಲನೆ ಅಗತ್ಯವಿದೆ. ಕೆಲವು ಕಾರ್ಯಾಚರಣೆಗಳು ಔಟ್‌ಪುಟ್ ಬಫರ್ ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತವೆ, ನಿಮ್ಮ ಕೋಡ್ ಅದನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದಾಗ ಹಂಚಿಕೆಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಒಂದು ಸುಂದರವಾದ ಸಾಲು ಹಲವಾರು ದೊಡ್ಡ ಬಫರ್‌ಗಳನ್ನು ಆರ್ಡರ್ ಮಾಡಬಹುದು. ಪೈಥಾನ್ ಸ್ಪೀಡ್ ಸಹ ಈ ಸಮಸ್ಯೆಯನ್ನು ಎತ್ತಿ ತೋರಿಸುತ್ತದೆ. ಹಂಚಿಕೆದಾರರು ನಿಮ್ಮ ಸೌಂದರ್ಯಕ್ಕೆ ಗಮನಾರ್ಹವಾಗಿ ಅಸಡ್ಡೆಯಾಗಿದ್ದಾರೆ. ನೀವು ಲೂಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಸಹ ಇರಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತು ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಬದಲಾಯಿಸಬಹುದು. ನಂಬಾ ಬೆಂಬಲಿತ ಸಂಖ್ಯಾತ್ಮಕ ಪೈಥಾನ್ ಕಾರ್ಯಗಳನ್ನು ಸ್ಥಳೀಯ ಕೋಡ್‌ಗೆ ಸಂಕಲಿಸಬಹುದು. ಇಲ್ಲಿ ನಮ್ಮ ಪರೀಕ್ಷೆಯಿಂದ ಲೂಪ್ ಅದರ ಕಂಪೈಲರ್ ಡೆಕೋರೇಟರ್‌ನೊಂದಿಗೆ ಇದೆ.

3:47 ಇದು ಇನ್ನೂ 'ಫಾರ್' ಎಂದು ಹೇಳುತ್ತದೆ. ದುಬಾರಿ ಇಂಟರ್‌ಪ್ರಿಟರ್ ಮಾರ್ಗ ಬದಲಾಗಿದೆ. ಸಂಕಲನದ ನಂತರ, ಈ ಲೂಪ್ ಸಿದ್ಧ ಅರೇಗಳೊಂದಿಗೆ ಅರ್ಧ ಮಿಲಿಸೆಕೆಂಡ್‌ಗಿಂತ ಕಡಿಮೆ ಸಮಯ ತೆಗೆದುಕೊಂಡಿತು. ಈ ರನ್‌ನಲ್ಲಿ ಸಂಕಲನಕ್ಕೆ ಸುಮಾರು ಒಂದು ಸೆಕೆಂಡ್ ತೆಗೆದುಕೊಂಡಿತು. ಆ ಸೆಟಪ್ ವೆಚ್ಚವನ್ನು ಪುನರಾವರ್ತಿತ ಸಮಯದಿಂದ ಹೊರಗಿಡಲಾಯಿತು,

ಸಂಕಲಿತ ಪೈಥಾನ್ ಲೂಪ್ ಸಹ ವೇಗವಾಗಿರಬಹುದೇ?

4:00 ಆದ್ದರಿಂದ ಒಂದು ಸಣ್ಣ ಒಂದು-ಬಾರಿ ಕೆಲಸವು ವಿಭಿನ್ನ ಹೋಲಿಕೆಗೆ ಅರ್ಹವಾಗಿದೆ. ನಂಬಾ ಸ್ವಂತ ಮಾರ್ಗದರ್ಶಿ ಸ್ಪಷ್ಟ ಲೂಪ್‌ಗಳನ್ನು ತೋರಿಸಲು ಸಂತೋಷವಾಗಿದೆ. ಹಾಟ್ ಪಾತ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವ ಮೊದಲು ಭಾಷಾ ವಲಸೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಪ್ರೊಫೈಲರ್ ತೆರೆಯುವುದನ್ನು ತಪ್ಪಿಸಲು ಒಂದು ವಿಸ್ತಾರವಾದ ಮಾರ್ಗವಾಗಿದೆ. ಮೊದಲು ಸಮಯವನ್ನು ಏನು ಸೇವಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಿರಿ. ನೆಟ್‌ವರ್ಕ್ ಕಾಯುವಿಕೆಗಳು, ಆಬ್ಜೆಕ್ಟ್ ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಬೃಹತ್ ಅಂಕಗಣಿತವು ವಿಭಿನ್ನ ಪರಿಹಾರಗಳಿಗೆ ಕರೆ ನೀಡುತ್ತವೆ. ಸ್ಥಳೀಯ ಅರೇ ಕಾರ್ಯಾಚರಣೆಗಳು ಲೆಕ್ಕಾಚಾರ ಮತ್ತು ಡೇಟಾ ಹೊಂದಿಕೆಯಾದಾಗ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ನಿಮ್ಮ ಕರೆ ಮಾಡುವವರು ನಿಜವಾಗಿ ಏನು ಬೇಕು ಎಂಬುದನ್ನು ಅಳೆಯಿರಿ.

4:22 ಈಗ ಆ ಶಾರ್ಟ್‌ಕಟ್‌ಗಾಗಿ. ನೀವು ಪೈಥಾನ್ ಕಾರ್ಯವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಮತ್ತು ಅದು ಅರೇ ಅನ್ನು ಸ್ವೀಕರಿಸಬೇಕೆಂದು ಬಯಸುತ್ತೀರಿ. ವೆಕ್ಟರೈಜ್ ಎಂಬ ರ‍್ಯಾಪರ್ ಕಾಣೆಯಾದ ಕಾರ್ಯಕ್ಷಮತೆ ಬಟನ್‌ನಂತೆ ಧ್ವನಿಸುತ್ತದೆ. ಅದರ ದಾಖಲಾತಿಯಲ್ಲಿ ಒಂದು ಪ್ರಮುಖ ವಾಕ್ಯ ಕಾಯುತ್ತಿದೆ. ನಂಪೈ ಹೇಳುತ್ತದೆ ಅದರ ವೆಕ್ಟರೈಜ್ ರ‍್ಯಾಪರ್ ಅನ್ನು ಪ್ರಾಥಮಿಕವಾಗಿ ಅನುಕೂಲಕ್ಕಾಗಿ ಒದಗಿಸಲಾಗಿದೆ. ಅದರ ಅನುಷ್ಠಾನವು ಮೂಲಭೂತವಾಗಿ ಒಂದು ಫಾರ್ ಲೂಪ್ ಆಗಿದೆ. ರ‍್ಯಾಪರ್ ಬ್ಯಾಚ್‌ಗಳನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಆದರೆ ಅನುಕ್ರಮ ಅಂಶಗಳಿಗಾಗಿ ನಿಮ್ಮ ಪೈಥಾನ್ ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತಲೇ ಇರುತ್ತದೆ. ಇಂಟರ್ಫೇಸ್ ಚಿಕ್ಕದಾಯಿತು. ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಗಡಿ ಕಾರ್ಯನಿರತವಾಗಿತ್ತು.

4:43 ಪೈಥಾನ್ ಕಾಲ್‌ಬ್ಯಾಕ್ ಮೂಲಕ ಅದೇ ಮೌಲ್ಯಗಳು ಮರಳಿ ಬರುವುದನ್ನು ವೀಕ್ಷಿಸಿ. ಸಿದ್ಧ ಅರೇಗಳೊಂದಿಗೆ, ಈ ಆವೃತ್ತಿಯು ಸುಮಾರು ಎಂಬತ್ತೇಳು ಮಿಲಿಸೆಕೆಂಡುಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಇದು ನಮ್ಮ ಕಾಂಪ್ರಹೆನ್ಷನ್‌ಗಿಂತ ನಿಧಾನವಾಗಿತ್ತು. ಉಪಯುಕ್ತ ಪ್ರಸಾರ ರ‍್ಯಾಪರ್ ನೀವು ತೆಗೆದುಹಾಕಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದ ಪ್ರತಿ-ಅಂಶದ ನಿಖರ ಕೆಲಸವನ್ನು ಸಂರಕ್ಷಿಸಬಹುದು. ಬ್ಯಾಚ್ ಇಂಟರ್ಫೇಸ್‌ನ ಹಿಂದಿನ ಅನುಷ್ಠಾನವನ್ನು ಪರಿಶೀಲಿಸಿ, ಹೊಂದಾಣಿಕೆಯ ಡೇಟಾವನ್ನು ಅದರ ಉಪಯುಕ್ತ ರೂಪದಲ್ಲಿ ಇರಿಸಿ, ಮತ್ತು ಹೋಲಿಕೆಯಲ್ಲಿ ಪರಿವರ್ತನೆಯನ್ನು ಸೇರಿಸಿ.

np.vectorize ವಾಸ್ತವವಾಗಿ ಏನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ?

4:56 ಸ್ಥಳೀಯ, ಕಾಲ್‌ಬ್ಯಾಕ್ ಮತ್ತು ಸಂಕಲಿತ ಲೂಪ್‌ಗಳು ಕರೆ ಮಾಡುವವರ ಕುರ್ಚಿಯಿಂದ ಒಂದೇ ರೀತಿ ಕಾಣಿಸಬಹುದು. ವೆಕ್ಟರೈಜ್ ಎಂಬ ಹೆಸರು ನಿಮ್ಮ ಸ್ಟಾಪ್‌ವಾಚ್ ಎಂದಿಗೂ ಸಹಿ ಹಾಕದ ಭರವಸೆಯನ್ನು ನೀಡಿತು. ಅನುಕೂಲವೇ ನಿಮಗೆ ಬೇಕಾಗಿರುವಾಗ ಅದನ್ನು ಇರಿಸಿ. ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ, ಚಲಾಯಿಸುವ ಲೂಪ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ. ಅಳತೆ ಮಾಡಿದ ಸಂಖ್ಯಾತ್ಮಕ ಹಾಟ್ ಪಾತ್ ಅನ್ನು ಬ್ಯಾಚಿಂಗ್ ಮಾಡಲು ನನ್ನ ತೀರ್ಪು SHIP IT ಆಗಿದೆ. ಸಾಮಾನ್ಯ ಲೂಪ್‌ಗಳು ಈಗಾಗಲೇ ಚೆನ್ನಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಿದಾಗ ಅವುಗಳನ್ನು ಇರಿಸಿ. ಕೆಲಸ ಎಲ್ಲಿ ನಡೆಯುತ್ತದೆ ಮತ್ತು ಮುಂದಿನ ಕರೆ ಮಾಡುವವರಿಗೆ ಏನು ಬೇಕು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ. ಚಂದಾದಾರರಾಗಿ, ಬೆಲ್ ಒತ್ತಿ, ಮತ್ತು ನೀವು ಅದನ್ನು ವಿಭಿನ್ನವಾಗಿ ಸ್ಟಾಂಪ್ ಮಾಡುತ್ತಿದ್ದೀರಾ ಎಂದು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ನನಗೆ ತಿಳಿಸಿ.

5:18 ಮತ್ತು ಇಂದಿನ ಡಿಫ್ ಅಷ್ಟೆ. ನಾನು Axrisi ಯಿಂದ ನಿಕೋ. ಜವಾಬ್ದಾರಿಯುತವಾಗಿ ವಿಲೀನಗೊಳಿಸಿ. This is The Daily Diff, under the hood. Keep an eye on that shortcut. CPython is the standard Python implementation. It compiles your source into bytecode, then runs those instructions in an interpreter. NumPy is a numerical library whose arrays hold values with a

ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ನೀವು ಏನು ಬದಲಾಯಿಸಬೇಕು?

5:41 declared data type. Its built in arithmetic can hand a whole batch to compiled operations. Take a million floating point values, square each one, then add the original value. Every version gets identical values and produces matching answers. The values are small enough to keep rounding differences out of the race. On this machine, the comprehension took about thirty three milliseconds.

ಮೂಲಗಳು

1. Universal functions (ufunc) basics — NumPy 2.2NumPy
2. The N-dimensional array — NumPy 2.2NumPy
3. numpy.vectorize — convenience and performance notesNumPy
4. CPU/SIMD optimizations — NumPy 2.2NumPy
5. dis — Disassembler for Python bytecodePython Software Foundation
6. CPython 3.10.12 list representationCPython contributors
7. The limits of Python vectorization as a performance techniqueItamar Turner-Trauring / Python⇒Speed
8. Performance TipsNumba
9. Basics of CuPyCuPy