TensorFlow ಯಂತ್ರ-ಕಲಿಕೆ ಮಾದರಿಗಳನ್ನು ರಚಿಸಲು ಬಹುಮುಖ ಸಾಧನವಾಗಿದೆ.
ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ, ಓಪನ್ ಸೋರ್ಸ್ ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ಫ್ರೇಮ್ವರ್ಕ್ ಆಗಿರುವ ಟೆನ್ಸರ್ಫ್ಲೋ ಮೂಲಕ ಮುಖ ಗುರುತಿಸುವಿಕೆ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ. ಒಂದು ಯಶಸ್ವಿ ಮುಖ ಗುರುತಿಸುವಿಕೆ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವಲ್ಲಿ ನಾವು ಅಗತ್ಯ ಪ್ರಕ್ರಿಯೆಗಳ ಮೇಲೆ ಹೋಗುತ್ತೇವೆ, ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವುದು ಮತ್ತು ಸಿದ್ಧಪಡಿಸುವುದು ಮತ್ತು ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುವುದು ಮತ್ತು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು.
ಕೋಡ್ ತುಣುಕುಗಳು ಮತ್ತು ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳ ಸಹಾಯದಿಂದ ಮುಖದ ಗುರುತಿಸುವಿಕೆಯನ್ನು ರಚಿಸಲು ನೀವು TensorFlow ನೊಂದಿಗೆ ಮೊದಲ-ಕೈ ಅನುಭವವನ್ನು ಪಡೆಯುತ್ತೀರಿ. ನಾವು ಮುಂದುವರಿದಂತೆ ಅನುಸರಿಸಲು ನಿಮಗೆ ಸ್ವಾಗತ.
ಟೆನ್ಸರ್ ಫ್ಲೋಗೆ ಪರಿಚಯ
TensorFlow ಒಂದು ಉಚಿತ ಮತ್ತು ಮುಕ್ತ-ಮೂಲ ಗ್ರಂಥಾಲಯವಾಗಿದೆ. ಇದು ಸಾಂಕೇತಿಕ ಗಣಿತ ಟೂಲ್ಬಾಕ್ಸ್ ಆಗಿದ್ದು ಅದು ಡೇಟಾ ಫ್ಲೋ ಮತ್ತು ಡಿಫರೆನ್ಸಬಲ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಆಳವಾದ ಸೇರಿದಂತೆ ನೀವು ಅದರೊಂದಿಗೆ ಹಲವಾರು ಕಾರ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಬಹುದು ನರಮಂಡಲ ತರಬೇತಿ.
TensorFlow ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳಬಲ್ಲದು. ಅಂತೆಯೇ, ಇದು ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಉತ್ತಮ ಸಾಧನವಾಗಿದೆ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸುವುದು. ನೀವು ಹಲವಾರು ಲೇಯರ್ಗಳು ಮತ್ತು ಟೆನ್ಸರ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಸಂಕೀರ್ಣ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು. ಅಲ್ಲದೆ, ಲೈಬ್ರರಿಯಲ್ಲಿ ಪೂರ್ವ-ನಿರ್ಮಿತ ಮಾದರಿಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗಾಗಿ ಉತ್ತಮವಾಗಿ-ಟ್ಯೂನ್ ಮಾಡಬಹುದು.
ಇದಲ್ಲದೆ, TensorFlow ಒಂದು ದೊಡ್ಡ ಮತ್ತು ವಿಸ್ತರಿಸುತ್ತಿರುವ ಬಳಕೆದಾರ ಸಮುದಾಯವನ್ನು ಹೊಂದಿದೆ. ಆದ್ದರಿಂದ, ಪ್ಲಾಟ್ಫಾರ್ಮ್ಗೆ ಹೊಸದಾಗಿರುವ ವ್ಯಕ್ತಿಗಳಿಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿ ಮತ್ತು ಸಹಾಯವಿದೆ.
TensorFlow ಜನಪ್ರಿಯವಾಗಿದೆ ಯಂತ್ರ ಕಲಿಕೆ ಭಾಗಶಃ ಏಕೆಂದರೆ ಇದು ಅಂತ್ಯದಿಂದ ಅಂತ್ಯದ ಕೆಲಸದ ಹರಿವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ನೀವು ಸುಲಭವಾಗಿ ಮಾದರಿಗಳನ್ನು ನಿರ್ಮಿಸಬಹುದು, ತರಬೇತಿ ಮಾಡಬಹುದು ಮತ್ತು ನಿಯೋಜಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟ ಬೇಡಿಕೆಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಮಾದರಿಗಳನ್ನು ಸುಧಾರಿಸಲು ಮತ್ತು ಸ್ಕೇಲಿಂಗ್ ಮಾಡಲು ಇದು ಉಪಕರಣಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ. ಇದು ಡೇಟಾ ಪೂರ್ವ-ಸಂಸ್ಕರಣೆಯಿಂದ ಮಾದರಿ ನಿಯೋಜನೆಗೆ ಬದಲಾಗುತ್ತದೆ.
ಮುಖ ಗುರುತಿಸುವಿಕೆ ಎಂದರೇನು?
ಮುಖ ಗುರುತಿಸುವಿಕೆ ಎ ಕಂಪ್ಯೂಟರ್ ದೃಷ್ಟಿ ವ್ಯಕ್ತಿಯ ಮುಖದ ಆಧಾರದ ಮೇಲೆ ಅವರ ಗುರುತನ್ನು ಗುರುತಿಸುವ ಕಾರ್ಯ. ಈ ತಂತ್ರವು ಕಣ್ಣುಗಳು, ಮೂಗು ಮತ್ತು ಬಾಯಿಯ ಆಕಾರ ಮತ್ತು ವಿನ್ಯಾಸದಂತಹ ಮುಖದ ಲಕ್ಷಣಗಳನ್ನು ಗುರುತಿಸುತ್ತದೆ.
ಮತ್ತು, ಇದು ಹೊಂದಾಣಿಕೆಯನ್ನು ಗುರುತಿಸಲು ತಿಳಿದಿರುವ ಮುಖಗಳ ಡೇಟಾಬೇಸ್ಗೆ ಹೋಲಿಸುತ್ತದೆ. ಮುಖ ಗುರುತಿಸುವಿಕೆಯು ಭದ್ರತಾ ವ್ಯವಸ್ಥೆಗಳು, ಫೋಟೋ ಸಂಘಟನೆ ಮತ್ತು ಬಯೋಮೆಟ್ರಿಕ್ ದೃಢೀಕರಣ ಸೇರಿದಂತೆ ಹಲವಾರು ಉಪಯೋಗಗಳನ್ನು ಹೊಂದಿದೆ.
ಯಂತ್ರ ಕಲಿಕೆಯಲ್ಲಿನ ಪ್ರಗತಿಗಳ ಪರಿಣಾಮವಾಗಿ ಇತ್ತೀಚಿನ ವರ್ಷಗಳಲ್ಲಿ ಮುಖ ಗುರುತಿಸುವಿಕೆ ಅಲ್ಗಾರಿದಮ್ಗಳ ನಿಖರತೆ ಗಣನೀಯವಾಗಿ ಹೆಚ್ಚಾಗಿದೆ.
ಅಗತ್ಯ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವುದು
ಯಾವುದನ್ನಾದರೂ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಮ್ಮ ಮಾದರಿಗೆ ಅಗತ್ಯವಿರುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು ನಾವು ಆಮದು ಮಾಡಿಕೊಳ್ಳಬೇಕು. Tensorflow (tf) ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ ಮತ್ತು ಮಾದರಿಯನ್ನು ರಚಿಸಲು ಮತ್ತು ತರಬೇತಿ ನೀಡಲು ಬಳಸಲಾಗುತ್ತದೆ. <(p>
"numpy" ಗಣಿತದ ಲೆಕ್ಕಾಚಾರಗಳು ಮತ್ತು ಡೇಟಾ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
"matplotlib.pyplot" ಅನ್ನು plt ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗಿದೆ ಮತ್ತು ಇದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಡೇಟಾ ಚಾರ್ಟಿಂಗ್ ಮತ್ತು ದೃಶ್ಯೀಕರಣಗಳು.
ಅಂತಿಮವಾಗಿ, "ಎಲ್ಎಫ್ಡಬ್ಲ್ಯೂ ಜನರನ್ನು ಪಡೆದುಕೊಳ್ಳಿ" ಅನ್ನು ಸ್ಕ್ಲೀರ್ನ್ನಿಂದ ಆಮದು ಮಾಡಿಕೊಳ್ಳಲಾಗುತ್ತದೆ. ಡೇಟಾಸೆಟ್ಗಳು ಮತ್ತು ಮುಖ ಗುರುತಿಸುವಿಕೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಕಾರ್ಯವು ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಟೂಲ್ಕಿಟ್ನ ಭಾಗವಾಗಿದೆ. ಈ ಕಾರ್ಯಕ್ಕೆ ಧನ್ಯವಾದಗಳು ನಾವು ಇನ್ನೊಂದು ಡೇಟಾಸೆಟ್ ಅನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಇದನ್ನು ಈಗಾಗಲೇ ಸ್ಕಿಟ್-ಲರ್ನ್ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ.
ಮತ್ತು, ಇದು ನಿಮಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಪ್ರವೇಶವನ್ನು ನೀಡುತ್ತದೆ ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ ಡೇಟಾಸೆಟ್ಗಳು ಅರ್ಜಿಗಳನ್ನು. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, "ಲೇಬಲ್ ಮಾಡಿದ ಮುಖಗಳು ಇನ್ ದಿ ವೈಲ್ಡ್" (LFW) ಡೇಟಾಸೆಟ್ ಅನ್ನು ಹಿಂಪಡೆಯಲು ನಾವು lfw ಪೀಪಲ್ ವಿಧಾನವನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಇದು ಜನರ ಮುಖಗಳ ಫೋಟೋಗಳು ಮತ್ತು ಅವರೊಂದಿಗೆ ಹೋಗುವ ಲೇಬಲ್ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ನಮ್ಮ ಮುಖ ಗುರುತಿಸುವಿಕೆ ಮಾದರಿಯ ಅನುಷ್ಠಾನ ಮತ್ತು ಮೌಲ್ಯಮಾಪನದಲ್ಲಿ ಈ ಗ್ರಂಥಾಲಯಗಳು ನಿರ್ಣಾಯಕವಾಗಿವೆ.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
ಮುಖ ಗುರುತಿಸುವಿಕೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಪೂರ್ವ ಸಂಸ್ಕರಣೆ ಮತ್ತು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಈ ಭಾಗದಲ್ಲಿ, ಮುಖದ ಗುರುತಿಸುವಿಕೆ ಡೇಟಾವನ್ನು ಪೂರ್ವಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಾವು "ಎಲ್ಎಫ್ಡಬ್ಲ್ಯೂ ಜನರನ್ನು ಪಡೆದುಕೊಳ್ಳಿ" ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ಮೊದಲಿಗೆ, "ಪ್ರತಿ ವ್ಯಕ್ತಿಗೆ ನಿಮಿಷ ಮುಖಗಳು=60" ಆಯ್ಕೆಯೊಂದಿಗೆ ನಾವು lfw ಜನರನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತೇವೆ. ಡೇಟಾ ಸೆಟ್ನಲ್ಲಿ ಕನಿಷ್ಠ 60 ಫೋಟೋಗಳನ್ನು ಹೊಂದಿರುವ ವ್ಯಕ್ತಿಗಳನ್ನು ಮಾತ್ರ ಸೇರಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ ಎಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಮ್ಮ ಮಾದರಿಯು ಕಲಿಯಲು ಸಾಕಷ್ಟು ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತೇವೆ. ಅಲ್ಲದೆ, ಇದು ಮಿತಿಮೀರಿದ ಅಪಾಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಮುಖಗಳ ವಸ್ತುವಿನಿಂದ ಡೇಟಾ ಮತ್ತು ಲೇಬಲ್ಗಳನ್ನು ನಂತರ ಹೊರತೆಗೆಯಲಾಗುತ್ತದೆ ಮತ್ತು X ಮತ್ತು y ವೇರಿಯಬಲ್ಗಳಿಗೆ ನಿಯೋಜಿಸಲಾಗುತ್ತದೆ. ಎಕ್ಸ್ ಹೋಲ್.
ಪೂರ್ವ-ಸಂಸ್ಕರಿಸಿದ ಡೇಟಾ ಮತ್ತು ಲೇಬಲ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮ ಮುಖ ಗುರುತಿಸುವಿಕೆಯ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಲು ನಾವು ಈಗ ಸಿದ್ಧರಿದ್ದೇವೆ.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
ವಿಭಜಿಸುವ ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್ಗಳು
ಈ ಹಂತದಲ್ಲಿ, sklearn.model ಆಯ್ಕೆಯಿಂದ ಟ್ರೈನ್ ಟೆಸ್ಟ್ ಸ್ಪ್ಲಿಟ್ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ನಮ್ಮ ಮುಖ ಗುರುತಿಸುವಿಕೆ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಎರಡು ಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ. ತರಬೇತಿಯ ನಂತರ ನಮ್ಮ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ಣಯಿಸುವುದು ಈ ವಿಭಜನೆಯ ಗುರಿಯಾಗಿದೆ
ಟ್ರೈನ್ ಟೆಸ್ಟ್ ಸ್ಪ್ಲಿಟ್ ಫಂಕ್ಷನ್ ಇನ್ಪುಟ್ ಡೇಟಾ X ಮತ್ತು ಲೇಬಲ್ y ಆಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಮತ್ತು, ಇದು ಅವುಗಳನ್ನು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಸೆಟ್ಗಳಾಗಿ ವಿಭಜಿಸುತ್ತದೆ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು ಪರೀಕ್ಷಾ ಗಾತ್ರ = 0.2 ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ. 20% ಡೇಟಾವನ್ನು ಪರೀಕ್ಷಾ ಸೆಟ್ ಆಗಿ ಮತ್ತು 80% ತರಬೇತಿ ಸೆಟ್ ಆಗಿ ಬಳಸಲಾಗುವುದು ಎಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ಇದಲ್ಲದೆ, ಪ್ರತಿ ಬಾರಿ ಕೋಡ್ ಅನ್ನು ನಿರ್ವಹಿಸಿದಾಗ ಡೇಟಾವನ್ನು ಸ್ಥಿರವಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಯಾದೃಚ್ಛಿಕ ಸ್ಥಿತಿ=42 ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
ಡೇಟಾವನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು
ಡೇಟಾವನ್ನು ಪೂರ್ವ ಸಂಸ್ಕರಣೆಯ ಉದ್ದೇಶವು ಮಾದರಿಗೆ ಪ್ರವೇಶಿಸಲು ಅದನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು. ಪ್ರತಿ ಡೇಟಾ ಬಿಂದುವನ್ನು 255 ರಿಂದ ಭಾಗಿಸುವ ಮೂಲಕ ಡೇಟಾವನ್ನು ಈ ಕೋಡ್ನಲ್ಲಿ ಪೂರ್ವ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಇದನ್ನು ಸಾಧಿಸಲು ನಮಗೆ ಏನು ಪ್ರೇರೇಪಿಸಿತು? ಸಾಮಾನ್ಯೀಕರಣವು ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳು ಒಂದೇ ಪ್ರಮಾಣದಲ್ಲಿವೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಯಂತ್ರ ಕಲಿಕೆಯಲ್ಲಿ ಬಳಸಲಾಗುವ ಪೂರ್ವ ಸಂಸ್ಕರಣಾ ವಿಧಾನವಾಗಿದೆ. ಈ ಸನ್ನಿವೇಶದಲ್ಲಿ, 255 ರಿಂದ ಭಾಗಿಸುವುದರಿಂದ ದತ್ತಾಂಶವನ್ನು 0 ರಿಂದ 1 ರ ಶ್ರೇಣಿಗೆ ಅಳೆಯಲಾಗುತ್ತದೆ, ಇದು ಸಾಮಾನ್ಯ ಚಿತ್ರ ಡೇಟಾ ಸಾಮಾನ್ಯೀಕರಣ ಹಂತವಾಗಿದೆ.
ಇದು ಮಾದರಿಯ ಒಮ್ಮುಖವನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೆಚ್ಚಿಸಬಹುದು.
X_train = X_train / 255.0
X_test = X_test / 255.0
ಮೋಡ್ ಅನ್ನು ರಚಿಸಲಾಗುತ್ತಿದೆ
ಚಿತ್ರದಲ್ಲಿ ಯಾರ ಮುಖ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಗುರುತಿಸಲು ಬಯಸುತ್ತೇವೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಸಂಪರ್ಕಗೊಂಡ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ದಟ್ಟವಾದ ನೆಟ್ವರ್ಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಇದು ಮಾದರಿಯನ್ನು ರಚಿಸಲು ಬಳಸಲಾದ ಕೃತಕ ನರಮಂಡಲವಾಗಿದೆ.
ಮಾನವನ ಮೆದುಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಸಂಘಟಿತವಾಗಿದೆ ಎಂಬುದರ ನಂತರ ಕೃತಕ ನರಮಂಡಲವನ್ನು ರೂಪಿಸಲಾಗಿದೆ. ಅವು ಮಾಹಿತಿ-ಸಂಸ್ಕರಣಾ ನೋಡ್ಗಳು ಅಥವಾ ಲಿಂಕ್ ಆಗಿರುವ ನ್ಯೂರಾನ್ಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟಿದೆ. ದಟ್ಟವಾದ ಜಾಲದಲ್ಲಿರುವ ಪದರದಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ನರಕೋಶವು ಅದರ ಮೇಲಿನ ಪದರದಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ನರಕೋಶಕ್ಕೂ ಲಿಂಕ್ ಆಗಿದೆ.
ಈ ಕೋಡ್ನಲ್ಲಿ ಮಾದರಿಯು ನಾಲ್ಕು ಪದರಗಳನ್ನು ಹೊಂದಿದೆ. ಮುಂದಿನ ಲೇಯರ್ಗೆ ಫೀಡ್ ಮಾಡಲು, ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು ಮೊದಲ ಲೇಯರ್ನಲ್ಲಿ ಒಂದು ಆಯಾಮದ ಅರೇಗೆ ಚಪ್ಪಟೆಗೊಳಿಸಲಾಗುತ್ತದೆ. ಕೆಳಗಿನ ಎರಡು ಪದರಗಳಲ್ಲಿ 128 ಮತ್ತು 64 ನರಕೋಶಗಳು, ಅದರ ಪ್ರಕಾರ, ಸಂಪೂರ್ಣವಾಗಿ ಲಿಂಕ್ ಆಗಿವೆ.
ReLU ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವು ಈ ಲೇಯರ್ಗಳಿಂದ ಬಳಸಲಾಗುವ ಅನನ್ಯ ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವಾಗಿದೆ. ಅದರೊಂದಿಗೆ, ಇನ್ಪುಟ್ಗಳು ಮತ್ತು ಔಟ್ಪುಟ್ಗಳ ನಡುವಿನ ರೇಖಾತ್ಮಕವಲ್ಲದ ಪರಸ್ಪರ ಸಂಬಂಧಗಳನ್ನು ಕಲಿಯಲು ನಾವು ಮಾದರಿಯನ್ನು ಪಡೆಯಬಹುದು. ಕೊನೆಯ ಪದರವು ಮುನ್ಸೂಚನೆಗಳನ್ನು ಮಾಡಲು ಸಾಫ್ಟ್ಮ್ಯಾಕ್ಸ್ ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತದೆ. ಮತ್ತು, ಇದು ಸಂಭಾವ್ಯ ವರ್ಗಗಳಿರುವಷ್ಟು ನ್ಯೂರಾನ್ಗಳೊಂದಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಸಂಪರ್ಕ ಹೊಂದಿದ ಪದರವಾಗಿದೆ.
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
ಮಾದರಿಯ ಕಂಪೈಲಿಂಗ್
"ಕಂಪೈಲ್" ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡಲಾಗಿದೆ. ನಾವು ತರಬೇತಿಗಾಗಿ ಮಾದರಿಯನ್ನು ಸಿದ್ಧಪಡಿಸಬೇಕು. ಆದ್ದರಿಂದ, ಮಾದರಿಯನ್ನು ನಿರ್ಣಯಿಸಲು ಬಳಸಲಾಗುವ ಆಪ್ಟಿಮೈಜರ್, ನಷ್ಟದ ಕಾರ್ಯ ಮತ್ತು ಮೆಟ್ರಿಕ್ಗಳನ್ನು ನಾವು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
ತರಬೇತಿಯ ಸಮಯದಲ್ಲಿ, ಆಪ್ಟಿಮೈಜರ್ ಮಾದರಿಯ ನಿಯತಾಂಕಗಳನ್ನು ಬದಲಾಯಿಸುವ ಉಸ್ತುವಾರಿ ವಹಿಸುತ್ತದೆ. "ಆಡಮ್" ಆಪ್ಟಿಮೈಜರ್ ಜನಪ್ರಿಯ ಆಳವಾದ ಕಲಿಕೆಯ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರವಾಗಿದೆ.
ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ಣಯಿಸಲು ನಾವು ನಷ್ಟ ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ. ಗುರಿ ಲೇಬಲ್ಗಳು ಒಂದು-ಬಿಸಿ ಎನ್ಕೋಡ್ ಮಾಡಲಾದ ವೆಕ್ಟರ್ಗಳಿಗಿಂತ ಚಿತ್ರದ ವರ್ಗವನ್ನು ಪ್ರತಿಬಿಂಬಿಸುವ ಪೂರ್ಣಾಂಕಗಳಾಗಿರುವುದರಿಂದ, "ವಿರಳವಾದ ವರ್ಗೀಯ ಕ್ರಾಸ್ಸೆಂಟ್ರೊಪಿ" ನಷ್ಟ ಕಾರ್ಯವು ಅನುಕೂಲಕರವಾಗಿರುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, ನಾವು ಮಾದರಿಯನ್ನು ನಿರ್ಣಯಿಸಲು ಮೆಟ್ರಿಕ್ಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, "ನಿಖರತೆ".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
ಮಾದರಿ ತರಬೇತಿ
ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಲು ನಾವು "ಫಿಟ್" ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ.
ನಾವು ತರಬೇತಿ ಡೇಟಾ (ಎಕ್ಸ್ ರೈಲು) ಮತ್ತು ಸಂಬಂಧಿತ ಲೇಬಲ್ಗಳನ್ನು (ವೈ ರೈಲು) ಒದಗಿಸುತ್ತೇವೆ, ಹಾಗೆಯೇ ಯುಗಗಳ ಸಂಖ್ಯೆಯನ್ನು (ಪುನರಾವರ್ತನೆಗಳು) 10 ರಂತೆ ಹೊಂದಿಸುತ್ತೇವೆ. ತರಬೇತಿ ವಿಧಾನವು ನಷ್ಟವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮಾದರಿ ತೂಕವನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ (ಇದರ ನಡುವಿನ ವ್ಯತ್ಯಾಸ ಭವಿಷ್ಯ ಮತ್ತು ನೈಜ ಲೇಬಲ್ಗಳು) ಮತ್ತು ತರಬೇತಿ ಡೇಟಾದ ನಿಖರತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
model.fit(X_train, y_train, epochs=10)
ಮಾದರಿ ಮೌಲ್ಯಮಾಪನ
ಈಗ, ನಾವು ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಯನ್ನು ನಿರ್ಣಯಿಸಬೇಕಾಗಿದೆ. ನಾವು ಪರೀಕ್ಷಾ ನಷ್ಟವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಮಾದರಿಯ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನಿರ್ಣಯಿಸಲು ಪರೀಕ್ಷಾ ನಿಖರತೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಪರೀಕ್ಷಾ ಡೇಟಾ X ಪರೀಕ್ಷೆ ಮತ್ತು ಪರೀಕ್ಷಾ ಲೇಬಲ್ಗಳು y ಪರೀಕ್ಷೆಯಲ್ಲಿ, ನಾವು "ಮಾದರಿ. ಮೌಲ್ಯಮಾಪನ ಕಾರ್ಯ" ಎಂದು ಕರೆಯಬೇಕಾಗಿದೆ
ಕಾರ್ಯವು ಪರೀಕ್ಷಾ ನಿಖರತೆ ಮತ್ತು ಪರೀಕ್ಷಾ ನಷ್ಟವನ್ನು ನೀಡುತ್ತದೆ. ಅಸ್ಥಿರ ಪರೀಕ್ಷೆ ನಷ್ಟ ಮತ್ತು ಪರೀಕ್ಷಾ ನಿಖರತೆ ಅನುಕ್ರಮವಾಗಿ ಈ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಅಂತಿಮವಾಗಿ, ನಾವು ಪರೀಕ್ಷಾ ನಿಖರತೆಯನ್ನು ಔಟ್ಪುಟ್ ಮಾಡಲು "ಮುದ್ರಣ" ಕಾರ್ಯವನ್ನು ಬಳಸುತ್ತೇವೆ.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
ತರಗತಿಗಳನ್ನು ಊಹಿಸುವುದು ಮತ್ತು ಪೂರ್ವಭಾವಿ ತರಗತಿಗಳನ್ನು ಪಡೆಯುವುದು
ತರಬೇತಿ ಮಾದರಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು, ಅಲ್ಗಾರಿದಮ್ ಮುನ್ಸೂಚನೆಗಳನ್ನು ಮಾಡುತ್ತದೆ. ಪರೀಕ್ಷಾ ದತ್ತಾಂಶವನ್ನು "model.predict" ವಿಧಾನಕ್ಕೆ ರವಾನಿಸಿದಾಗ, ಪರೀಕ್ಷಾ ಸೆಟ್ನಲ್ಲಿರುವ ಪ್ರತಿ ಚಿತ್ರಕ್ಕೂ ಇದು ಭವಿಷ್ಯವಾಣಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ.
ಪ್ರತಿ ಚಿತ್ರಕ್ಕಾಗಿ ಗುರಿ ವರ್ಗದ ಹೆಸರನ್ನು ನಂತರ "ಗುರಿ ಹೆಸರುಗಳು" ಪಟ್ಟಿಯಿಂದ "np.argmax" ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಸೂಚ್ಯಂಕವನ್ನು ಮಹಾನ್ ನಿರೀಕ್ಷಿತ ಸಂಭವನೀಯತೆಯೊಂದಿಗೆ ಗುರುತಿಸಲು ಹಿಂಪಡೆಯಲಾಗುತ್ತದೆ. ಈ ಸೂಚ್ಯಂಕವನ್ನು ನಂತರ ಪ್ರತಿ ಚಿತ್ರಕ್ಕಾಗಿ ಊಹಿಸಲಾದ ವರ್ಗವನ್ನು ನಿರ್ಧರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.
ಪಟ್ಟಿಯ ಗ್ರಹಿಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು, "ಮುನ್ಸೂಚನೆಗಳು" ಶ್ರೇಣಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಮುನ್ಸೂಚನೆಗಳನ್ನು ಈ ವಿಧಾನಕ್ಕೆ ಒಳಪಡಿಸಲಾಗುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ "ಮುನ್ಸೂಚಿಸಲಾದ ವರ್ಗಗಳು" ಪಟ್ಟಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
ಮುನ್ಸೂಚನೆಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸುವುದು
ನಮ್ಮ ಮಾದರಿಯು ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಈಗ ನೋಡಬಹುದು.
ಮಾದರಿಯು ಎಷ್ಟು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂಬುದನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು, ಮೊದಲ 10 ಫೋಟೋಗಳು ಮತ್ತು ಅವುಗಳ ಮುನ್ನೋಟಗಳನ್ನು ತೋರಿಸಲಾಗುತ್ತದೆ. ಇದು ಫೋಟೋಗಳನ್ನು ಗ್ರೇಸ್ಕೇಲ್ನಲ್ಲಿ ರೂಪಿಸುತ್ತದೆ ಮತ್ತು ಚಿತ್ರದ ನಿಜವಾದ ವರ್ಗ ಮತ್ತು matplotlib.pyplot ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಯಿಂದ ಊಹಿಸಲಾದ ವರ್ಗ ಎರಡನ್ನೂ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ಮೊದಲ 10 ಪರೀಕ್ಷಾ ಸೆಟ್ ಫೋಟೋಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ಪ್ಲ್ಯಾಟ್ ಮಾಡಲು ಫಾರ್ ಲೂಪ್ ಮೂಲಕ "imshow" ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಗುರಿಯ ಹೆಸರುಗಳು[y ಪರೀಕ್ಷೆ[i]] ಮತ್ತು ಊಹಿಸಲಾದ ವರ್ಗಗಳನ್ನು[i] ಅನುಕ್ರಮವಾಗಿ ಚಿತ್ರದ ನಿಜವಾದ ವರ್ಗ ಮತ್ತು ಊಹಿಸಲಾದ ವರ್ಗವನ್ನು ನಿರ್ಧರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪ್ರತಿ ಕಥಾವಸ್ತುವಿನ ಶೀರ್ಷಿಕೆಗಳನ್ನು ನಂತರ ಈ ವರ್ಗೀಕರಣಗಳಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ.
ಅಂತಿಮವಾಗಿ, plt.show() ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಕಥಾವಸ್ತುವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
ಅಂತಿಮಗೊಳಿಸು
ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳನ್ನು ರಚಿಸಲು TensorFlow ಸಂಪೂರ್ಣ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ವಾತಾವರಣವನ್ನು ನೀಡುತ್ತದೆ.
ನಿರ್ದಿಷ್ಟ ಅವಶ್ಯಕತೆಗಳನ್ನು ಪೂರೈಸಲು ಮಾದರಿಯನ್ನು ಉತ್ತಮವಾಗಿ-ಟ್ಯೂನ್ ಮಾಡುವ ಮೂಲಕ ಅಥವಾ ಯಂತ್ರ ಕಲಿಕೆಯಲ್ಲಿ ಹೊಸ ಬೆಳವಣಿಗೆಗಳನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ಮಾದರಿಯ ನಿಖರತೆಯನ್ನು ಇನ್ನಷ್ಟು ಹೆಚ್ಚಿಸಬಹುದು.
ಭವಿಷ್ಯದಲ್ಲಿ ಭದ್ರತಾ ವ್ಯವಸ್ಥೆಗಳು, ಬಯೋಮೆಟ್ರಿಕ್ ದೃಢೀಕರಣ ಮತ್ತು ಆರೋಗ್ಯ ರಕ್ಷಣೆಯಂತಹ ಉದ್ಯಮಗಳಲ್ಲಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಮತ್ತು ಮುಖದ ಗುರುತಿಸುವಿಕೆಯನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಾವು ಶೀಘ್ರದಲ್ಲೇ ಆಕರ್ಷಕ ಆವಿಷ್ಕಾರಗಳನ್ನು ನೋಡುತ್ತೇವೆ.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