ಇಮೇಜ್ ವೈಶಿಷ್ಟ್ಯದ ಹೊರತೆಗೆಯುವಿಕೆಗಾಗಿ UDF ಗಳ Apache Spark ನ ಬಳಕೆಯೊಂದಿಗೆ SparkContext ಸಮಸ್ಯೆಗಳನ್ನು ಸರಿಪಡಿಸುವುದು

ಅಪಾಚೆ ಸ್ಪಾರ್ಕ್‌ನ UDF ಗಳಲ್ಲಿ ಸ್ಪಾರ್ಕ್ ಸಂದರ್ಭದ ದೋಷಗಳ ಹಿಂದಿನ ರಹಸ್ಯವನ್ನು ಬಹಿರಂಗಪಡಿಸುವುದು

ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತಿದೆ ಅಪಾಚೆ ಸ್ಪಾರ್ಕ್ ಮತ್ತು PySpark ಸಾಮಾನ್ಯವಾಗಿ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿತರಿಸಿದ ಕಂಪ್ಯೂಟಿಂಗ್ ಅನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಆದರೆ ಕೆಲವೊಮ್ಮೆ, ವಿಷಯಗಳು ಯೋಜಿಸಿದಂತೆ ನಡೆಯುವುದಿಲ್ಲ. ಅನೇಕ ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಎದುರಿಸುವ ಒಂದು ಸಾಮಾನ್ಯ ಅಪಾಯ, ವಿಶೇಷವಾಗಿ ಕರೆ ಮಾಡುವಾಗ ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳು (UDFs), ಕುಖ್ಯಾತ "SparkContext ಅನ್ನು ಡ್ರೈವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬಳಸಬಹುದು" ದೋಷವಾಗಿದೆ.

ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನಂತಹ ಸಂಕೀರ್ಣ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ ಈ ದೋಷವು ವಿಶೇಷವಾಗಿ ನಿರಾಶಾದಾಯಕವಾಗಿರುತ್ತದೆ, ಅಲ್ಲಿ ಕಾರ್ಯಗಳು ಬಹು ಕಾರ್ಮಿಕರಲ್ಲಿ ವಿಭಜಿಸಲ್ಪಡುತ್ತವೆ. ಚಿತ್ರದ ವೈಶಿಷ್ಟ್ಯದ ಹೊರತೆಗೆಯುವಿಕೆಯಂತಹ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, SparkContext ಏಕೆ ಈ ರೀತಿ ವರ್ತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿರ್ಣಾಯಕವಾಗುತ್ತದೆ. 💻

ಈ ಲೇಖನದಲ್ಲಿ, PyTorch ನಲ್ಲಿ ResNet ಮಾದರಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಉದಾಹರಣೆಯ ಮೂಲಕ ನಾನು ನಿಮ್ಮನ್ನು ಕರೆದೊಯ್ಯುತ್ತೇನೆ. UDF ನಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಧಾರಾವಾಹಿ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುವಾಗ SparkContext ಏಕೆ ಸಮಸ್ಯೆಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ, ಇದು ರನ್‌ಟೈಮ್ ದೋಷಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಇದರ ಮೂಲಕ, ಸ್ಪಾರ್ಕ್‌ನೊಂದಿಗೆ ಸುಗಮ ಡೇಟಾ ಸಂಸ್ಕರಣೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ದೋಷದ ಸುತ್ತಲೂ ಕೆಲಸ ಮಾಡಲು ನಾನು ತಂತ್ರಗಳನ್ನು ಸಹ ಹಂಚಿಕೊಳ್ಳುತ್ತೇನೆ.

ಸ್ಪಾರ್ಕ್‌ನಲ್ಲಿ ML ಪೈಪ್‌ಲೈನ್ ನಿರ್ಮಿಸುವಾಗ ನೀವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದ್ದರೆ, ನೀವು ಒಬ್ಬಂಟಿಯಾಗಿಲ್ಲ! ಈ ದೋಷವನ್ನು ತಪ್ಪಿಸಲು ಮತ್ತು ವಿತರಿಸಿದ ಪರಿಸರದಲ್ಲಿ ಸ್ಪಾರ್ಕ್ UDF ಗಳ ಸುಗಮ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪ್ರಾಯೋಗಿಕ ಪರಿಹಾರಗಳನ್ನು ನಾವು ನೋಡುತ್ತಿರುವಾಗ ನನ್ನೊಂದಿಗೆ ಇರಿ. 🚀

