ಪರಿವಿಡಿ[ಮರೆಮಾಡಿ][ತೋರಿಸಿ]
ಮೆದುಳನ್ನು ನರಮಂಡಲಕ್ಕೆ ಹೋಲಿಸಬಹುದು. ಯಂತ್ರ ಕಲಿಕೆ ಮತ್ತು ಕೃತಕ ನರಮಂಡಲದ ಹಿಂದಿನ ವಿಚಾರಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ವಿಷಯಕ್ಕೆ ಹೊಸಬರಿಗೆ ಸಹಾಯ ಮಾಡಲು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಸಾದೃಶ್ಯ ಇದಾಗಿದೆ.
ತೆರೆಮರೆಯಲ್ಲಿ ಗಣಿತ ಮತ್ತು ಸಂಖ್ಯಾಶಾಸ್ತ್ರದ ಲೆಕ್ಕಾಚಾರಗಳ ಹಲವಾರು ಪದರಗಳು ನಡೆಯುತ್ತಿರುವುದರಿಂದ, ಈ ಜಾಲಗಳನ್ನು ಗಣಿತದ ಕಾರ್ಯವೆಂದು ವ್ಯಾಖ್ಯಾನಿಸುವುದು ಹೆಚ್ಚು ಮುಂದುವರಿದ ವಿಧಾನವಾಗಿದೆ.
ಯಂತ್ರ ಕಲಿಕೆಯಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಆಸಕ್ತಿ ಹೊಂದಿರುವ ಮತ್ತು ಪೈಥಾನ್ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಕೋಡ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಬಯಸುವ ಜನರಿಗೆ ಇದು.
ಈ ಲೇಖನದಲ್ಲಿ, ಮೊದಲಿನಿಂದಲೂ ಸಂಪೂರ್ಣ ಸಂಪರ್ಕಿತ ಆಳವಾದ ನರಮಂಡಲವನ್ನು (DNN) ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ. ಪೈಥಾನ್ 3.
ನಮ್ಮ ಪೈಥಾನ್ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಕೋಡ್ಗಾಗಿ ಫೈಲ್ ರಚನೆಯ ಅವಲೋಕನ
ಇಲ್ಲಿ ಮೂರು ಫೈಲ್ಗಳನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಮೊದಲನೆಯದು ಸರಳವಾದ nn.py ಫೈಲ್ ಆಗಿದೆ, ಇದನ್ನು "ಸಹಾಯಕ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿಸುವುದು" ಮತ್ತು "ಮೊದಲಿನಿಂದ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು" ನಲ್ಲಿ ಚರ್ಚಿಸಲಾಗುವುದು.
"MNIST ಡೇಟಾ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ" ನಲ್ಲಿ ವಿವರಿಸಿದಂತೆ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲು mnist loader.py ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ಸಹ ನಾವು ಹೊಂದಿದ್ದೇವೆ.
ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗುವ test.py ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ.
ಈ ಫೈಲ್ ಅನ್ನು "ಚಾಲನೆಯಲ್ಲಿರುವ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ" ವಿವರವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ.
ಅನುಸ್ಥಾಪನ
ಈ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಅನುಸರಿಸಲು NumPy ಪೈಥಾನ್ ಲೈಬ್ರರಿಯನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಬೇಕು. ಟರ್ಮಿನಲ್ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಇದನ್ನು ಸಾಧಿಸಬಹುದು:
ಮಾಡ್ಯೂಲ್ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಸಹಾಯಕ ಕಾರ್ಯವನ್ನು ಹೊಂದಿಸುವುದು
ನಮಗೆ ಅಗತ್ಯವಿರುವ ಎರಡು ಲೈಬ್ರರಿಗಳು ಯಾದೃಚ್ಛಿಕ ಮತ್ತು NumPy, ನಾವು ಈಗಿನಿಂದಲೇ ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ. ನಮ್ಮ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ನ ಆರಂಭಿಕ ತೂಕಗಳಿಗಾಗಿ, ನಾವು ಯಾದೃಚ್ಛಿಕ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳನ್ನು ಷಫಲ್ ಮಾಡುತ್ತೇವೆ.
ನಮ್ಮ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ವೇಗಗೊಳಿಸಲು, ನಾವು NumPy ಅಥವಾ np ಅನ್ನು ಬಳಸುತ್ತೇವೆ (ಸಂಪ್ರದಾಯದಿಂದ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ np ಎಂದು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ). ನಮ್ಮ ಆಮದು ಮಾಡಿದ ನಂತರ ನಮ್ಮ ಎರಡು ಸಹಾಯಕ ಕಾರ್ಯಗಳನ್ನು ಮಾಡಲಾಗುವುದು. ಎರಡು ಸಿಗ್ಮೋಯ್ಡ್ ಕಾರ್ಯಗಳು: ಒಂದು ಮತ್ತು ಸಿಗ್ಮೋಯ್ಡ್ ಅವಿಭಾಜ್ಯ.
ಲಾಜಿಸ್ಟಿಕ್ ರಿಗ್ರೆಷನ್ ಸಿಗ್ಮೋಯ್ಡ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡೇಟಾವನ್ನು ವರ್ಗೀಕರಿಸುತ್ತದೆ, ಆದರೆ ಬ್ಯಾಕ್ಪ್ರೊಪಾಗೇಶನ್ ಸಿಗ್ಮೋಯ್ಡ್ ಪ್ರೈಮ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡೆಲ್ಟಾ ಅಥವಾ ಗ್ರೇಡಿಯಂಟ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.
ನೆಟ್ವರ್ಕ್ ವರ್ಗವನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ
ಸಂಪೂರ್ಣ ಲಿಂಕ್ ಮಾಡಲಾದ ನರಮಂಡಲವನ್ನು ನಿರ್ಮಿಸುವುದು ಈ ವಿಭಾಗದ ಏಕೈಕ ಕೇಂದ್ರವಾಗಿದೆ. ನೆಟ್ವರ್ಕ್ ವರ್ಗವು ನಂತರ ಬರುವ ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತದೆ. ಆಬ್ಜೆಕ್ಟ್() { [ಸ್ಥಳೀಯ ಕೋಡ್] } ಕಾರ್ಯವನ್ನು ನಮ್ಮ ನೆಟ್ವರ್ಕ್ ವರ್ಗದಲ್ಲಿ ಆರಂಭದಲ್ಲಿ ರಚಿಸಲಾಗುತ್ತದೆ.
ಆಬ್ಜೆಕ್ಟ್() { [ಸ್ಥಳೀಯ ಕೋಡ್] } ಕಾರ್ಯಕ್ಕೆ ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್, ಗಾತ್ರಗಳು ಅಗತ್ಯವಿದೆ. ಗಾತ್ರಗಳ ವೇರಿಯೇಬಲ್ ನಮ್ಮ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ನ ಪ್ರತಿ ಲೇಯರ್ನಲ್ಲಿರುವ ಇನ್ಪುಟ್ ನೋಡ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳ ಸಂಗ್ರಹವಾಗಿದೆ.
ನಮ್ಮ __init__ ವಿಧಾನದಲ್ಲಿ ನಾವು ನಾಲ್ಕು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ. ಇನ್ಪುಟ್ ವೇರಿಯೇಬಲ್ಗಳು, ಗಾತ್ರಗಳು, ಕ್ರಮವಾಗಿ ಲೇಯರ್ ಗಾತ್ರಗಳ ಪಟ್ಟಿ ಮತ್ತು ಲೇಯರ್ಗಳ ಸಂಖ್ಯೆ, ಸಂಖ್ಯೆ ಲೇಯರ್ಗಳನ್ನು ಹೊಂದಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಇನ್ಪುಟ್ ಲೇಯರ್ ಅನ್ನು ಅನುಸರಿಸುವ ಪ್ರತಿಯೊಂದು ಲೇಯರ್ಗೆ ನಮ್ಮ ನೆಟ್ವರ್ಕ್ನ ಆರಂಭಿಕ ಪಕ್ಷಪಾತಗಳನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ನಿಯೋಜಿಸುವುದು ಮೊದಲ ಹಂತವಾಗಿದೆ.
ಅಂತಿಮವಾಗಿ, ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಲೇಯರ್ಗಳ ನಡುವಿನ ಪ್ರತಿಯೊಂದು ಲಿಂಕ್ ಅದರ ತೂಕವನ್ನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತದೆ. Np.Random.Randn() ಸಂದರ್ಭಕ್ಕಾಗಿ ಸಾಮಾನ್ಯ ವಿತರಣೆಯಿಂದ ಪಡೆದ ಯಾದೃಚ್ಛಿಕ ಮಾದರಿಯನ್ನು ನೀಡುತ್ತದೆ.
ಫೀಡ್ ಫಾರ್ವರ್ಡ್ ಫಂಕ್ಷನ್
ನರಮಂಡಲದಲ್ಲಿ, ಫೀಡ್ಫಾರ್ವರ್ಡ್ ಕಾರ್ಯದಿಂದ ಮಾಹಿತಿಯನ್ನು ಕಳುಹಿಸಲಾಗುತ್ತದೆ. ಪ್ರಸ್ತುತ ಸಕ್ರಿಯಗೊಳಿಸುವ ವೆಕ್ಟರ್ ಅನ್ನು ಸೂಚಿಸುವ ಒಂದು ಆರ್ಗ್ಯುಮೆಂಟ್, ಈ ಕಾರ್ಯದಿಂದ ಅಗತ್ಯವಿರುತ್ತದೆ.
ಈ ಕಾರ್ಯವು ನೆಟ್ವರ್ಕ್ನಲ್ಲಿನ ಎಲ್ಲಾ ಪಕ್ಷಪಾತಗಳು ಮತ್ತು ತೂಕಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಮೂಲಕ ಪ್ರತಿ ಪದರದಲ್ಲಿನ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಗಳನ್ನು ಅಂದಾಜು ಮಾಡುತ್ತದೆ. ನೀಡಲಾದ ಉತ್ತರವು ಮುನ್ಸೂಚನೆಯಾಗಿದೆ, ಇದು ಕೊನೆಯ ಪದರದ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಯಾಗಿದೆ.
ಮಿನಿ-ಬ್ಯಾಚ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್
ನಮ್ಮ ನೆಟ್ವರ್ಕ್ ವರ್ಗದ ವರ್ಕ್ಹಾರ್ಸ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಆಗಿದೆ. ಈ ಆವೃತ್ತಿಯಲ್ಲಿ, ನಾವು ಮಿನಿ-ಬ್ಯಾಚ್ (ಸ್ಟೊಕಾಸ್ಟಿಕ್) ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಗ್ರೇಡಿಯಂಟ್ ಮೂಲದ ಮಾರ್ಪಡಿಸಿದ ಬದಲಾವಣೆ.
ನಮ್ಮ ಮಾದರಿಯನ್ನು ನವೀಕರಿಸಲು ಡೇಟಾ ಪಾಯಿಂಟ್ಗಳ ಸಣ್ಣ ಬ್ಯಾಚ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ಈ ವಿಧಾನಕ್ಕೆ ಅಗತ್ಯವಿರುವ ನಾಲ್ಕು ಮತ್ತು ಒಂದು ಐಚ್ಛಿಕ ವಾದವನ್ನು ರವಾನಿಸಲಾಗಿದೆ. ಅಗತ್ಯವಿರುವ ನಾಲ್ಕು ಅಸ್ಥಿರಗಳೆಂದರೆ ತರಬೇತಿ ಡೇಟಾ ಸೆಟ್, ಯುಗಗಳ ಸಂಖ್ಯೆ, ಮಿನಿ-ಬ್ಯಾಚ್ಗಳ ಗಾತ್ರ ಮತ್ತು ಕಲಿಕೆಯ ದರ (ಇಟಾ).
ವಿನಂತಿಯ ಮೇರೆಗೆ ಪರೀಕ್ಷಾ ಡೇಟಾ ಲಭ್ಯವಿದೆ. ನಾವು ಅಂತಿಮವಾಗಿ ಈ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿದಾಗ ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಪೂರೈಸುತ್ತೇವೆ. ತರಬೇತಿ ಡೇಟಾವನ್ನು ಪಟ್ಟಿಯ ಪ್ರಕಾರವಾಗಿ ಪರಿವರ್ತಿಸಿದ ನಂತರ ಈ ಕಾರ್ಯದಲ್ಲಿನ ಮಾದರಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆರಂಭದಲ್ಲಿ ಪಟ್ಟಿಯ ಉದ್ದಕ್ಕೆ ಹೊಂದಿಸಲಾಗಿದೆ.
ನೀಡಲಾದ ಡೇಟಾವನ್ನು ಪರೀಕ್ಷಿಸಲು ನಾವು ಅದೇ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಅನ್ವಯಿಸುತ್ತೇವೆ. ಏಕೆಂದರೆ ನಮಗೆ ಪಟ್ಟಿಗಳಾಗಿ ಹಿಂತಿರುಗಿಸುವ ಬದಲು, ಅವು ನಿಜವಾಗಿಯೂ ಪಟ್ಟಿಗಳ ಜಿಪ್ಗಳಾಗಿವೆ. ನಾವು ನಂತರ MNIST ಡೇಟಾ ಮಾದರಿಗಳನ್ನು ಲೋಡ್ ಮಾಡಿದಾಗ, ನಾವು ಇದರ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳುತ್ತೇವೆ.
ನಾವು ಎರಡೂ ರೀತಿಯ ಡೇಟಾವನ್ನು ಪಟ್ಟಿಗಳಾಗಿ ಒದಗಿಸುತ್ತೇವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಂಡರೆ, ಈ ಪ್ರಕಾರದ ಬಿತ್ತರಿಸುವುದು ಅಗತ್ಯವಾಗಿ ಅಗತ್ಯವಿಲ್ಲ.
ಒಮ್ಮೆ ನಾವು ಡೇಟಾವನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾವು ಲೂಪ್ನಲ್ಲಿ ತರಬೇತಿ ಯುಗಗಳ ಮೇಲೆ ಹೋಗುತ್ತೇವೆ. ತರಬೇತಿ ಅವಧಿಯು ಕೇವಲ ಒಂದು ಸುತ್ತಿನ ನರ ನೆಟ್ವರ್ಕ್ ತರಬೇತಿಯಾಗಿದೆ. ಮಿನಿ-ಬ್ಯಾಚ್ಗಳ ಪಟ್ಟಿಯನ್ನು ಮಾಡುವ ಮೊದಲು ಯಾದೃಚ್ಛಿಕತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಮೊದಲು ಪ್ರತಿ ಯುಗದಲ್ಲಿನ ಡೇಟಾವನ್ನು ಷಫಲ್ ಮಾಡುತ್ತೇವೆ.
ಅಪ್ಡೇಟ್ ಮಿನಿ ಬ್ಯಾಚ್ ಫಂಕ್ಷನ್ ಅನ್ನು ಕೆಳಗೆ ಚರ್ಚಿಸಲಾಗಿದೆ, ಪ್ರತಿ ಮಿನಿ ಬ್ಯಾಚ್ಗೆ ಕರೆಯಲಾಗುವುದು. ಪರೀಕ್ಷಾ ಡೇಟಾ ಲಭ್ಯವಿದ್ದರೆ ಪರೀಕ್ಷಾ ನಿಖರತೆಯನ್ನು ಸಹ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
ವೆಚ್ಚ-ಉತ್ಪನ್ನ ಸಹಾಯಕ ಕಾರ್ಯ
ನಾವು ನಿಜವಾಗಿಯೂ ಬ್ಯಾಕ್ಪ್ರೊಪಗೇಶನ್ ಕೋಡ್ ಅನ್ನು ರಚಿಸುವ ಮೊದಲು ವೆಚ್ಚದ ಉತ್ಪನ್ನ ಎಂಬ ಸಹಾಯಕ ಕಾರ್ಯವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸೋಣ. ನಮ್ಮ ಔಟ್ಪುಟ್ ಲೇಯರ್ನಲ್ಲಿ ನಾವು ತಪ್ಪು ಮಾಡಿದರೆ, ವೆಚ್ಚದ ಉತ್ಪನ್ನ ಕಾರ್ಯವು ಅದನ್ನು ತೋರಿಸುತ್ತದೆ.
ಇದಕ್ಕೆ ಎರಡು ಇನ್ಪುಟ್ಗಳ ಅಗತ್ಯವಿದೆ: ಔಟ್ಪುಟ್ ಆಕ್ಟಿವೇಶನ್ಗಳ ಅರೇ ಮತ್ತು ನಿರೀಕ್ಷಿತ ಔಟ್ಪುಟ್ ಮೌಲ್ಯಗಳ y-ನಿರ್ದೇಶಾಂಕಗಳು.
ಬ್ಯಾಕ್ಪ್ರೊಪಾಗೇಷನ್ ಕಾರ್ಯ
ನಮ್ಮ ಪ್ರಸ್ತುತ ಸಕ್ರಿಯಗೊಳಿಸುವ ವೆಕ್ಟರ್, ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆ, ಹಾಗೆಯೇ ಯಾವುದೇ ಇತರ ಸಕ್ರಿಯಗೊಳಿಸುವ ವೆಕ್ಟರ್ಗಳು, ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಗಳು ಮತ್ತು z-ವೆಕ್ಟರ್ಗಳು, zs, ಎಲ್ಲವನ್ನೂ ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕು. ಇನ್ಪುಟ್ ಲೇಯರ್ ಎಂಬ ಲೇಯರ್ ಅನ್ನು ಮೊದಲು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಅವುಗಳನ್ನು ಹಾಕುವ ನಂತರ ನಾವು ಪ್ರತಿ ಪಕ್ಷಪಾತ ಮತ್ತು ತೂಕದ ಮೂಲಕ ಲೂಪ್ ಮಾಡುತ್ತೇವೆ. ಪ್ರತಿ ಲೂಪ್ z ವೆಕ್ಟರ್ ಅನ್ನು ತೂಕ ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಯ ಡಾಟ್ ಉತ್ಪನ್ನವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು, ಅದನ್ನು zs ಪಟ್ಟಿಗೆ ಸೇರಿಸುವುದು, ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಯನ್ನು ಮರು ಲೆಕ್ಕಾಚಾರ ಮಾಡುವುದು ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಗಳ ಪಟ್ಟಿಗೆ ನವೀಕರಿಸಿದ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಯನ್ನು ಸೇರಿಸುವುದು ಒಳಗೊಂಡಿರುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ಗಣಿತ. zs ವೆಕ್ಟರ್ಗಳ ಕೊನೆಯ ಅಂಶದ ಸಿಗ್ಮೋಯ್ಡ್ ಅವಿಭಾಜ್ಯದಿಂದ ಗುಣಿಸಿದ ಹಿಂದಿನ ಪದರದ ದೋಷಕ್ಕೆ ಸಮಾನವಾದ ಡೆಲ್ಟಾವನ್ನು ನಾವು ನಮ್ಮ ಹಿಂದುಳಿದ ಪಾಸ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲಾಗುತ್ತದೆ.
Nabla b ಯ ಕೊನೆಯ ಪದರವನ್ನು ಡೆಲ್ಟಾ ಎಂದು ಹೊಂದಿಸಲಾಗಿದೆ, ಮತ್ತು nabla w ನ ಅಂತಿಮ ಪದರವನ್ನು ಡೆಲ್ಟಾದ ಡಾಟ್ ಉತ್ಪನ್ನವಾಗಿ ಮತ್ತು ಎರಡನೆಯಿಂದ ಕೊನೆಯ ಹಂತದ ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆಗೆ ಹೊಂದಿಸಲಾಗಿದೆ (ಪರಿವರ್ತನೆ ಮಾಡುವುದರಿಂದ ನಾವು ಗಣಿತವನ್ನು ಮಾಡಬಹುದು) .
ನಾವು ಮೊದಲಿನಂತೆಯೇ ಮುಂದುವರಿಯುತ್ತೇವೆ, ಎರಡನೆಯ ಪದರದಿಂದ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ಕೊನೆಯದರೊಂದಿಗೆ ಮುಕ್ತಾಯಗೊಳಿಸುತ್ತೇವೆ ಮತ್ತು ಈ ಕೊನೆಯ ಪದರಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾವರ್ತಿಸಿ. ನಂತರ ನಬ್ಲಾಗಳನ್ನು ಟುಪಲ್ ಆಗಿ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
ಮಿನಿ-ಬ್ಯಾಚ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಅನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ
ಮೊದಲಿನಿಂದಲೂ ನಮ್ಮ SGD (ಸ್ಟೋಕಾಸ್ಟಿಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್) ವಿಧಾನವು ಮಿನಿ-ಬ್ಯಾಚ್ ಅಪ್ಡೇಟಿಂಗ್ ಅನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ. ಇದು SGD ಯಲ್ಲಿ ಬಳಸಲ್ಪಟ್ಟಿದೆ ಆದರೆ ಬ್ಯಾಕ್ಪ್ರಾಪ್ನ ಅಗತ್ಯವಿರುವುದರಿಂದ, ಈ ಕಾರ್ಯವನ್ನು ಎಲ್ಲಿ ಹಾಕಬೇಕೆಂದು ನಾನು ಚರ್ಚಿಸಿದೆ.
ಅಂತಿಮವಾಗಿ, ನಾನು ಅದನ್ನು ಇಲ್ಲಿ ಪೋಸ್ಟ್ ಮಾಡಲು ಆಯ್ಕೆ ಮಾಡಿದೆ. ಇದು ನಮ್ಮ ಬ್ಯಾಕ್ಪ್ರಾಪ್ ಕಾರ್ಯದಂತೆಯೇ ಪಕ್ಷಪಾತಗಳು ಮತ್ತು ತೂಕದ ನಬ್ಲಾಗಳ 0 ವೆಕ್ಟರ್ಗಳನ್ನು ಉತ್ಪಾದಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
ಇದಕ್ಕೆ ಮಿನಿ-ಬ್ಯಾಚ್ ಮತ್ತು ಎಟಾ ಕಲಿಕೆ ದರವು ಅದರ ಎರಡು ಇನ್ಪುಟ್ಗಳ ಅಗತ್ಯವಿದೆ. ಮಿನಿ-ಬ್ಯಾಚ್ನಲ್ಲಿ, ಪ್ರತಿ ಇನ್ಪುಟ್, x ಮತ್ತು ಔಟ್ಪುಟ್, y ಗೆ ಪ್ರತಿ ನಾಬ್ಲಾ ರಚನೆಯ ಡೆಲ್ಟಾವನ್ನು ಪಡೆಯಲು ನಾವು ಬ್ಯಾಕ್ಪ್ರಾಪ್ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ನಬ್ಲಾ ಪಟ್ಟಿಗಳನ್ನು ನಂತರ ಈ ಡೆಲ್ಟಾಗಳೊಂದಿಗೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ನಾವು ನೆಟ್ವರ್ಕ್ನ ತೂಕ ಮತ್ತು ಪಕ್ಷಪಾತಗಳನ್ನು ನವೀಕರಿಸಲು ಕಲಿಕೆಯ ದರ ಮತ್ತು ನಬ್ಲಾಸ್ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಪ್ರತಿಯೊಂದು ಮೌಲ್ಯವನ್ನು ಇತ್ತೀಚಿನ ಮೌಲ್ಯಕ್ಕೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ, ಕಡಿಮೆ ಕಲಿಕೆಯ ದರ, ಮಿನಿಬ್ಯಾಚ್ ಗಾತ್ರದಿಂದ ಗುಣಿಸಿ ಮತ್ತು ನಂತರ ನಬ್ಲಾ ಮೌಲ್ಯಕ್ಕೆ ಸೇರಿಸಲಾಗುತ್ತದೆ.
ಕಾರ್ಯವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ
ಮೌಲ್ಯಮಾಪನ ಕಾರ್ಯವು ನಾವು ಬರೆಯಬೇಕಾದ ಅಂತಿಮವಾಗಿದೆ. ಈ ಕಾರ್ಯಕ್ಕಾಗಿ ಪರೀಕ್ಷಾ ಡೇಟಾ ಮಾತ್ರ ಇನ್ಪುಟ್ ಆಗಿದೆ. ಈ ಕಾರ್ಯದಲ್ಲಿ, ನಾವು ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶದೊಂದಿಗೆ ನೆಟ್ವರ್ಕ್ನ ಔಟ್ಪುಟ್ಗಳನ್ನು ಮಾತ್ರ ಹೋಲಿಸುತ್ತೇವೆ, y. ಇನ್ಪುಟ್, x, ಫಾರ್ವರ್ಡ್ ಅನ್ನು ಪೋಷಿಸುವ ಮೂಲಕ, ನೆಟ್ವರ್ಕ್ನ ಔಟ್ಪುಟ್ಗಳನ್ನು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.
ಸಂಪೂರ್ಣ ಕೋಡ್
ನಾವು ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಸಂಯೋಜಿಸಿದಾಗ, ಅದು ಹೇಗೆ ಕಾಣುತ್ತದೆ.
ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
MNIST ಡೇಟಾವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ನಮ್ಮ MNIST ಡೇಟಾ .pkl.gz ಫಾರ್ಮ್ಯಾಟ್ನಲ್ಲಿದೆ, ಅದನ್ನು ನಾವು GZIP ಬಳಸಿ ತೆರೆಯುತ್ತೇವೆ ಮತ್ತು ಉಪ್ಪಿನಕಾಯಿಯೊಂದಿಗೆ ಲೋಡ್ ಮಾಡುತ್ತೇವೆ. ಈ ಡೇಟಾವನ್ನು ಮೂರು ಗಾತ್ರದ ಟ್ಯೂಪಲ್ ಆಗಿ ಲೋಡ್ ಮಾಡಲು ತ್ವರಿತ ವಿಧಾನವನ್ನು ಬರೆಯೋಣ, ತರಬೇತಿ, ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ ಎಂದು ವಿಂಗಡಿಸಲಾಗಿದೆ.
ನಮ್ಮ ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಲು, y ಅನ್ನು 10-ಐಟಂ ಅರೇಗೆ ಎನ್ಕೋಡ್ ಮಾಡಲು ನಾವು ಇನ್ನೊಂದು ಕಾರ್ಯವನ್ನು ಬರೆಯುತ್ತೇವೆ. ಚಿತ್ರದ ಸರಿಯಾದ ಅಂಕೆಯೊಂದಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ 0 ಅನ್ನು ಹೊರತುಪಡಿಸಿ ಸರಣಿಯು ಎಲ್ಲಾ 1s ಆಗಿರುತ್ತದೆ.
ನಮ್ಮ ಡೇಟಾವನ್ನು ಓದಬಲ್ಲ ಫಾರ್ಮ್ಯಾಟ್ಗೆ ಲೋಡ್ ಮಾಡಲು ನಾವು ಮೂಲಭೂತ ಲೋಡ್ ಡೇಟಾ ಮತ್ತು ಒಂದು ಹಾಟ್ ಎನ್ಕೋಡ್ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತೇವೆ. ಮತ್ತೊಂದು ಕಾರ್ಯವನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ ಅದು ನಮ್ಮ x ಮೌಲ್ಯಗಳನ್ನು ಗಾತ್ರ 784 ಪಟ್ಟಿಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಚಿತ್ರದ 784 ಪಿಕ್ಸೆಲ್ಗಳಿಗೆ ಹೊಂದಾಣಿಕೆಯಾಗುತ್ತದೆ ಮತ್ತು ನಮ್ಮ y ಮೌಲ್ಯಗಳನ್ನು ಅವುಗಳ ಏಕ ಬಿಸಿ ಎನ್ಕೋಡ್ ವೆಕ್ಟರ್ ರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ.
ನಂತರ ನಾವು x ಮತ್ತು y ಮೌಲ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತೇವೆ ಅಂದರೆ ಒಂದು ಸೂಚ್ಯಂಕವು ಇನ್ನೊಂದಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ. ಇದು ತರಬೇತಿ, ಮೌಲ್ಯೀಕರಣ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ ಸೆಟ್ಗಳಿಗೆ ಅನ್ವಯಿಸುತ್ತದೆ. ನಂತರ ನಾವು ಬದಲಾದ ಡೇಟಾವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತೇವೆ.
ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸುವುದು
ನಾವು "mnist ಲೋಡರ್" ಎಂಬ ಹೊಸ ಫೈಲ್ ಅನ್ನು ತಯಾರಿಸುತ್ತೇವೆ ಅದು ನಾವು ಈ ಹಿಂದೆ ಸ್ಥಾಪಿಸಿದ ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ (ಸರಳ nn) ಮತ್ತು MNIST ಡೇಟಾ ಸೆಟ್ ಲೋಡರ್ ಎರಡನ್ನೂ ನಾವು ಪರೀಕ್ಷೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ.
ಈ ಫೈಲ್ನಲ್ಲಿ, ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಡೇಟಾವನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು, 784 ರ ಇನ್ಪುಟ್ ಲೇಯರ್ ಗಾತ್ರ ಮತ್ತು 10 ರ ಔಟ್ಪುಟ್ ಲೇಯರ್ ಗಾತ್ರದೊಂದಿಗೆ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು, ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ನೆಟ್ವರ್ಕ್ನ SGD ಕಾರ್ಯವನ್ನು ರನ್ ಮಾಡಿ, ನಂತರ ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ಅದನ್ನು ಪರೀಕ್ಷಿಸಿ.
ನಮ್ಮ ಇನ್ಪುಟ್ ಲೇಯರ್ಗಳ ಪಟ್ಟಿಗೆ, 784 ಮತ್ತು 10 ರ ನಡುವೆ ಇರುವ ಯಾವುದೇ ಸಂಖ್ಯೆಗಳಲ್ಲಿ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ನಾವು ಇತರ ಲೇಯರ್ಗಳನ್ನು ನಾವು ಇಷ್ಟಪಡುವ ರೀತಿಯಲ್ಲಿ ಬದಲಾಯಿಸಬಹುದು; ಕೇವಲ ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಗಾತ್ರಗಳನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.
ಮೂರು ಪದರಗಳು ಅಗತ್ಯವಿಲ್ಲ; ನಾವು ನಾಲ್ಕು, ಐದು, ಅಥವಾ ಕೇವಲ ಎರಡು ಬಳಸಬಹುದು. ಅದರ ಪ್ರಯೋಗವನ್ನು ಆನಂದಿಸಿ.
ತೀರ್ಮಾನ
ಇಲ್ಲಿ, ಪೈಥಾನ್ 3 ಅನ್ನು ಬಳಸಿ, ನಾವು ಮೊದಲಿನಿಂದ ನರಮಂಡಲವನ್ನು ರಚಿಸುತ್ತೇವೆ. ಉನ್ನತ ಮಟ್ಟದ ಗಣಿತದ ಜೊತೆಗೆ, ನಾವು ಅನುಷ್ಠಾನದ ನಿಶ್ಚಿತಗಳನ್ನು ಸಹ ಚರ್ಚಿಸಿದ್ದೇವೆ.
ನಾವು ಸಹಾಯಕ ಕಾರ್ಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ. ನರಕೋಶಗಳು ಕೆಲಸ ಮಾಡಲು, ಸಿಗ್ಮೋಯ್ಡ್ ಮತ್ತು ಸಿಗ್ಮೋಯ್ಡ್ ಅವಿಭಾಜ್ಯ ಕಾರ್ಯಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ. ನಂತರ ನಾವು ಫೀಡ್ಫಾರ್ವರ್ಡ್ ಕಾರ್ಯವನ್ನು ಆಚರಣೆಗೆ ತರುತ್ತೇವೆ, ಇದು ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ಗೆ ಡೇಟಾವನ್ನು ಫೀಡ್ ಮಾಡುವ ಮೂಲಭೂತ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ.
ಮುಂದೆ, ನಾವು ಪೈಥಾನ್ನಲ್ಲಿ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಇದು ನಮ್ಮ ನರಮಂಡಲವನ್ನು ಚಾಲನೆ ಮಾಡುವ ಎಂಜಿನ್. "ಸ್ಥಳೀಯ ಮಿನಿಮಾ" ಅನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಅವುಗಳ ತೂಕ ಮತ್ತು ಪಕ್ಷಪಾತಗಳನ್ನು ಅತ್ಯುತ್ತಮವಾಗಿಸಲು, ನಮ್ಮ ನರಮಂಡಲದ ನೆಟ್ವರ್ಕ್ ಗ್ರೇಡಿಯಂಟ್ ಡಿಸೆಂಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ನಾವು ಬಳಸಿ ಬ್ಯಾಕ್ಪ್ರೊಪಾಗೇಷನ್ ಕಾರ್ಯವನ್ನು ರಚಿಸಿದ್ದೇವೆ ಗ್ರೇಡಿಯಂಟ್ ಅವರೋಹಣ.
ಔಟ್ಪುಟ್ಗಳು ಸರಿಯಾದ ಲೇಬಲ್ಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗದಿದ್ದಾಗ ನವೀಕರಣಗಳನ್ನು ತಲುಪಿಸುವ ಮೂಲಕ, ಈ ಕಾರ್ಯವು "ಕಲಿಯಲು" ನರಮಂಡಲವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ನಾವು ನಮ್ಮ ಹೊಚ್ಚಹೊಸ ಪೈಥಾನ್ ಅನ್ನು ಇರಿಸಿದ್ದೇವೆ ನರಮಂಡಲ MNIST ಡೇಟಾ ಸೆಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪರೀಕ್ಷೆಗೆ. ಎಲ್ಲವೂ ಸುಗಮವಾಗಿ ಕಾರ್ಯ ನಿರ್ವಹಿಸಿದವು.
ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