ನೀವು ಮತ್ತೆ ಮೊದಲು ವಸ್ತುಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವ ಕಾರ್ಯವಾಗಿದೆ. ಸ್ವೀಕಾರಾರ್ಹ ನಿಖರತೆಯೊಂದಿಗೆ ಕಾರ್ಯಾಚರಣೆಯ ವೇಗವು ಆದ್ಯತೆಯಾಗಿದೆ. ನೀವು YOLOv3 ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಮತ್ತಷ್ಟು ತರಬೇತಿ ಮಾಡಿ. ನಿಖರತೆ(mAp75) 0.95 ಕ್ಕಿಂತ ಹೆಚ್ಚಿದೆ. ಆದರೆ ರನ್ ರೇಟ್ ಇನ್ನೂ ಕಡಿಮೆ ಇದೆ. ಅಮೇಧ್ಯ.
ಇಂದು ನಾವು ಪ್ರಮಾಣೀಕರಣವನ್ನು ಬೈಪಾಸ್ ಮಾಡುತ್ತೇವೆ. ಮತ್ತು ಕಟ್ ಅಡಿಯಲ್ಲಿ ನಾವು ನೋಡುತ್ತೇವೆ ಮಾದರಿ ಸಮರುವಿಕೆ — ನಿಖರತೆಯ ನಷ್ಟವಿಲ್ಲದೆಯೇ ನಿರ್ಣಯವನ್ನು ವೇಗಗೊಳಿಸಲು ನೆಟ್ವರ್ಕ್ನ ಅನಗತ್ಯ ಭಾಗಗಳನ್ನು ಟ್ರಿಮ್ ಮಾಡುವುದು. ಎಲ್ಲಿ, ಎಷ್ಟು ಮತ್ತು ಹೇಗೆ ಕತ್ತರಿಸುವುದು ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿದೆ. ಇದನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಹೇಗೆ ಮಾಡುವುದು ಮತ್ತು ನೀವು ಅದನ್ನು ಎಲ್ಲಿ ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ. ಕೊನೆಯಲ್ಲಿ ಕೆರಾಗಳ ಮೇಲೆ ಭಂಡಾರವಿದೆ.
ಪರಿಚಯ
ನನ್ನ ಹಿಂದಿನ ಕೆಲಸದ ಸ್ಥಳದಲ್ಲಿ, ಪೆರ್ಮ್‌ನಲ್ಲಿರುವ ಮ್ಯಾಕ್ರೋಸ್ಕೋಪ್, ನಾನು ಒಂದು ಅಭ್ಯಾಸವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇನೆ - ಯಾವಾಗಲೂ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯವನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು. ಮತ್ತು ಯಾವಾಗಲೂ ನೆಟ್ವರ್ಕ್ ರನ್‌ಟೈಮ್ ಅನ್ನು ಸಮರ್ಪಕ ಫಿಲ್ಟರ್ ಮೂಲಕ ಪರಿಶೀಲಿಸಿ. ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ಪಾದನೆಯಲ್ಲಿನ ಸ್ಟೇಟ್-ಆಫ್-ಆರ್ಟ್ ಈ ಫಿಲ್ಟರ್ ಅನ್ನು ರವಾನಿಸುವುದಿಲ್ಲ, ಅದು ನನ್ನನ್ನು ಸಮರುವಿಕೆಗೆ ಕಾರಣವಾಯಿತು.
ಸಮರುವಿಕೆಯನ್ನು ಚರ್ಚಿಸಿದ ಹಳೆಯ ವಿಷಯವಾಗಿದೆ 2017 ರಲ್ಲಿ. ವಿವಿಧ ನೋಡ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ನಿಖರತೆಯನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ ತರಬೇತಿ ಪಡೆದ ನೆಟ್ವರ್ಕ್ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು ಮುಖ್ಯ ಆಲೋಚನೆಯಾಗಿದೆ. ಇದು ತಂಪಾಗಿದೆ, ಆದರೆ ಅದರ ಬಳಕೆಯ ಬಗ್ಗೆ ನಾನು ವಿರಳವಾಗಿ ಕೇಳುತ್ತೇನೆ. ಬಹುಶಃ, ಸಾಕಷ್ಟು ಅನುಷ್ಠಾನಗಳಿಲ್ಲ, ಯಾವುದೇ ರಷ್ಯನ್ ಭಾಷೆಯ ಲೇಖನಗಳಿಲ್ಲ, ಅಥವಾ ಸರಳವಾಗಿ ಎಲ್ಲರೂ ಅದನ್ನು ಸಮರುವಿಕೆಯನ್ನು ಜ್ಞಾನವನ್ನು ಪರಿಗಣಿಸುತ್ತಾರೆ ಮತ್ತು ಮೌನವಾಗಿರುತ್ತಾರೆ.
ಆದರೆ ಅದನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ತೆಗೆದುಕೊಳ್ಳೋಣ
ಜೀವಶಾಸ್ತ್ರದ ಒಂದು ನೋಟ
ಡೀಪ್ ಲರ್ನಿಂಗ್ ಜೀವಶಾಸ್ತ್ರದಿಂದ ಬರುವ ವಿಚಾರಗಳನ್ನು ನೋಡಿದಾಗ ನಾನು ಅದನ್ನು ಪ್ರೀತಿಸುತ್ತೇನೆ. ಅವರು, ವಿಕಸನದಂತೆ, ನಂಬಬಹುದು (ನಿಮಗೆ ReLU ಹೋಲುತ್ತದೆ ಎಂದು ತಿಳಿದಿದೆಯೇ ?)
ಮಾದರಿ ಸಮರುವಿಕೆ ಪ್ರಕ್ರಿಯೆಯು ಸಹ ಜೀವಶಾಸ್ತ್ರಕ್ಕೆ ಹತ್ತಿರದಲ್ಲಿದೆ. ಇಲ್ಲಿ ನೆಟ್ವರ್ಕ್ನ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಮೆದುಳಿನ ಪ್ಲಾಸ್ಟಿಟಿಗೆ ಹೋಲಿಸಬಹುದು. ಪುಸ್ತಕದಲ್ಲಿ ಒಂದೆರಡು ಆಸಕ್ತಿದಾಯಕ ಉದಾಹರಣೆಗಳಿವೆ. :
- ಕೇವಲ ಒಂದು ಅರ್ಧದೊಂದಿಗೆ ಜನಿಸಿದ ಮಹಿಳೆಯ ಮೆದುಳು ಕಾಣೆಯಾದ ಅರ್ಧದ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸ್ವತಃ ಪುನರುಜ್ಜೀವನಗೊಂಡಿದೆ.
- ವ್ಯಕ್ತಿ ದೃಷ್ಟಿಗೆ ಕಾರಣವಾದ ತನ್ನ ಮೆದುಳಿನ ಭಾಗವನ್ನು ಹೊಡೆದನು. ಕಾಲಾನಂತರದಲ್ಲಿ, ಮೆದುಳಿನ ಇತರ ಭಾಗಗಳು ಈ ಕಾರ್ಯಗಳನ್ನು ವಹಿಸಿಕೊಂಡವು. (ನಾವು ಪುನರಾವರ್ತಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿಲ್ಲ)
ಅಂತೆಯೇ, ನಿಮ್ಮ ಮಾದರಿಯಿಂದ ಕೆಲವು ದುರ್ಬಲ ಸುರುಳಿಗಳನ್ನು ನೀವು ಕತ್ತರಿಸಬಹುದು. ಕೊನೆಯ ಉಪಾಯವಾಗಿ, ಉಳಿದ ಕಟ್ಟುಗಳು ಕಟ್ ಪದಗಳಿಗಿಂತ ಬದಲಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ನೀವು ವರ್ಗಾವಣೆ ಕಲಿಕೆಯನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಾ ಅಥವಾ ನೀವು ಮೊದಲಿನಿಂದ ಕಲಿಯುತ್ತಿದ್ದೀರಾ?
ಆಯ್ಕೆ ಸಂಖ್ಯೆ ಒಂದು. ನೀವು Yolov3 ನಲ್ಲಿ ವರ್ಗಾವಣೆ ಕಲಿಕೆಯನ್ನು ಬಳಸುತ್ತೀರಿ. ರೆಟಿನಾ, ಮಾಸ್ಕ್-ಆರ್‌ಸಿಎನ್‌ಎನ್ ಅಥವಾ ಯು-ನೆಟ್. ಆದರೆ ಹೆಚ್ಚಿನ ಸಮಯ ನಾವು COCO ನಲ್ಲಿರುವಂತೆ 80 ಆಬ್ಜೆಕ್ಟ್ ವರ್ಗಗಳನ್ನು ಗುರುತಿಸುವ ಅಗತ್ಯವಿಲ್ಲ. ನನ್ನ ಅಭ್ಯಾಸದಲ್ಲಿ, ಎಲ್ಲವೂ 1-2 ಶ್ರೇಣಿಗಳಿಗೆ ಸೀಮಿತವಾಗಿದೆ. 80 ತರಗತಿಗಳ ವಾಸ್ತುಶಿಲ್ಪವು ಇಲ್ಲಿ ಅನಗತ್ಯವಾಗಿದೆ ಎಂದು ಒಬ್ಬರು ಊಹಿಸಬಹುದು. ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಚಿಕ್ಕದಾಗಿ ಮಾಡಬೇಕೆಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ಇದಲ್ಲದೆ, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಪೂರ್ವ-ತರಬೇತಿ ಪಡೆದ ತೂಕವನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ ನಾನು ಇದನ್ನು ಮಾಡಲು ಬಯಸುತ್ತೇನೆ.
ಆಯ್ಕೆ ಸಂಖ್ಯೆ ಎರಡು. ಬಹುಶಃ ನೀವು ಸಾಕಷ್ಟು ಡೇಟಾ ಮತ್ತು ಕಂಪ್ಯೂಟಿಂಗ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಅಥವಾ ಸೂಪರ್-ಕಸ್ಟಮ್ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅಗತ್ಯವಿದೆ. ಪರವಾಗಿಲ್ಲ. ಆದರೆ ನೀವು ಮೊದಲಿನಿಂದಲೂ ನೆಟ್ವರ್ಕ್ ಕಲಿಯುತ್ತಿದ್ದೀರಿ. ಡೇಟಾ ರಚನೆಯನ್ನು ನೋಡುವುದು, ಶಕ್ತಿಯಲ್ಲಿ ಅಧಿಕವಾಗಿರುವ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಮತ್ತು ಮರುತರಬೇತಿಯಿಂದ ಡ್ರಾಪ್‌ಔಟ್‌ಗಳನ್ನು ತಳ್ಳುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ನಾನು 0.6 ಡ್ರಾಪ್‌ಔಟ್‌ಗಳನ್ನು ನೋಡಿದೆ, ಕಾರ್ಲ್.
ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು. ಪ್ರೇರೇಪಿಸಿದೆ. ಈಗ ಯಾವ ರೀತಿಯ ಸುನ್ನತಿ ಸಮರುವಿಕೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡೋಣ
ಸಾಮಾನ್ಯ ಅಲ್ಗಾರಿದಮ್
ನಾವು ಕಟ್ಟುಗಳನ್ನು ತೆಗೆಯಬಹುದು ಎಂದು ನಿರ್ಧರಿಸಿದ್ದೇವೆ. ಇದು ತುಂಬಾ ಸರಳವಾಗಿ ಕಾಣುತ್ತದೆ:
ಯಾವುದೇ ಕನ್ವಲ್ಯೂಷನ್ ಅನ್ನು ತೆಗೆದುಹಾಕುವುದು ನೆಟ್‌ವರ್ಕ್‌ಗೆ ಒತ್ತಡವನ್ನುಂಟುಮಾಡುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ದೋಷದಲ್ಲಿ ಸ್ವಲ್ಪ ಹೆಚ್ಚಳಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ. ಒಂದೆಡೆ, ದೋಷದಲ್ಲಿನ ಈ ಹೆಚ್ಚಳವು ನಾವು ಸುರುಳಿಗಳನ್ನು ಎಷ್ಟು ಸರಿಯಾಗಿ ತೆಗೆದುಹಾಕುತ್ತೇವೆ ಎಂಬುದರ ಸೂಚಕವಾಗಿದೆ (ಉದಾಹರಣೆಗೆ, ದೊಡ್ಡ ಹೆಚ್ಚಳವು ನಾವು ಏನಾದರೂ ತಪ್ಪು ಮಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ). ಆದರೆ ಸಣ್ಣ ಹೆಚ್ಚಳವು ಸಾಕಷ್ಟು ಸ್ವೀಕಾರಾರ್ಹವಾಗಿದೆ ಮತ್ತು ಸಣ್ಣ LR ನೊಂದಿಗೆ ನಂತರದ ಬೆಳಕಿನ ಹೆಚ್ಚುವರಿ ತರಬೇತಿಯಿಂದ ಹೆಚ್ಚಾಗಿ ಹೊರಹಾಕಲ್ಪಡುತ್ತದೆ. ಹೆಚ್ಚುವರಿ ತರಬೇತಿ ಹಂತವನ್ನು ಸೇರಿಸಿ:
ಈಗ ನಾವು ನಮ್ಮ ಕಲಿಕೆಯನ್ನು ನಿಲ್ಲಿಸಲು ಬಯಸಿದಾಗ ನಾವು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕಾಗಿದೆ<->ಪ್ರೂನಿಂಗ್ ಲೂಪ್. ನಾವು ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಗಾತ್ರ ಮತ್ತು ವೇಗಕ್ಕೆ ಕಡಿಮೆ ಮಾಡಬೇಕಾದಾಗ ಇಲ್ಲಿ ವಿಲಕ್ಷಣ ಆಯ್ಕೆಗಳು ಇರಬಹುದು (ಉದಾಹರಣೆಗೆ, ಮೊಬೈಲ್ ಸಾಧನಗಳಿಗಾಗಿ). ಆದಾಗ್ಯೂ, ದೋಷವು ಸ್ವೀಕಾರಾರ್ಹಕ್ಕಿಂತ ಹೆಚ್ಚಾಗುವವರೆಗೆ ಚಕ್ರವನ್ನು ಮುಂದುವರಿಸುವುದು ಸಾಮಾನ್ಯ ಆಯ್ಕೆಯಾಗಿದೆ. ಷರತ್ತು ಸೇರಿಸಿ:
ಆದ್ದರಿಂದ, ಅಲ್ಗಾರಿದಮ್ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಅಳಿಸಿದ ಸುರುಳಿಗಳನ್ನು ಹೇಗೆ ನಿರ್ಧರಿಸುವುದು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು ಇದು ಉಳಿದಿದೆ.
ಅಳಿಸಿದ ಪ್ಯಾಕೇಜುಗಳಿಗಾಗಿ ಹುಡುಕಿ
ನಾವು ಕೆಲವು ಸುರುಳಿಗಳನ್ನು ತೆಗೆದುಹಾಕಬೇಕಾಗಿದೆ. ಮುಂದೆ ನುಗ್ಗುವುದು ಮತ್ತು ಯಾರನ್ನಾದರೂ "ಶೂಟಿಂಗ್" ಮಾಡುವುದು ಕೆಟ್ಟ ಕಲ್ಪನೆ, ಆದರೂ ಅದು ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಆದರೆ ನೀವು ತಲೆ ಹೊಂದಿರುವುದರಿಂದ, ತೆಗೆದುಹಾಕಲು "ದುರ್ಬಲ" ಸುರುಳಿಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಲು ನೀವು ಯೋಚಿಸಬಹುದು ಮತ್ತು ಪ್ರಯತ್ನಿಸಬಹುದು. ಹಲವಾರು ಆಯ್ಕೆಗಳಿವೆ:
- . ಸಣ್ಣ ತೂಕದೊಂದಿಗೆ ಸುರುಳಿಗಳು ಅಂತಿಮ ನಿರ್ಧಾರಕ್ಕೆ ಕಡಿಮೆ ಕೊಡುಗೆ ನೀಡುತ್ತವೆ ಎಂಬ ಕಲ್ಪನೆ
- ಚಿಕ್ಕದಾದ L1-ಅಳತೆ ಸರಾಸರಿ ಮತ್ತು ಪ್ರಮಾಣಿತ ವಿಚಲನವನ್ನು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ವಿತರಣೆಯ ಸ್ವರೂಪದ ಮೌಲ್ಯಮಾಪನದೊಂದಿಗೆ ನಾವು ಪೂರಕಗೊಳಿಸುತ್ತೇವೆ.
- . ಅತ್ಯಲ್ಪ ಸುರುಳಿಗಳ ಹೆಚ್ಚು ನಿಖರವಾದ ನಿರ್ಣಯ, ಆದರೆ ಬಹಳ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುವ ಮತ್ತು ಸಂಪನ್ಮೂಲ-ಸೇವಿಸುವ.
- ಇತರೆ
ಪ್ರತಿಯೊಂದು ಆಯ್ಕೆಗಳು ಜೀವನದ ಹಕ್ಕು ಮತ್ತು ಅದರ ಸ್ವಂತ ಅನುಷ್ಠಾನದ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿವೆ. ಇಲ್ಲಿ ನಾವು ಚಿಕ್ಕ L1- ಅಳತೆಯೊಂದಿಗೆ ಆಯ್ಕೆಯನ್ನು ಪರಿಗಣಿಸುತ್ತೇವೆ
YOLOv3 ಗಾಗಿ ಹಸ್ತಚಾಲಿತ ಪ್ರಕ್ರಿಯೆ
ಮೂಲ ವಾಸ್ತುಶಿಲ್ಪವು ಉಳಿದಿರುವ ಬ್ಲಾಕ್ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಆದರೆ ಆಳವಾದ ನೆಟ್‌ವರ್ಕ್‌ಗಳಿಗೆ ಅವು ಎಷ್ಟು ತಂಪಾಗಿದ್ದರೂ, ಅವು ನಮಗೆ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಅಡ್ಡಿಯಾಗುತ್ತವೆ. ಈ ಲೇಯರ್‌ಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಸೂಚಿಕೆಗಳೊಂದಿಗೆ ನೀವು ಹೊಂದಾಣಿಕೆಗಳನ್ನು ಅಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂಬುದು ತೊಂದರೆ:
ಆದ್ದರಿಂದ, ನಾವು ಸಮನ್ವಯಗಳನ್ನು ಮುಕ್ತವಾಗಿ ಅಳಿಸಬಹುದಾದ ಲೇಯರ್‌ಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡೋಣ:
ಈಗ ನಾವು ಕೆಲಸದ ಚಕ್ರವನ್ನು ನಿರ್ಮಿಸೋಣ:
- ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಗಳನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
- ಎಷ್ಟು ಕತ್ತರಿಸಬೇಕೆಂದು ಲೆಕ್ಕಾಚಾರ
- ಕತ್ತರಿಸಿ ತೆಗೆ
- LR=10e-1 ನೊಂದಿಗೆ 4 ಯುಗಗಳನ್ನು ಕಲಿಯುವುದು
- ಪರೀಕ್ಷೆ
ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ ನಾವು ಎಷ್ಟು ಭಾಗವನ್ನು ತೆಗೆದುಹಾಕಬಹುದು ಎಂಬುದನ್ನು ಅಂದಾಜು ಮಾಡಲು ಸುರುಳಿಗಳನ್ನು ಇಳಿಸುವುದು ಉಪಯುಕ್ತವಾಗಿದೆ. ಇಳಿಸುವಿಕೆಯ ಉದಾಹರಣೆಗಳು:
ಬಹುತೇಕ ಎಲ್ಲೆಡೆ 5% ರಷ್ಟು ಸುರುಳಿಗಳು ಅತ್ಯಂತ ಕಡಿಮೆ L1- ರೂಢಿಯನ್ನು ಹೊಂದಿವೆ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕಬಹುದು. ಪ್ರತಿ ಹಂತದಲ್ಲೂ, ಈ ಇಳಿಸುವಿಕೆಯನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಯಾವ ಪದರಗಳು ಮತ್ತು ಎಷ್ಟು ಕತ್ತರಿಸಬಹುದು ಎಂಬುದರ ಮೌಲ್ಯಮಾಪನವನ್ನು ಮಾಡಲಾಯಿತು.
ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು 4 ಹಂತಗಳಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಲಾಗಿದೆ (ಆರ್‌ಟಿಎಕ್ಸ್ 2060 ಸೂಪರ್‌ಗಾಗಿ ಇಲ್ಲಿ ಮತ್ತು ಎಲ್ಲೆಡೆ ಸಂಖ್ಯೆಗಳು):
| ಹಂತ | mAp75 | ನಿಯತಾಂಕಗಳ ಸಂಖ್ಯೆ, ಮಿಲಿಯನ್ | ನೆಟ್ವರ್ಕ್ ಗಾತ್ರ, ಎಂಬಿ | ಆರಂಭದಿಂದ ಶೇ. | ರನ್ ಸಮಯ, ms | ಸುನ್ನತಿ ಸ್ಥಿತಿ |
|---|---|---|---|---|---|---|
| 0 | 0.9656 | 60 | 241 | 100 | 180 | - |
| 1 | 0.9622 | 55 | 218 | 91 | 175 | ಎಲ್ಲಾ 5% |
| 2 | 0.9625 | 50 | 197 | 83 | 168 | ಎಲ್ಲಾ 5% |
| 3 | 0.9633 | 39 | 155 | 64 | 155 | 15+ ಸುರುಳಿಗಳನ್ನು ಹೊಂದಿರುವ ಲೇಯರ್‌ಗಳಿಗೆ 400% |
| 4 | 0.9555 | 31 | 124 | 51 | 146 | 10+ ಸುರುಳಿಗಳನ್ನು ಹೊಂದಿರುವ ಲೇಯರ್‌ಗಳಿಗೆ 100% |
ಒಂದು ಸಕಾರಾತ್ಮಕ ಪರಿಣಾಮವನ್ನು ಹಂತ 2 ಗೆ ಸೇರಿಸಲಾಗಿದೆ - ಬ್ಯಾಚ್ ಗಾತ್ರ 4 ಮೆಮೊರಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ, ಇದು ಹೆಚ್ಚುವರಿ ತರಬೇತಿಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ವೇಗಗೊಳಿಸಿತು.
4 ನೇ ಹಂತದಲ್ಲಿ, ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸಲಾಯಿತು ಏಕೆಂದರೆ ದೀರ್ಘಾವಧಿಯ ಹೆಚ್ಚುವರಿ ತರಬೇತಿಯು ಹಳೆಯ ಮೌಲ್ಯಗಳಿಗೆ mAp75 ಅನ್ನು ಹೆಚ್ಚಿಸಲಿಲ್ಲ.
ಪರಿಣಾಮವಾಗಿ, ನಾವು ತೀರ್ಮಾನವನ್ನು ವೇಗಗೊಳಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇವೆ 15%, ಮೂಲಕ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಿ 35% ಮತ್ತು ನಿಖರವಾಗಿ ಕಳೆದುಕೊಳ್ಳುವುದಿಲ್ಲ.
ಸರಳವಾದ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಿಗೆ ಆಟೋಮೇಷನ್
ಸರಳವಾದ ನೆಟ್ವರ್ಕ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ಗಳಿಗಾಗಿ (ಷರತ್ತಿನ ಆಡ್, ಕಾನ್ಕಾಟರ್ನೇಟ್ ಮತ್ತು ಉಳಿದ ಬ್ಲಾಕ್‌ಗಳಿಲ್ಲದೆ), ಎಲ್ಲಾ ಕನ್ವಲ್ಯೂಷನಲ್ ಲೇಯರ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸಲು ಮತ್ತು ಸುರುಳಿಗಳನ್ನು ಕತ್ತರಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಸಾಕಷ್ಟು ಸಾಧ್ಯವಿದೆ.
ನಾನು ಈ ಆಯ್ಕೆಯನ್ನು ಜಾರಿಗೆ ತಂದಿದ್ದೇನೆ .
ಇದು ಸರಳವಾಗಿದೆ: ನಿಮಗೆ ನಷ್ಟದ ಕಾರ್ಯ, ಆಪ್ಟಿಮೈಜರ್ ಮತ್ತು ಬ್ಯಾಚ್ ಜನರೇಟರ್‌ಗಳು ಮಾತ್ರ ಅಗತ್ಯವಿದೆ:
import pruning
from keras.optimizers import Adam
from keras.utils import Sequence
train_batch_generator = BatchGenerator...
score_batch_generator = BatchGenerator...
opt = Adam(lr=1e-4)
pruner = pruning.Pruner("config.json", "categorical_crossentropy", opt)
pruner.prune(train_batch, valid_batch)ಅಗತ್ಯವಿದ್ದರೆ, ನೀವು ಸಂರಚನಾ ನಿಯತಾಂಕಗಳನ್ನು ಬದಲಾಯಿಸಬಹುದು:
{
"input_model_path": "model.h5",
"output_model_path": "model_pruned.h5",
"finetuning_epochs": 10, # the number of epochs for train between pruning steps
"stop_loss": 0.1, # loss for stopping process
"pruning_percent_step": 0.05, # part of convs for delete on every pruning step
"pruning_standart_deviation_part": 0.2 # shift for limit pruning part
}ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪ್ರಮಾಣಿತ ವಿಚಲನದ ಆಧಾರದ ಮೇಲೆ ಮಿತಿಯನ್ನು ಅಳವಡಿಸಲಾಗಿದೆ. ಈಗಾಗಲೇ "ಸಾಕಷ್ಟು" L1 ಅಳತೆಗಳೊಂದಿಗೆ ಸುರುಳಿಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ತೆಗೆದುಹಾಕಲಾದ ಭಾಗವನ್ನು ಮಿತಿಗೊಳಿಸುವುದು ಗುರಿಯಾಗಿದೆ:
ಹೀಗಾಗಿ, ಬಲಕ್ಕೆ ಹೋಲುವ ವಿತರಣೆಗಳಿಂದ ದುರ್ಬಲ ಸುರುಳಿಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಹಾಕಲು ನಾವು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತೇವೆ ಮತ್ತು ಎಡಕ್ಕೆ ಹೋಲುವ ವಿತರಣೆಗಳಿಂದ ತೆಗೆದುಹಾಕುವಿಕೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ:
ವಿತರಣೆಯು ಸಾಮಾನ್ಯ ಹಂತಕ್ಕೆ ಬಂದಾಗ, ಸಮರುವಿಕೆಯನ್ನು_ಪ್ರಮಾಣಿತ_ವಿಚಲನ_ಭಾಗದ ಗುಣಾಂಕವನ್ನು ಇದರಿಂದ ಆಯ್ಕೆ ಮಾಡಬಹುದು:
ನಾನು 2 ಸಿಗ್ಮಾದ ಊಹೆಯನ್ನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ಅಥವಾ ನೀವು <1.0 ಮೌಲ್ಯವನ್ನು ಬಿಟ್ಟು ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ನಿರ್ಲಕ್ಷಿಸಬಹುದು.
ಔಟ್‌ಪುಟ್ ನೆಟ್ವರ್ಕ್ ಗಾತ್ರ, ನಷ್ಟ ಮತ್ತು ಸಂಪೂರ್ಣ ಪರೀಕ್ಷೆಗಾಗಿ ನೆಟ್ವರ್ಕ್ ರನ್‌ಟೈಮ್‌ನ ಗ್ರಾಫ್ ಆಗಿದೆ, ಇದನ್ನು 1.0 ಗೆ ಸಾಮಾನ್ಯಗೊಳಿಸಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಇಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಗಾತ್ರವು ಗುಣಮಟ್ಟವನ್ನು ಕಳೆದುಕೊಳ್ಳದೆ ಸುಮಾರು 2 ಪಟ್ಟು ಕಡಿಮೆಯಾಗಿದೆ (100k ತೂಕದೊಂದಿಗೆ ಸಣ್ಣ ಕನ್ವಲ್ಯೂಷನಲ್ ನೆಟ್ವರ್ಕ್):
ಚಾಲನೆಯಲ್ಲಿರುವ ವೇಗವು ಸಾಮಾನ್ಯ ಏರಿಳಿತಗಳಿಗೆ ಒಳಪಟ್ಟಿರುತ್ತದೆ ಮತ್ತು ವಾಸ್ತವಿಕವಾಗಿ ಬದಲಾಗದೆ ಉಳಿಯುತ್ತದೆ. ಇದಕ್ಕೆ ವಿವರಣೆಯಿದೆ:
- ಸುರುಳಿಗಳ ಸಂಖ್ಯೆಯು ಅನುಕೂಲಕರ (32, 64, 128) ನಿಂದ ವೀಡಿಯೊ ಕಾರ್ಡ್‌ಗಳಿಗೆ ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿಲ್ಲ - 27, 51, ಇತ್ಯಾದಿ. ನಾನು ಇಲ್ಲಿ ತಪ್ಪಾಗಿರಬಹುದು, ಆದರೆ ಹೆಚ್ಚಾಗಿ ಅದು ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.
- ವಾಸ್ತುಶಿಲ್ಪವು ವಿಶಾಲವಾಗಿಲ್ಲ, ಆದರೆ ಸ್ಥಿರವಾಗಿದೆ. ಅಗಲವನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ, ನಾವು ಆಳದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಹೀಗಾಗಿ, ನಾವು ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತೇವೆ, ಆದರೆ ವೇಗವನ್ನು ಬದಲಾಯಿಸಬೇಡಿ.
ಆದ್ದರಿಂದ, ರನ್ ಸಮಯದಲ್ಲಿ CUDA ಲೋಡ್‌ನಲ್ಲಿ 20-30% ರಷ್ಟು ಕಡಿತದಲ್ಲಿ ಸುಧಾರಣೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಲಾಗಿದೆ, ಆದರೆ ರನ್ ಸಮಯದಲ್ಲಿ ಕಡಿತದಲ್ಲಿ ಅಲ್ಲ
ಫಲಿತಾಂಶಗಳು
ಪ್ರತಿಬಿಂಬಿಸೋಣ. ಸಮರುವಿಕೆಯನ್ನು ಮಾಡಲು ನಾವು 2 ಆಯ್ಕೆಗಳನ್ನು ಪರಿಗಣಿಸಿದ್ದೇವೆ - YOLOv3 (ನೀವು ನಿಮ್ಮ ಕೈಗಳಿಂದ ಕೆಲಸ ಮಾಡಬೇಕಾದಾಗ) ಮತ್ತು ಸರಳವಾದ ಆರ್ಕಿಟೆಕ್ಚರ್ಗಳೊಂದಿಗೆ ನೆಟ್ವರ್ಕ್ಗಳಿಗಾಗಿ. ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಿಖರತೆಯ ನಷ್ಟವಿಲ್ಲದೆಯೇ ನೆಟ್ವರ್ಕ್ ಗಾತ್ರದ ಕಡಿತ ಮತ್ತು ವೇಗವನ್ನು ಸಾಧಿಸಲು ಸಾಧ್ಯವಿದೆ ಎಂದು ನೋಡಬಹುದು. ಫಲಿತಾಂಶಗಳು:
- ಕಡಿಮೆಗೊಳಿಸುವುದು
- ವೇಗವರ್ಧಕ ರನ್
- CUDA ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುವುದು
- ಪರಿಣಾಮವಾಗಿ, ಪರಿಸರ ಸ್ನೇಹಪರತೆ (ಕಂಪ್ಯೂಟಿಂಗ್ ಸಂಪನ್ಮೂಲಗಳ ಭವಿಷ್ಯದ ಬಳಕೆಯನ್ನು ನಾವು ಉತ್ತಮಗೊಳಿಸುತ್ತೇವೆ. ಎಲ್ಲೋ ಒಬ್ಬರು ಸಂತೋಷವಾಗಿರುತ್ತಾರೆ )
ಅನುಬಂಧ
- ಸಮರುವಿಕೆಯ ಹಂತದ ನಂತರ, ನೀವು ಪರಿಮಾಣೀಕರಣವನ್ನು ಸೇರಿಸಬಹುದು (ಉದಾಹರಣೆಗೆ, TensorRT ಯೊಂದಿಗೆ)
- ಟೆನ್ಸರ್‌ಫ್ಲೋ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ . ಕೆಲಸ ಮಾಡುತ್ತದೆ.
- ನಾನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಬಯಸುತ್ತೇನೆ ಮತ್ತು ಸಹಾಯ ಮಾಡಲು ಸಂತೋಷಪಡುತ್ತೇನೆ
ಮೂಲ: www.habr.com