ಡೀಪ್ ಲರ್ನಿಂಗ್ ಮಾಡೆಲ್‌ಗಳೊಂದಿಗೆ ಸ್ಪಾರ್ಕ್ UDF ಧಾರಾವಾಹಿಯ ದೋಷನಿವಾರಣೆ

ಜೊತೆ ಕೆಲಸ ಮಾಡುವಾಗ ಅಪಾಚೆ ಸ್ಪಾರ್ಕ್, ವಿತರಣೆ ಸಂಸ್ಕರಣೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ವೇಗಗೊಳಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ-ಪ್ರಮಾಣದ ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್‌ನಂತಹ ಕಾರ್ಯಗಳಲ್ಲಿ. ಆದಾಗ್ಯೂ, ಸ್ಪಾರ್ಕ್ ಕೆಲವು ನಿರ್ಬಂಧಗಳನ್ನು ವಿಧಿಸುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಅದರ ಮೇಲೆ ಸ್ಪಾರ್ಕ್ ಸಂದರ್ಭ. ಮೇಲಿನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ, DataFrame ನಲ್ಲಿನ ಪ್ರತಿ ಸಾಲಿನ ಚಿತ್ರಗಳಿಂದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊರತೆಗೆಯಲು UDF ನಲ್ಲಿ ResNet ಆಳವಾದ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ವಿಧಾನವು SparkContext ಮಿತಿಯನ್ನು ಹೊಡೆಯುತ್ತದೆ: SparkContext ಅನ್ನು ಡ್ರೈವರ್ ನೋಡ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬಳಸಬಹುದಾಗಿದೆ ಮತ್ತು ವರ್ಕರ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಕೋಡ್‌ನಲ್ಲಿ ಅಲ್ಲ, ಅದಕ್ಕಾಗಿಯೇ ಕೋಡ್ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ. ಆರಂಭಿಕ ಪರಿಹಾರವು ಸ್ಪಾರ್ಕ್ ಸೆಶನ್, ಇಮೇಜ್ ಪ್ರಿ-ಪ್ರೊಸೆಸಿಂಗ್ ಮತ್ತು ವೈಶಿಷ್ಟ್ಯದ ಹೊರತೆಗೆಯುವಿಕೆಯನ್ನು ನಿರ್ವಹಿಸಲು ಇಮೇಜ್‌ವೆಕ್ಟೋರೈಸರ್ ವರ್ಗವನ್ನು ರಚಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ಕಾರ್ಯಗಳನ್ನು ಒಂದು ವರ್ಗದಲ್ಲಿ ಕೇಂದ್ರೀಕರಿಸುವ ಮೂಲಕ, ನಾವು ಕೋಡ್ ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವಂತೆ ಇರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. 💻

ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ಇಮೇಜ್‌ವೆಕ್ಟೋರೈಸರ್ ವರ್ಗವು ಸ್ಪಾರ್ಕ್ ಸೆಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಜನಪ್ರಿಯ ಆಳವಾದ ಕಲಿಕೆಯ ಗ್ರಂಥಾಲಯವಾದ ಪೈಟೋರ್ಚ್‌ನಿಂದ ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ರೆಸ್‌ನೆಟ್ ಮಾದರಿಯನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಮರುಗಾತ್ರಗೊಳಿಸುವಿಕೆ ಮತ್ತು ಸಾಮಾನ್ಯಗೊಳಿಸುವಿಕೆ ಸೇರಿದಂತೆ ರೂಪಾಂತರಗಳ ಒಂದು ಸೆಟ್ ಅನ್ನು ಅನ್ವಯಿಸುವುದರೊಂದಿಗೆ, ಪ್ರತಿ ಚಿತ್ರವನ್ನು ಮಾದರಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಬಹುದು. Extract_features ವಿಧಾನವು ಪ್ರತಿ ಚಿತ್ರವನ್ನು ಹೇಗೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ: ಮೊದಲು, ಚಿತ್ರವನ್ನು ಓದಲಾಗುತ್ತದೆ, ಪೂರ್ವ-ಸಂಸ್ಕರಿಸಲಾಗುತ್ತದೆ, ನಂತರ ಉನ್ನತ ಮಟ್ಟದ ವೈಶಿಷ್ಟ್ಯದ ವೆಕ್ಟರ್‌ಗಳನ್ನು ಹೊರತೆಗೆಯಲು ResNet ಮಾದರಿಯ ಮೂಲಕ ರವಾನಿಸಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನವು SparkContext ಧಾರಾವಾಹಿ ಸಮಸ್ಯೆಯನ್ನು ಹೊಡೆಯುತ್ತದೆ ಏಕೆಂದರೆ UDF ನೇರವಾಗಿ ಕೆಲಸಗಾರ ಕಾರ್ಯಗಳಲ್ಲಿ ಸ್ಪಾರ್ಕ್ ಘಟಕಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. PySpark ವಿತರಿಸಿದ ನೋಡ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ResNet ಮಾದರಿಯನ್ನು ಧಾರಾವಾಹಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗದ ಕಾರಣ, ಇದು ರನ್‌ಟೈಮ್ ಸಮಸ್ಯೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.

