ಎಲ್ಲರಿಗು ನಮಸ್ಖರ! ನಾನು CROC ನಲ್ಲಿ CV ಡೆವಲಪರ್ ಆಗಿದ್ದೇನೆ. ನಾವು ಈಗ 3 ವರ್ಷಗಳಿಂದ ಸಿವಿ ಕ್ಷೇತ್ರದಲ್ಲಿ ಯೋಜನೆಗಳನ್ನು ಅನುಷ್ಠಾನಗೊಳಿಸುತ್ತಿದ್ದೇವೆ. ಈ ಸಮಯದಲ್ಲಿ, ನಾವು ಬಹಳಷ್ಟು ಕೆಲಸಗಳನ್ನು ಮಾಡಿದ್ದೇವೆ, ಉದಾಹರಣೆಗೆ: ನಾವು ಚಾಲಕರನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿದ್ದೇವೆ ಆದ್ದರಿಂದ ಅವರು ಚಾಲನೆ ಮಾಡುವಾಗ ಅವರು ಕುಡಿಯುವುದಿಲ್ಲ, ಧೂಮಪಾನ ಮಾಡಲಿಲ್ಲ, ಫೋನ್‌ನಲ್ಲಿ ಮಾತನಾಡುವುದಿಲ್ಲ, ರಸ್ತೆಯತ್ತ ನೋಡಿದರು ಮತ್ತು ಕನಸುಗಳು ಅಥವಾ ಮೋಡಗಳಲ್ಲಿ ಅಲ್ಲ. ; ಮೀಸಲಾದ ಲೇನ್‌ಗಳಲ್ಲಿ ಚಾಲನೆ ಮಾಡುವ ಮತ್ತು ಹಲವಾರು ಪಾರ್ಕಿಂಗ್ ಸ್ಥಳಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಜನರನ್ನು ನಾವು ರೆಕಾರ್ಡ್ ಮಾಡಿದ್ದೇವೆ; ಕಾರ್ಮಿಕರು ಹೆಲ್ಮೆಟ್‌ಗಳು, ಕೈಗವಸುಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ಧರಿಸಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಂಡರು. ಸೌಲಭ್ಯವನ್ನು ಪ್ರವೇಶಿಸಲು ಬಯಸುವ ಉದ್ಯೋಗಿಯನ್ನು ಗುರುತಿಸಲಾಗಿದೆ; ನಾವು ಎಲ್ಲವನ್ನೂ ಎಣಿಸಿದ್ದೇವೆ.
ನಾನು ಇದನ್ನೆಲ್ಲ ಯಾವುದಕ್ಕಾಗಿ ಮಾಡುತ್ತಿದ್ದೇನೆ?
ಯೋಜನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನಾವು ಉಬ್ಬುಗಳನ್ನು ಹೊಡೆದಿದ್ದೇವೆ, ಬಹಳಷ್ಟು ಉಬ್ಬುಗಳು, ನಿಮಗೆ ತಿಳಿದಿರುವ ಅಥವಾ ಭವಿಷ್ಯದಲ್ಲಿ ಪರಿಚಯವಾಗುವ ಕೆಲವು ಸಮಸ್ಯೆಗಳು.
ಪರಿಸ್ಥಿತಿಯನ್ನು ಅನುಕರಿಸೋಣ
ನಾವು ಯುವ ಕಂಪನಿ "N" ನಲ್ಲಿ ಕೆಲಸ ಪಡೆದಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ, ಅವರ ಚಟುವಟಿಕೆಗಳು ML ಗೆ ಸಂಬಂಧಿಸಿವೆ. ನಾವು ML (DL, CV) ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ, ನಂತರ ಕೆಲವು ಕಾರಣಗಳಿಗಾಗಿ ನಾವು ಇನ್ನೊಂದು ಕೆಲಸಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತೇವೆ, ಸಾಮಾನ್ಯವಾಗಿ ವಿರಾಮ ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ನಮ್ಮ ಸ್ವಂತ ಅಥವಾ ಬೇರೆಯವರ ನರಕೋಶಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತೇವೆ.
- ಸತ್ಯದ ಕ್ಷಣ ಬರುತ್ತದೆ, ನೀವು ಎಲ್ಲಿ ನಿಲ್ಲಿಸಿದ್ದೀರಿ, ನೀವು ಯಾವ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಪ್ರಯತ್ನಿಸಿದ್ದೀರಿ ಮತ್ತು ಮುಖ್ಯವಾಗಿ, ಅವು ಯಾವ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಿವೆ ಎಂಬುದನ್ನು ನೀವು ಹೇಗಾದರೂ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬೇಕು. ಎಲ್ಲಾ ಲಾಂಚ್‌ಗಳಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಯಾರು ಸಂಗ್ರಹಿಸಿದ್ದಾರೆ ಎಂಬುದಕ್ಕೆ ಹಲವು ಆಯ್ಕೆಗಳಿವೆ: ತಲೆ, ಸಂರಚನೆಗಳು, ನೋಟ್‌ಪ್ಯಾಡ್, ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಕೆಲಸದ ವಾತಾವರಣದಲ್ಲಿ. ಕೋಡ್‌ನಲ್ಲಿ ಕಾಮೆಂಟ್ ಮಾಡಿದ ಸಾಲುಗಳಂತೆ ಹೈಪರ್‌ಪ್ಯಾರಾಮೀಟರ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದಾಗ ನಾನು ಒಂದು ಆಯ್ಕೆಯನ್ನು ನೋಡಿದೆ, ಸಾಮಾನ್ಯವಾಗಿ, ಅಲಂಕಾರಿಕ ಹಾರಾಟ. ಈಗ ನೀವು ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಅಲ್ಲ, ಆದರೆ ಕಂಪನಿಯನ್ನು ತೊರೆದ ವ್ಯಕ್ತಿಯ ಯೋಜನೆಗೆ ಹಿಂತಿರುಗಿದ್ದೀರಿ ಎಂದು ಊಹಿಸಿ ಮತ್ತು ನೀವು model_1.pb ಎಂಬ ಕೋಡ್ ಮತ್ತು ಮಾದರಿಯನ್ನು ಆನುವಂಶಿಕವಾಗಿ ಪಡೆದಿದ್ದೀರಿ. ಚಿತ್ರವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು ಮತ್ತು ಎಲ್ಲಾ ನೋವನ್ನು ತಿಳಿಸಲು, ನೀವು ಸಹ ಹರಿಕಾರ ತಜ್ಞ ಎಂದು ಊಹಿಸೋಣ.
- ಮುಂದುವರೆಯಿರಿ. ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಲು, ನಾವು ಮತ್ತು ಅದರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರತಿಯೊಬ್ಬರೂ ಪರಿಸರವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ. ಕೆಲವು ಕಾರಣಗಳಿಂದ ಅವರು ಅವನನ್ನು ನಮ್ಮ ಆನುವಂಶಿಕವಾಗಿ ಬಿಡಲಿಲ್ಲ ಎಂದು ಆಗಾಗ್ಗೆ ಸಂಭವಿಸುತ್ತದೆ. ಇದು ಕ್ಷುಲ್ಲಕ ಕೆಲಸವೂ ಆಗಬಹುದು. ಈ ಹಂತದಲ್ಲಿ ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡಲು ನೀವು ಬಯಸುವುದಿಲ್ಲ, ಅಲ್ಲವೇ?
- ನಾವು ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ (ಉದಾಹರಣೆಗೆ, ಕಾರ್ ಡಿಟೆಕ್ಟರ್). ಅದು ತುಂಬಾ ಒಳ್ಳೆಯದು ಆಗುವ ಹಂತಕ್ಕೆ ನಾವು ಹೋಗುತ್ತೇವೆ - ಫಲಿತಾಂಶವನ್ನು ಉಳಿಸುವ ಸಮಯ. ಇದನ್ನು car_detection_v1.pb ಎಂದು ಕರೆಯೋಣ. ನಂತರ ನಾವು ಇನ್ನೊಂದನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ - car_detection_v2.pb. ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ, ನಮ್ಮ ಸಹೋದ್ಯೋಗಿಗಳು ಅಥವಾ ನಾವೇ ವಿಭಿನ್ನ ವಾಸ್ತುಶಿಲ್ಪಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಚ್ಚು ಹೆಚ್ಚು ಕಲಿಸುತ್ತೇವೆ. ಪರಿಣಾಮವಾಗಿ, ಕಲಾಕೃತಿಗಳ ಗುಂಪನ್ನು ರಚಿಸಲಾಗಿದೆ, ಅದರ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಶ್ರಮದಾಯಕವಾಗಿ ಸಂಗ್ರಹಿಸಬೇಕು (ಆದರೆ ನಾವು ಇದನ್ನು ನಂತರ ಮಾಡುತ್ತೇವೆ, ಏಕೆಂದರೆ ಸದ್ಯಕ್ಕೆ ನಮಗೆ ಹೆಚ್ಚಿನ ಆದ್ಯತೆಯ ವಿಷಯಗಳಿವೆ).
- ಸರಿ ಈಗ ಎಲ್ಲಾ ಮುಗಿದಿದೆ! ನಮಗೆ ಒಂದು ಮಾದರಿ ಇದೆ! ನಾವು ಮುಂದಿನ ಮಾದರಿಯ ತರಬೇತಿಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದೇ, ಹೊಸ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಬಹುದೇ ಅಥವಾ ನಾವು ಸ್ವಲ್ಪ ಚಹಾವನ್ನು ಕುಡಿಯಬಹುದೇ? ಮತ್ತು ಯಾರು ನಿಯೋಜಿಸುತ್ತಾರೆ?
ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುವುದು
ಪ್ರಾಜೆಕ್ಟ್ ಅಥವಾ ಉತ್ಪನ್ನದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದು ಅನೇಕ ಜನರ ಕೆಲಸವಾಗಿದೆ. ಮತ್ತು ಕಾಲಾನಂತರದಲ್ಲಿ, ಜನರು ಬಿಟ್ಟು ಬರುತ್ತಾರೆ, ಹೆಚ್ಚಿನ ಯೋಜನೆಗಳಿವೆ, ಮತ್ತು ಯೋಜನೆಗಳು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾಗುತ್ತವೆ. ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ, ಮೇಲೆ ವಿವರಿಸಿದ ಚಕ್ರದ ಸಂದರ್ಭಗಳು (ಮತ್ತು ಮಾತ್ರವಲ್ಲ) ಕೆಲವು ಸಂಯೋಜನೆಗಳಲ್ಲಿ ಪುನರಾವರ್ತನೆಯಿಂದ ಪುನರಾವರ್ತನೆಯವರೆಗೆ ಸಂಭವಿಸುತ್ತವೆ. ಇದೆಲ್ಲವೂ ವ್ಯರ್ಥ ಸಮಯ, ಗೊಂದಲ, ನರಗಳು, ಪ್ರಾಯಶಃ ಗ್ರಾಹಕರ ಅತೃಪ್ತಿ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಹಣವನ್ನು ಕಳೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವೆಲ್ಲರೂ ಸಾಮಾನ್ಯವಾಗಿ ಅದೇ ಹಳೆಯ ಕುಂಟೆಯನ್ನು ಅನುಸರಿಸುತ್ತಿದ್ದರೂ, ಯಾರೂ ಈ ಕ್ಷಣಗಳನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಮೆಲುಕು ಹಾಕಲು ಬಯಸುವುದಿಲ್ಲ ಎಂದು ನಾನು ನಂಬುತ್ತೇನೆ.
ಆದ್ದರಿಂದ, ನಾವು ಒಂದು ಅಭಿವೃದ್ಧಿ ಚಕ್ರದ ಮೂಲಕ ಹೋಗಿದ್ದೇವೆ ಮತ್ತು ಪರಿಹರಿಸಬೇಕಾದ ಸಮಸ್ಯೆಗಳಿವೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಇದನ್ನು ಮಾಡಲು ನಿಮಗೆ ಅಗತ್ಯವಿದೆ:
- ಕೆಲಸದ ಫಲಿತಾಂಶಗಳನ್ನು ಅನುಕೂಲಕರವಾಗಿ ಸಂಗ್ರಹಿಸಿ;
- ಹೊಸ ಉದ್ಯೋಗಿಗಳನ್ನು ಒಳಗೊಳ್ಳುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸಿ;
- ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ನಿಯೋಜಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸರಳಗೊಳಿಸಿ;
- ಮಾದರಿ ಆವೃತ್ತಿಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ;
- ಮಾದರಿಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಅನುಕೂಲಕರ ಮಾರ್ಗವನ್ನು ಹೊಂದಿರಿ;
- ಮಾದರಿ ರಾಜ್ಯ ನಿರ್ವಹಣಾ ಸಾಧನವನ್ನು ಹುಡುಕಿ;
- ಉತ್ಪಾದನೆಗೆ ಮಾದರಿಗಳನ್ನು ತಲುಪಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಕಂಡುಕೊಳ್ಳಿ.
ಈ ಜೀವನ ಚಕ್ರವನ್ನು ಸುಲಭವಾಗಿ ಮತ್ತು ಅನುಕೂಲಕರವಾಗಿ ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಕೆಲಸದ ಹರಿವಿನೊಂದಿಗೆ ಬರಲು ಇದು ಅಗತ್ಯವಾಗಿದೆಯೇ? ಈ ಅಭ್ಯಾಸವನ್ನು MLOps ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ
MLOps, ಅಥವಾ ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ DevOps, ದತ್ತಾಂಶ ವಿಜ್ಞಾನ ಮತ್ತು IT ತಂಡಗಳು ಸಹಕರಿಸಲು ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆ ಮಾದರಿಗಳಿಗೆ ಮೇಲ್ವಿಚಾರಣೆ, ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ಆಡಳಿತದ ಮೂಲಕ ಮಾದರಿ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ನಿಯೋಜನೆಯ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.
ನೀವು ಮಾಡಬಹುದು ಈ ಎಲ್ಲದರ ಬಗ್ಗೆ ಗೂಗಲ್ ವ್ಯಕ್ತಿಗಳು ಏನು ಯೋಚಿಸುತ್ತಾರೆ? ಲೇಖನದಿಂದ MLOps ಸಾಕಷ್ಟು ದೊಡ್ಡ ವಿಷಯ ಎಂದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.
ನನ್ನ ಲೇಖನದಲ್ಲಿ ನಾನು ಪ್ರಕ್ರಿಯೆಯ ಭಾಗವನ್ನು ಮಾತ್ರ ವಿವರಿಸುತ್ತೇನೆ. ಅನುಷ್ಠಾನಕ್ಕಾಗಿ, ನಾನು MLflow ಉಪಕರಣವನ್ನು ಬಳಸುತ್ತೇನೆ, ಏಕೆಂದರೆ... ಇದು ಮುಕ್ತ-ಮೂಲ ಯೋಜನೆಯಾಗಿದೆ, ಸಂಪರ್ಕಿಸಲು ಸಣ್ಣ ಪ್ರಮಾಣದ ಕೋಡ್ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಜನಪ್ರಿಯ ml ಚೌಕಟ್ಟುಗಳೊಂದಿಗೆ ಏಕೀಕರಣವಿದೆ. Kubeflow, SageMaker, Trains, ಇತ್ಯಾದಿಗಳಂತಹ ಇತರ ಪರಿಕರಗಳಿಗಾಗಿ ನೀವು ಇಂಟರ್ನೆಟ್ ಅನ್ನು ಹುಡುಕಬಹುದು ಮತ್ತು ಬಹುಶಃ ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸೂಕ್ತವಾದ ಒಂದನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.
MLFlow ಉಪಕರಣವನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು "ಬಿಲ್ಡಿಂಗ್" MLOps
MLFlow ಎಂಬುದು ಮಿಲಿ ಮಾದರಿಗಳ ಜೀವನಚಕ್ರ ನಿರ್ವಹಣೆಗೆ ಮುಕ್ತ ಮೂಲ ವೇದಿಕೆಯಾಗಿದೆ ().
MLflow ನಾಲ್ಕು ಘಟಕಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:
- MLflow ಟ್ರ್ಯಾಕಿಂಗ್ - ಈ ಫಲಿತಾಂಶಕ್ಕೆ ಕಾರಣವಾದ ರೆಕಾರ್ಡಿಂಗ್ ಫಲಿತಾಂಶಗಳು ಮತ್ತು ನಿಯತಾಂಕಗಳ ಸಮಸ್ಯೆಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತದೆ;
- MLflow ಪ್ರಾಜೆಕ್ಟ್ - ಪ್ಯಾಕೇಜ್ ಕೋಡ್ ಮತ್ತು ಯಾವುದೇ ವೇದಿಕೆಯಲ್ಲಿ ಅದನ್ನು ಪುನರುತ್ಪಾದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ;
- MLflow ಮಾದರಿಗಳು - ಉತ್ಪಾದನೆಗೆ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸುವ ಜವಾಬ್ದಾರಿ;
- MLflow ರಿಜಿಸ್ಟ್ರಿ - ಕೇಂದ್ರೀಕೃತ ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಮಾದರಿಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಅವುಗಳ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
MLflow ಎರಡು ಘಟಕಗಳ ಮೇಲೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:
- ಉಡಾವಣೆಯು ನಾವು ನೋಂದಾಯಿಸಲು ಬಯಸುವ ತರಬೇತಿ, ನಿಯತಾಂಕಗಳು ಮತ್ತು ಮೆಟ್ರಿಕ್‌ಗಳ ಪೂರ್ಣ ಚಕ್ರವಾಗಿದೆ;
- ಪ್ರಯೋಗವು ಒಟ್ಟಿಗೆ ನಡೆಯುವ "ವಿಷಯ" ಆಗಿದೆ.
ಉದಾಹರಣೆಯ ಎಲ್ಲಾ ಹಂತಗಳನ್ನು ಉಬುಂಟು 18.04 ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿದೆ.
1. ಸರ್ವರ್ ಅನ್ನು ನಿಯೋಜಿಸಿ
ನಮ್ಮ ಯೋಜನೆಯನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಮಾಹಿತಿಯನ್ನು ಸ್ವೀಕರಿಸಲು, ನಾವು ಸರ್ವರ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ. MLflow ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಎರಡು ಮುಖ್ಯ ಅಂಶಗಳನ್ನು ಹೊಂದಿದೆ:
- ಬ್ಯಾಕೆಂಡ್ ಸ್ಟೋರ್ - ನೋಂದಾಯಿತ ಮಾದರಿಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುವ ಜವಾಬ್ದಾರಿ (4 DBMS ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ: mysql, mssql, sqlite, ಮತ್ತು postgresql);
- ಕಲಾಕೃತಿಗಳ ಅಂಗಡಿ - ಕಲಾಕೃತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಜವಾಬ್ದಾರಿ (7 ಶೇಖರಣಾ ಆಯ್ಕೆಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ: Amazon S3, ಅಜುರೆ ಬ್ಲಾಬ್ ಸಂಗ್ರಹಣೆ, Google ಕ್ಲೌಡ್ ಸಂಗ್ರಹಣೆ, FTP ಸರ್ವರ್, SFTP ಸರ್ವರ್, NFS, HDFS).
ಎಂದು ಕಲಾಕೃತಿ ಅಂಗಡಿ ಸರಳತೆಗಾಗಿ, ನಾವು sftp ಸರ್ವರ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.
- ಒಂದು ಗುಂಪನ್ನು ರಚಿಸಿ
$ sudo groupadd sftpg - ಬಳಕೆದಾರರನ್ನು ಸೇರಿಸಿ ಮತ್ತು ಅವರಿಗೆ ಪಾಸ್‌ವರ್ಡ್ ಹೊಂದಿಸಿ
$ sudo useradd -g sftpg mlflowsftp $ sudo passwd mlflowsftp - ಒಂದೆರಡು ಪ್ರವೇಶ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ
$ sudo mkdir -p /data/mlflowsftp/upload $ sudo chown -R root.sftpg /data/mlflowsftp $ sudo chown -R mlflowsftp.sftpg /data/mlflowsftp/upload - /etc/ssh/sshd_config ಗೆ ಕೆಲವು ಸಾಲುಗಳನ್ನು ಸೇರಿಸಿ
Match Group sftpg ChrootDirectory /data/%u ForceCommand internal-sftp - ಸೇವೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ
$ sudo systemctl restart sshd
ಎಂದು ಬ್ಯಾಕೆಂಡ್ ಅಂಗಡಿ postgresql ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.
$ sudo apt update
$ sudo apt-get install -y postgresql postgresql-contrib postgresql-server-dev-all
$ sudo apt install gcc
$ pip install psycopg2
$ sudo -u postgres -i
# Create new user: mlflow_user
[postgres@user_name~]$ createuser --interactive -P
Enter name of role to add: mlflow_user
Enter password for new role: mlflow
Enter it again: mlflow
Shall the new role be a superuser? (y/n) n
Shall the new role be allowed to create databases? (y/n) n
Shall the new role be allowed to create more new roles? (y/n) n
# Create database mlflow_bd owned by mlflow_user
$ createdb -O mlflow_user mlflow_dbಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಈ ಕೆಳಗಿನ ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ (ಪ್ರತ್ಯೇಕ ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ):
pip install mlflow
pip install pysftpನಮ್ಮ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ
$ mlflow server
--backend-store-uri postgresql://mlflow_user:mlflow@localhost/mlflow_db
--default-artifact-root sftp://mlflowsftp:mlflow@sftp_host/upload
--host server_host
--port server_port2. ಟ್ರ್ಯಾಕಿಂಗ್ ಸೇರಿಸಿ
ನಮ್ಮ ತರಬೇತಿಯ ಫಲಿತಾಂಶಗಳು ಕಳೆದುಹೋಗದಿರಲು, ಭವಿಷ್ಯದ ಪೀಳಿಗೆಯ ಡೆವಲಪರ್‌ಗಳು ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ಹಳೆಯ ಒಡನಾಡಿಗಳಿಗೆ ಮತ್ತು ನೀವು ಕಲಿಕೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಶಾಂತವಾಗಿ ವಿಶ್ಲೇಷಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ, ನಾವು ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ. ಟ್ರ್ಯಾಕಿಂಗ್ ಎಂದರೆ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು, ಮೆಟ್ರಿಕ್‌ಗಳು, ಕಲಾಕೃತಿಗಳು ಮತ್ತು ತರಬೇತಿಯ ಪ್ರಾರಂಭದ ಕುರಿತು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಉಳಿಸುವುದು, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಸರ್ವರ್‌ನಲ್ಲಿ.
ಉದಾಹರಣೆಗೆ, ನಾನು ಚಿಕ್ಕದನ್ನು ರಚಿಸಿದೆ ಕೆರಾಸ್‌ನಲ್ಲಿರುವ ಎಲ್ಲವನ್ನೂ ವಿಭಾಗಿಸಲು . ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಸೇರಿಸಲು, ನಾನು mlflow_training.py ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದ್ದೇನೆ.
ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಸಂಗತಿಗಳು ಸಂಭವಿಸುವ ಸಾಲುಗಳು ಇಲ್ಲಿವೆ:
def run(self, epochs, lr, experiment_name):
# getting the id of the experiment, creating an experiment in its absence
remote_experiment_id = self.remote_server.get_experiment_id(name=experiment_name)
# creating a "run" and getting its id
remote_run_id = self.remote_server.get_run_id(remote_experiment_id)
# indicate that we want to save the results on a remote server
mlflow.set_tracking_uri(self.tracking_uri)
mlflow.set_experiment(experiment_name)
with mlflow.start_run(run_id=remote_run_id, nested=False):
mlflow.keras.autolog()
self.train_pipeline.train(lr=lr, epochs=epochs)
try:
self.log_tags_and_params(remote_run_id)
except mlflow.exceptions.RestException as e:
print(e)ಇಲ್ಲಿ self.remote_server ಎನ್ನುವುದು mlflow.tracking ವಿಧಾನಗಳ ಮೇಲೆ ಒಂದು ಸಣ್ಣ ಹೊದಿಕೆಯಾಗಿದೆ. MlflowClient (ನಾನು ಅದನ್ನು ಅನುಕೂಲಕ್ಕಾಗಿ ಮಾಡಿದ್ದೇನೆ), ಅದರ ಸಹಾಯದಿಂದ ನಾನು ಪ್ರಯೋಗವನ್ನು ರಚಿಸುತ್ತೇನೆ ಮತ್ತು ಅದನ್ನು ಸರ್ವರ್‌ನಲ್ಲಿ ಚಲಾಯಿಸುತ್ತೇನೆ. ಮುಂದೆ, ಉಡಾವಣಾ ಫಲಿತಾಂಶಗಳನ್ನು ಎಲ್ಲಿ ವಿಲೀನಗೊಳಿಸಬೇಕು ಎಂದು ನಾನು ಸೂಚಿಸುತ್ತೇನೆ (mlflow.set_tracking_uri(self.tracking_uri)). ನಾನು ಸ್ವಯಂಚಾಲಿತ ಲಾಗಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತೇನೆ mlflow.keras.autolog(). ಪ್ರಸ್ತುತ MLflow ಟ್ರ್ಯಾಕಿಂಗ್ TensorFlow, Keras, Gluon XGBoost, LightGBM, Spark ಗಾಗಿ ಸ್ವಯಂಚಾಲಿತ ಲಾಗಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ನಿಮ್ಮ ಫ್ರೇಮ್‌ವರ್ಕ್ ಅಥವಾ ಲೈಬ್ರರಿಯನ್ನು ನೀವು ಕಂಡುಹಿಡಿಯದಿದ್ದರೆ, ನೀವು ಯಾವಾಗಲೂ ಸ್ಪಷ್ಟವಾಗಿ ಲಾಗ್ ಮಾಡಬಹುದು. ನಾವು ತರಬೇತಿಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ. ರಿಮೋಟ್ ಸರ್ವರ್‌ನಲ್ಲಿ ಟ್ಯಾಗ್‌ಗಳು ಮತ್ತು ಇನ್‌ಪುಟ್ ನಿಯತಾಂಕಗಳನ್ನು ನೋಂದಾಯಿಸಿ.
ಒಂದೆರಡು ಸಾಲುಗಳು ಮತ್ತು ನೀವು, ಎಲ್ಲರಂತೆ, ಎಲ್ಲಾ ಉಡಾವಣೆಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಗೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುವಿರಿ. ಕೂಲ್?
3. ನಾವು ಯೋಜನೆಯನ್ನು ರೂಪಿಸುತ್ತೇವೆ
ಈಗ ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸುಲಭಗೊಳಿಸೋಣ. ಇದನ್ನು ಮಾಡಲು, MLproject ಮತ್ತು conda.yaml ಫೈಲ್ ಅನ್ನು ಪ್ರಾಜೆಕ್ಟ್ ರೂಟ್‌ಗೆ ಸೇರಿಸಿ.
ಎಂಎಲ್ ಪ್ರಾಜೆಕ್ಟ್
name: flow_segmentation
conda_env: conda.yaml
entry_points:
main:
parameters:
categories: {help: 'list of categories from coco dataset'}
epochs: {type: int, help: 'number of epochs in training'}
lr: {type: float, default: 0.001, help: 'learning rate'}
batch_size: {type: int, default: 8}
model_name: {type: str, default: 'Unet', help: 'Unet, PSPNet, Linknet, FPN'}
backbone_name: {type: str, default: 'resnet18', help: 'exampe resnet18, resnet50, mobilenetv2 ...'}
tracking_uri: {type: str, help: 'the server address'}
experiment_name: {type: str, default: 'My_experiment', help: 'remote and local experiment name'}
command: "python mlflow_training.py
--epochs={epochs}
--categories={categories}
--lr={lr}
--tracking_uri={tracking_uri}
--model_name={model_name}
--backbone_name={backbone_name}
--batch_size={batch_size}
--experiment_name={experiment_name}"MLflow ಯೋಜನೆಯು ಹಲವಾರು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ:
- ಹೆಸರು - ನಿಮ್ಮ ಯೋಜನೆಯ ಹೆಸರು;
- ಪರಿಸರ - ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ಅನಕೊಂಡವನ್ನು ರನ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅವಲಂಬನೆ ವಿವರಣೆಯು conda.yaml ಫೈಲ್‌ನಲ್ಲಿದೆ ಎಂದು conda_env ಸೂಚಿಸುತ್ತದೆ;
- ಎಂಟ್ರಿ ಪಾಯಿಂಟ್‌ಗಳು - ಯಾವ ಫೈಲ್‌ಗಳು ಮತ್ತು ಯಾವ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ನಾವು ರನ್ ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ (ತರಬೇತಿ ಪ್ರಾರಂಭಿಸುವಾಗ ಎಲ್ಲಾ ನಿಯತಾಂಕಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಲಾಗ್ ಮಾಡಲಾಗುತ್ತದೆ)
conda.yaml
name: flow_segmentation
channels:
- defaults
- anaconda
dependencies:
- python==3.7
- pip:
- mlflow==1.8.0
- pysftp==0.2.9
- Cython==0.29.19
- numpy==1.18.4
- pycocotools==2.0.0
- requests==2.23.0
- matplotlib==3.2.1
- segmentation-models==1.0.1
- Keras==2.3.1
- imgaug==0.4.0
- tqdm==4.46.0
- tensorflow-gpu==1.14.0ನಿಮ್ಮ ರನ್‌ಟೈಮ್ ಪರಿಸರವಾಗಿ ನೀವು ಡಾಕರ್ ಅನ್ನು ಬಳಸಬಹುದು, ಹೆಚ್ಚಿನ ವಿವರಗಳಿಗಾಗಿ ದಯವಿಟ್ಟು ನೋಡಿ .
4. ತರಬೇತಿಯನ್ನು ಪ್ರಾರಂಭಿಸೋಣ
ನಾವು ಯೋಜನೆಯನ್ನು ಕ್ಲೋನ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗುತ್ತೇವೆ:
git clone https://github.com/simbakot/mlflow_example.git
cd mlflow_example/ಚಲಾಯಿಸಲು ನೀವು ಗ್ರಂಥಾಲಯಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗಿದೆ
pip install mlflow
pip install pysftpಏಕೆಂದರೆ ನಾನು conda_env ಅನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಯಲ್ಲಿ, Anaconda ಅನ್ನು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಬೇಕು (ಆದರೆ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ನೀವೇ ಸ್ಥಾಪಿಸುವ ಮೂಲಕ ಮತ್ತು ಲಾಂಚ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗಳೊಂದಿಗೆ ಪ್ಲೇ ಮಾಡುವ ಮೂಲಕ ನೀವು ಇದನ್ನು ಪಡೆಯಬಹುದು).
ಎಲ್ಲಾ ಪೂರ್ವಸಿದ್ಧತಾ ಹಂತಗಳು ಪೂರ್ಣಗೊಂಡಿವೆ ಮತ್ತು ನಾವು ತರಬೇತಿಯನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು. ಯೋಜನೆಯ ಮೂಲದಿಂದ:
$ mlflow run -P epochs=10 -P categories=cat,dog -P tracking_uri=http://server_host:server_port .ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿದ ನಂತರ, ಕಾಂಡಾ ಪರಿಸರವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ತರಬೇತಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾನು ತರಬೇತಿಗಾಗಿ ಯುಗಗಳ ಸಂಖ್ಯೆಯನ್ನು ರವಾನಿಸಿದ್ದೇನೆ, ನಾವು ವಿಭಾಗಿಸಲು ಬಯಸುವ ವರ್ಗಗಳು (ನೀವು ಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ನೋಡಬಹುದು ) ಮತ್ತು ನಮ್ಮ ರಿಮೋಟ್ ಸರ್ವರ್‌ನ ವಿಳಾಸ.
MLproject ಫೈಲ್‌ನಲ್ಲಿ ಸಂಭವನೀಯ ನಿಯತಾಂಕಗಳ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಕಾಣಬಹುದು.
5. ಕಲಿಕೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ
ತರಬೇತಿಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನಾವು ನಮ್ಮ ಸರ್ವರ್‌ನ ವಿಳಾಸಕ್ಕೆ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಹೋಗಬಹುದು
ಇಲ್ಲಿ ನಾವು ಎಲ್ಲಾ ಪ್ರಯೋಗಗಳ ಪಟ್ಟಿಯನ್ನು ನೋಡುತ್ತೇವೆ (ಮೇಲಿನ ಎಡ), ಹಾಗೆಯೇ ರನ್ಗಳ ಮಾಹಿತಿಯನ್ನು (ಮಧ್ಯದಲ್ಲಿ). ಪ್ರತಿ ಉಡಾವಣೆಗಾಗಿ ನಾವು ಹೆಚ್ಚು ವಿವರವಾದ ಮಾಹಿತಿಯನ್ನು (ಪ್ಯಾರಾಮೀಟರ್‌ಗಳು, ಮೆಟ್ರಿಕ್‌ಗಳು, ಕಲಾಕೃತಿಗಳು ಮತ್ತು ಕೆಲವು ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿ) ವೀಕ್ಷಿಸಬಹುದು.
ಪ್ರತಿ ಮೆಟ್ರಿಕ್‌ಗೆ ನಾವು ಬದಲಾವಣೆಗಳ ಇತಿಹಾಸವನ್ನು ಗಮನಿಸಬಹುದು
ಆ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು "ಹಸ್ತಚಾಲಿತ" ಮೋಡ್‌ನಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು ಮತ್ತು ನೀವು MLflow API ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ವಯಂಚಾಲಿತ ಮೌಲ್ಯೀಕರಣವನ್ನು ಸಹ ಹೊಂದಿಸಬಹುದು.
6. ಮಾದರಿಯನ್ನು ನೋಂದಾಯಿಸಿ
ನಾವು ನಮ್ಮ ಮಾದರಿಯನ್ನು ವಿಶ್ಲೇಷಿಸಿದ ನಂತರ ಮತ್ತು ಅದು ಯುದ್ಧಕ್ಕೆ ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ನಿರ್ಧರಿಸಿದ ನಂತರ, ನಾವು ಅದನ್ನು ನೋಂದಾಯಿಸಲು ಮುಂದುವರಿಯುತ್ತೇವೆ, ಇದಕ್ಕಾಗಿ ನಾವು ಅಗತ್ಯವಿರುವ ಉಡಾವಣೆಯನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ (ಹಿಂದಿನ ಪ್ಯಾರಾಗ್ರಾಫ್ನಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ) ಮತ್ತು ಕೆಳಗೆ ಹೋಗಿ.
ನಾವು ನಮ್ಮ ಮಾದರಿಗೆ ಹೆಸರನ್ನು ನೀಡಿದ ನಂತರ, ಅದು ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ. ಅದೇ ಹೆಸರಿನೊಂದಿಗೆ ನೀವು ಇನ್ನೊಂದು ಮಾದರಿಯನ್ನು ಉಳಿಸಿದರೆ, ಆವೃತ್ತಿಯು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅಪ್‌ಗ್ರೇಡ್ ಆಗುತ್ತದೆ.
ಪ್ರತಿ ಮಾದರಿಗೆ, ನಾವು ವಿವರಣೆಯನ್ನು ಸೇರಿಸಬಹುದು ಮತ್ತು ಮೂರು ರಾಜ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು (ಸ್ಟೇಜಿಂಗ್, ಪ್ರೊಡಕ್ಷನ್, ಆರ್ಕೈವ್); ತರುವಾಯ, API ಅನ್ನು ಬಳಸಿಕೊಂಡು, ನಾವು ಈ ರಾಜ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು, ಇದು ಆವೃತ್ತಿಯೊಂದಿಗೆ ಹೆಚ್ಚುವರಿ ನಮ್ಯತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.
ನಾವು ಎಲ್ಲಾ ಮಾದರಿಗಳಿಗೆ ಸುಲಭ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದ್ದೇವೆ
ಮತ್ತು ಅವರ ಆವೃತ್ತಿಗಳು
ಹಿಂದಿನ ಪ್ಯಾರಾಗ್ರಾಫ್‌ನಂತೆ, ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು API ಬಳಸಿ ಮಾಡಬಹುದು.
7. ಮಾದರಿಯನ್ನು ನಿಯೋಜಿಸಿ
ಈ ಹಂತದಲ್ಲಿ, ನಾವು ಈಗಾಗಲೇ ತರಬೇತಿ ಪಡೆದ (ಕೆರಾಸ್) ಮಾದರಿಯನ್ನು ಹೊಂದಿದ್ದೇವೆ. ನೀವು ಅದನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಉದಾಹರಣೆ:
class SegmentationModel:
def __init__(self, tracking_uri, model_name):
self.registry = RemoteRegistry(tracking_uri=tracking_uri)
self.model_name = model_name
self.model = self.build_model(model_name)
def get_latest_model(self, model_name):
registered_models = self.registry.get_registered_model(model_name)
last_model = self.registry.get_last_model(registered_models)
local_path = self.registry.download_artifact(last_model.run_id, 'model', './')
return local_path
def build_model(self, model_name):
local_path = self.get_latest_model(model_name)
return mlflow.keras.load_model(local_path)
def predict(self, image):
image = self.preprocess(image)
result = self.model.predict(image)
return self.postprocess(result)
def preprocess(self, image):
image = cv2.resize(image, (256, 256))
image = image / 255.
image = np.expand_dims(image, 0)
return image
def postprocess(self, result):
return resultಇಲ್ಲಿ self.registry ಮತ್ತೆ ಅನುಕೂಲಕ್ಕಾಗಿ mlflow.tracking.MlflowClient ಮೇಲೆ ಸಣ್ಣ ಹೊದಿಕೆಯಾಗಿದೆ. ನಾನು ರಿಮೋಟ್ ಸರ್ವರ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತೇನೆ ಮತ್ತು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಹೆಸರಿನೊಂದಿಗೆ ಮತ್ತು ಇತ್ತೀಚಿನ ಉತ್ಪಾದನಾ ಆವೃತ್ತಿಯೊಂದಿಗೆ ಮಾದರಿಯನ್ನು ಹುಡುಕುತ್ತೇನೆ. ಮುಂದೆ, ನಾನು ಕಲಾಕೃತಿಯನ್ನು ಸ್ಥಳೀಯವಾಗಿ ./ಮಾದರಿ ಫೋಲ್ಡರ್‌ಗೆ ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತೇನೆ ಮತ್ತು ಈ ಡೈರೆಕ್ಟರಿಯಿಂದ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇನೆ mlflow.keras.load_model(local_path). ಈಗ ನಾವು ನಮ್ಮ ಮಾದರಿಯನ್ನು ಬಳಸಬಹುದು. CV (ML) ಡೆವಲಪರ್‌ಗಳು ಸುಲಭವಾಗಿ ಮಾದರಿಯನ್ನು ಸುಧಾರಿಸಬಹುದು ಮತ್ತು ಹೊಸ ಆವೃತ್ತಿಗಳನ್ನು ಪ್ರಕಟಿಸಬಹುದು.
ತೀರ್ಮಾನಕ್ಕೆ
ನಾನು ಅನುಮತಿಸುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಿದೆ:
- ML ಮಾದರಿಗಳು, ತರಬೇತಿ ಪ್ರಗತಿ ಮತ್ತು ಫಲಿತಾಂಶಗಳ ಬಗ್ಗೆ ಕೇಂದ್ರೀಯವಾಗಿ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಿ;
- ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ತ್ವರಿತವಾಗಿ ನಿಯೋಜಿಸಿ;
- ಮಾದರಿಗಳ ಕೆಲಸದ ಪ್ರಗತಿಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಿ ಮತ್ತು ವಿಶ್ಲೇಷಿಸಿ;
- ಮಾದರಿಗಳ ಸ್ಥಿತಿಯನ್ನು ಆವೃತ್ತಿ ಮತ್ತು ನಿರ್ವಹಿಸಲು ಇದು ಅನುಕೂಲಕರವಾಗಿದೆ;
- ಪರಿಣಾಮವಾಗಿ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸಲು ಇದು ಸುಲಭವಾಗಿದೆ.
ಈ ಉದಾಹರಣೆಯು ಆಟಿಕೆಯಾಗಿದೆ ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು ಆರಂಭಿಕ ಹಂತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಇದು ಫಲಿತಾಂಶಗಳ ಮೌಲ್ಯಮಾಪನದ ಯಾಂತ್ರೀಕೃತಗೊಂಡ ಮತ್ತು ಮಾದರಿಗಳ ನೋಂದಣಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ (ಅನುಕ್ರಮವಾಗಿ ಅಂಕಗಳು 5 ಮತ್ತು 6) ಅಥವಾ ನೀವು ಡೇಟಾಸೆಟ್‌ಗಳ ಆವೃತ್ತಿಯನ್ನು ಸೇರಿಸುತ್ತೀರಿ, ಅಥವಾ ಇನ್ನೇನಾದರೂ ? ನಾನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಅಂಶವೆಂದರೆ ನಿಮಗೆ ಒಟ್ಟಾರೆಯಾಗಿ MLOps ಅಗತ್ಯವಿದೆ, MLflow ಕೇವಲ ಅಂತ್ಯದ ಸಾಧನವಾಗಿದೆ.
ನಾನು ಪ್ರದರ್ಶಿಸದೇ ಇರುವಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ನೀವು ಎದುರಿಸಿದ್ದನ್ನು ಬರೆಯಿರಿ?
ನಿಮ್ಮ ಅಗತ್ಯಗಳನ್ನು ಪೂರೈಸಲು ನೀವು ಸಿಸ್ಟಮ್‌ಗೆ ಏನನ್ನು ಸೇರಿಸುತ್ತೀರಿ?
ಎಲ್ಲಾ ಅಥವಾ ಭಾಗಶಃ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ನೀವು ಯಾವ ಸಾಧನಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಬಳಸುತ್ತೀರಿ?
PS ನಾನು ಒಂದೆರಡು ಲಿಂಕ್‌ಗಳನ್ನು ಬಿಡುತ್ತೇನೆ:
ಗಿಥಬ್ ಯೋಜನೆ -
ಎಂಎಲ್‌ಫ್ಲೋ -
ಪ್ರಶ್ನೆಗಳಿಗಾಗಿ ನನ್ನ ಕೆಲಸದ ಇಮೇಲ್ - [ಇಮೇಲ್ ರಕ್ಷಿಸಲಾಗಿದೆ]
ನಮ್ಮ ಕಂಪನಿ ನಿಯತಕಾಲಿಕವಾಗಿ ಐಟಿ ತಜ್ಞರಿಗಾಗಿ ವಿವಿಧ ಈವೆಂಟ್‌ಗಳನ್ನು ಆಯೋಜಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ: ಜುಲೈ 8 ರಂದು ಮಾಸ್ಕೋ ಸಮಯಕ್ಕೆ 19:00 ಕ್ಕೆ ಆನ್‌ಲೈನ್ ಸ್ವರೂಪದಲ್ಲಿ ಸಿವಿ ಮೀಟಪ್ ಇರುತ್ತದೆ, ನಿಮಗೆ ಆಸಕ್ತಿ ಇದ್ದರೆ, ನೀವು ಭಾಗವಹಿಸಬಹುದು, ನೋಂದಣಿ .
ಮೂಲ: www.habr.com