ಇದನ್ನು ಪರಿಹರಿಸಲು, ಎರಡನೆಯ ವಿಧಾನವು ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ ಪ್ರಸಾರ ವೇರಿಯೇಬಲ್‌ಗಳು, ಇದು ಪ್ರತಿ ಕೆಲಸಗಾರನಿಗೆ ಒಮ್ಮೆ ಮಾತ್ರ ಡೇಟಾ ಅಥವಾ ವಸ್ತುಗಳನ್ನು ವಿತರಿಸುತ್ತದೆ. ResNet ಮಾದರಿಯನ್ನು ಪ್ರಸಾರ ಮಾಡುವುದರಿಂದ ಮಾದರಿಯನ್ನು ಪ್ರತಿ ವರ್ಕರ್ ನೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ UDF ಕರೆಯಲ್ಲಿ ಮರು-ಪ್ರಾರಂಭಿಸುವಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ. ನಂತರ ಚಿತ್ರದ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊರತೆಗೆಯುವ ಸಮಯದಲ್ಲಿ ಪ್ರಸಾರ ಮಾದರಿಯನ್ನು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ, ಇದು ಸೆಟಪ್ ಅನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮತ್ತು ಸ್ಕೇಲೆಬಲ್ ಮಾಡುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಂಪನ್ಮೂಲದ ಬಳಕೆಯನ್ನು ಗಣನೀಯವಾಗಿ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸ್ಪಾರ್ಕ್ ಕೆಲಸಗಾರರ ಮೇಲೆ ಅಲ್ಲ, ಚಾಲಕದಲ್ಲಿ ಅಗತ್ಯವಿರುವ ಘಟಕಗಳನ್ನು ಮಾತ್ರ ಪ್ರವೇಶಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ SparkContext ದೋಷವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವಾಗ ಬ್ರಾಡ್‌ಕಾಸ್ಟ್ ವೇರಿಯೇಬಲ್‌ಗಳು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿವೆ, ವಿತರಿಸಲಾದ ಇಮೇಜ್ ವೈಶಿಷ್ಟ್ಯದ ಹೊರತೆಗೆಯುವಿಕೆಗೆ ಎರಡನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಸೂಕ್ತವಾಗಿದೆ.

ಪ್ರಸಾರ ಮಾದರಿಯನ್ನು ಬಳಸಲು UDF ಕಾರ್ಯವನ್ನು ಸರಿಹೊಂದಿಸಿದ ನಂತರ, ಡೇಟಾಫ್ರೇಮ್‌ನ ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸುವ UDF ಅನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ವಿವಿಧ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು, ಮೂರನೇ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಾಗಿ ಒದಗಿಸಲಾಗಿದೆ ಪೈಟೆಸ್ಟ್. ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಬೈನರಿ ಇಮೇಜ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುವ ಕಾರ್ಯದ ಸಾಮರ್ಥ್ಯವನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ರೂಪಾಂತರ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಸರಿಯಾದ ಗಾತ್ರದ ವೈಶಿಷ್ಟ್ಯ ವೆಕ್ಟರ್ ಅನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತದೆ. ನಿಯೋಜನೆಯ ಮೊದಲು ಪ್ರತಿ ಘಟಕದ ಕಾರ್ಯವನ್ನು ಪರಿಶೀಲಿಸುವ ಮೂಲಕ ಪರೀಕ್ಷೆಯು ವಿಶ್ವಾಸಾರ್ಹತೆಯ ಮತ್ತೊಂದು ಪದರವನ್ನು ಸೇರಿಸುತ್ತದೆ. 📊 ಯುನಿಟ್ ಪರೀಕ್ಷೆಗಳು ವಿತರಿಸಿದ ಪರಿಸರದಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಮೌಲ್ಯಯುತವಾಗಿವೆ, ಏಕೆಂದರೆ ಕೋಡ್ ಮಾರ್ಪಾಡುಗಳು ನೋಡ್‌ಗಳಾದ್ಯಂತ ಅನಪೇಕ್ಷಿತ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಚಯಿಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತವೆ.

ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ, ಈ ವಿಧಾನಗಳು ಸ್ಪಾರ್ಕ್‌ನ ಸಂಕೀರ್ಣ ಇಮೇಜ್ ಡೇಟಾವನ್ನು ಸಮಾನಾಂತರವಾಗಿ ನಿರ್ವಹಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತವೆ, ಇದು ಯಂತ್ರ ಕಲಿಕೆ ಮತ್ತು AI ಯೋಜನೆಗಳಲ್ಲಿ ವಿಶಾಲವಾದ ಇಮೇಜ್ ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕಾರ್ಯಸಾಧ್ಯವಾಗುತ್ತದೆ. ಬ್ರಾಡ್‌ಕಾಸ್ಟ್ ಮಾಡೆಲ್‌ಗಳು, ಯುಡಿಎಫ್‌ಗಳು ಮತ್ತು ಟೆಸ್ಟಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಈ ವರ್ಕ್‌ಫ್ಲೋಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸುವಲ್ಲಿ ನಿರ್ಣಾಯಕ ಪಾತ್ರವನ್ನು ವಹಿಸುತ್ತವೆ. ಈ ಪರಿಹಾರಗಳು ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾ ಸಂಸ್ಕರಣೆಗೆ ನಮ್ಯತೆ, ಸ್ಕೇಲೆಬಿಲಿಟಿ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ತರುತ್ತವೆ - ವಿತರಿಸಿದ ಯಂತ್ರ ಕಲಿಕೆ ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ ಸ್ಥಿರವಾದ, ಉತ್ತಮ-ಗುಣಮಟ್ಟದ ಫಲಿತಾಂಶಗಳನ್ನು ಸಾಧಿಸಲು ಪ್ರಮುಖವಾಗಿದೆ.

# Import required libraries
from pyspark.sql import SparkSession, DataFrame
from pyspark.sql.functions import udf
from pyspark.sql.types import ArrayType, FloatType
from torchvision import models, transforms
from PIL import Image
import torch
import numpy as np
from io import BytesIO
# Define the class to initialize Spark session and ResNet model
class ImageVectorizer:
    def __init__(self):
        # Initialize SparkSession
        self.spark = SparkSession.builder.getOrCreate()
        # Load pre-trained ResNet model
        self.resnet_model = models.resnet50(pretrained=True)
        self.resnet_model.eval()
        # Define image transformation pipeline
        self.transform = transforms.Compose([
            transforms.Resize(256),
            transforms.CenterCrop(224),
            transforms.ToTensor(),
            transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                 std=[0.229, 0.224, 0.225])
        ])
    def extract_features(self, image_binary):
        # Convert image binary to tensor and extract features
        image = Image.open(BytesIO(image_binary))
        image = self.transform(image).unsqueeze(0)
        with torch.no_grad():
            features = self.resnet_model(image)
        return features.squeeze().numpy().tolist()
    def process_images(self, image_df):
        # Register a non-Spark UDF to call extract_features function
        extract_features_udf = udf(lambda x: self.extract_features(x), ArrayType(FloatType()))
        return image_df.withColumn("features", extract_features_udf(image_df["content"]))

# Import required libraries
from pyspark.sql import SparkSession
from pyspark.sql.functions import udf
from pyspark.sql.types import ArrayType, FloatType
from torchvision import models, transforms
from PIL import Image
import torch
import numpy as np
from io import BytesIO
# Initialize Spark session and broadcast model
spark = SparkSession.builder.getOrCreate()
resnet_model = models.resnet50(pretrained=True)
resnet_model.eval()
bc_resnet_model = spark.sparkContext.broadcast(resnet_model)
# Define transformation pipeline separately
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                     std=[0.229, 0.224, 0.225])
])
# Define feature extraction function using broadcast model
def extract_features(image_binary):
    image = Image.open(BytesIO(image_binary))
    image = transform(image).unsqueeze(0)
    with torch.no_grad():
        features = bc_resnet_model.value(image)
    return features.squeeze().numpy().tolist()
# Register UDF
extract_features_udf = udf(extract_features, ArrayType(FloatType()))

# Import pytest for unit testing
import pytest
import numpy as np
@pytest.fixture
def mock_image_binary():
    # Provide a sample image in binary format
    with open('test_image.jpg', 'rb') as f:
        return f.read()
def test_extract_features(mock_image_binary):
    # Initialize ImageVectorizer and call extract_features function
    vectorizer = ImageVectorizer()
    result = vectorizer.extract_features(mock_image_binary)
    assert isinstance(result, list)
    assert len(result) == 2048

ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗಾಗಿ ಸ್ಪಾರ್ಕ್ ಯುಡಿಎಫ್‌ಗಳೊಂದಿಗೆ ಸೀರಿಯಲೈಸೇಶನ್ ಸವಾಲುಗಳನ್ನು ನಿವಾರಿಸುವುದು

ಬಳಕೆಯಲ್ಲಿ ಗಮನಾರ್ಹ ಸವಾಲುಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ ಅಪಾಚೆ ಸ್ಪಾರ್ಕ್ ಮುಂತಾದ ಸುಧಾರಿತ ಕಾರ್ಯಗಳಿಗಾಗಿ ಚಿತ್ರ ಸಂಸ್ಕರಣೆ ಬಳಕೆದಾರ-ವ್ಯಾಖ್ಯಾನಿತ ಕಾರ್ಯಗಳೊಂದಿಗೆ (ಯುಡಿಎಫ್) ಕೆಲಸ ಮಾಡುವಾಗ ಸುಗಮ ಧಾರಾವಾಹಿಯನ್ನು ಖಾತ್ರಿಪಡಿಸುತ್ತದೆ. ಸ್ಪಾರ್ಕ್ ಅಂತರ್ಗತವಾಗಿ ವಿತರಿಸಲ್ಪಟ್ಟಿರುವುದರಿಂದ, ಸ್ಪಾರ್ಕ್ ಯುಡಿಎಫ್‌ಗಳಲ್ಲಿನ ಕಾರ್ಯಗಳನ್ನು ಸಂಸ್ಕರಣೆಗಾಗಿ ವರ್ಕರ್ ನೋಡ್‌ಗಳಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಇದು ಸಂಕೀರ್ಣ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳಂತಹ ಸರಣಿ ಮಾಡಲಾಗದ ವಸ್ತುಗಳು ಒಳಗೊಂಡಿದ್ದರೆ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, PyTorch ನಿಂದ ResNet ಮಾದರಿಯು ಸ್ಥಳೀಯವಾಗಿ ಧಾರಾವಾಹಿಯಾಗಿಲ್ಲ, ಅಂದರೆ "SparkContext ಅನ್ನು ಡ್ರೈವರ್‌ನಲ್ಲಿ ಮಾತ್ರ ಬಳಸಬಹುದು" ದೋಷವನ್ನು ತಪ್ಪಿಸಲು ಸ್ಪಾರ್ಕ್‌ನಲ್ಲಿ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿರ್ವಹಿಸುವ ಅಗತ್ಯವಿದೆ.

SparkContext ಸೇರಿದಂತೆ UDF ನಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ನೇರವಾಗಿ ವರ್ಕರ್ ನೋಡ್‌ಗಳಿಗೆ ವಿತರಿಸಲು ಸ್ಪಾರ್ಕ್ ಪ್ರಯತ್ನಿಸುವುದರಿಂದ ಸೀರಿಯಲೈಸೇಶನ್ ಒಂದು ಅಡಚಣೆಯಾಗುತ್ತದೆ. ಈ ಮಿತಿಯನ್ನು ನಾವು ಪ್ರತಿ ಬಾರಿ ಮರು-ಪ್ರಾರಂಭಿಸದೆಯೇ ನೋಡ್‌ಗಳಾದ್ಯಂತ ResNet ಮಾದರಿಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹಂಚಿಕೊಳ್ಳಲು ಬ್ರಾಡ್‌ಕಾಸ್ಟ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ದಿ broadcast() ವಿಧಾನವು ಪ್ರತಿ ಕೆಲಸಗಾರನಿಗೆ ಓದಲು-ಮಾತ್ರ ಡೇಟಾವನ್ನು ವಿತರಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ಅಲ್ಲಿ ಸ್ಪಾರ್ಕ್‌ನ ಧಾರಾವಾಹಿ ನಿರ್ಬಂಧಗಳನ್ನು ಪ್ರಚೋದಿಸದೆಯೇ ಅದನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಉಲ್ಲೇಖಿಸಬಹುದು. ಮಾದರಿಯನ್ನು ಪ್ರಸಾರ ಮಾಡುವ ಮೂಲಕ, ಡೇಟಾವನ್ನು ನಕಲು ಮಾಡದೆಯೇ ಎಲ್ಲಾ ನೋಡ್‌ಗಳಲ್ಲಿ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಹೊರತೆಗೆಯಲು ResNet ತೂಕವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು, ಮೆಮೊರಿ ಬಳಕೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಎರಡನ್ನೂ ಹೆಚ್ಚಿಸುತ್ತದೆ. 🌍

ಇಮೇಜ್ ಪ್ರೊಸೆಸಿಂಗ್‌ಗೆ ಮೀರಿ ವಿತರಿಸಲಾದ ML ಪೈಪ್‌ಲೈನ್‌ಗಳಿಗೆ ಈ ತಂತ್ರವು ವ್ಯಾಪಕವಾಗಿ ಅನ್ವಯಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಶಿಫಾರಸು ವ್ಯವಸ್ಥೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿದ್ದರೆ, ಸ್ಪಾರ್ಕ್ ಧಾರಾವಾಹಿ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ನೀವು ಬಳಕೆದಾರರ ಆದ್ಯತೆಗಳ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಅಥವಾ ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಗಳನ್ನು ಪ್ರಸಾರ ಮಾಡಬಹುದು. ಅಂತೆಯೇ, ಇತರ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆ ಕಾರ್ಯಗಳಿಗಾಗಿ (ಪಠ್ಯ ವೆಕ್ಟರೈಸೇಶನ್ ಅಥವಾ ಆಡಿಯೊ ಸಂಸ್ಕರಣೆಯಂತಹ) UDF ಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಧಾರಾವಾಹಿ ಮಾಡಲಾಗದ ವಸ್ತುಗಳನ್ನು ಪ್ರಸಾರ ಮಾಡುವುದರಿಂದ ಪ್ರಯೋಜನವಾಗುತ್ತದೆ, ಡೇಟಾ ನಕಲು ಓವರ್‌ಹೆಡ್‌ಗಳಿಲ್ಲದೆ ಸ್ಪಾರ್ಕ್ ಹೆಚ್ಚು ಸಮಾನಾಂತರ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಅಭ್ಯಾಸಗಳು ಅತ್ಯಾಧುನಿಕ ML ವರ್ಕ್‌ಫ್ಲೋಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಸಾಕಷ್ಟು ದೃಢವಾಗಿಸುತ್ತದೆ, ರಚನಾತ್ಮಕ ಮತ್ತು ರಚನೆಯಿಲ್ಲದ ಡೇಟಾ ಕಾರ್ಯಗಳಲ್ಲಿ ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳಿಗೆ ಅಗತ್ಯವಿರುವ ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ. 🚀