ಆರಂಭಿಕರಿಗಾಗಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಟ್ಯುಟೋರಿಯಲ್
ಆಳವಾದ ಕಲಿಕೆ ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಗೆ ಟೆನ್ಸರ್ಫ್ಲೋ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಚೌಕಟ್ಟುಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಗೂಗಲ್ ಬ್ರೈನ್ ತಂಡವು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಹಲವಾರು ಸಂಶೋಧನಾ ಯೋಜನೆಗಳು ಮತ್ತು ಕೈಗಾರಿಕಾ ಅನ್ವಯಿಕೆಗಳಲ್ಲಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತಿದೆ. ಈ ಲೇಖನವು ನಿಮಗೆ ಟೆನ್ಸರ್ಫ್ಲೋವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಹಾಯ ಮಾಡಲು ಹಂತ-ಹಂತದ ಟ್ಯುಟೋರಿಯಲ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.
1. ಟೆನ್ಸರ್ಫ್ಲೋ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ನಾವು TensorFlow ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಮತ್ತು ಬಳಸಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, TensorFlow ಎಂದರೇನು ಮತ್ತು ಅದರ ಹಿಂದಿನ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ. TensorFlow ಸಂಖ್ಯಾತ್ಮಕ ಲೆಕ್ಕಾಚಾರ ಮತ್ತು ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ ಮುಕ್ತ-ಮೂಲ ಚೌಕಟ್ಟಾಗಿದೆ. ಇದು ಸಂಖ್ಯಾತ್ಮಕ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಡೇಟಾ ಹರಿವಿನ ಗ್ರಾಫ್ಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಅಲ್ಲಿ ಗ್ರಾಫ್ನಲ್ಲಿರುವ ನೋಡ್ಗಳು ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ ಮತ್ತು ಅಂಚುಗಳು ಅವುಗಳ ನಡುವೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಬಹುಆಯಾಮದ ಡೇಟಾ ಶ್ರೇಣಿಗಳನ್ನು (ಟೆನ್ಸರ್ಗಳು) ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.
2. ಟೆನ್ಸರ್ ಫ್ಲೋ ಸ್ಥಾಪನೆ
ಟೆನ್ಸರ್ಫ್ಲೋ ಬಳಸುವಲ್ಲಿ ಮೊದಲ ಹೆಜ್ಜೆ ಅದನ್ನು ಸ್ಥಾಪಿಸುವುದು. ಪೈಥಾನ್ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಪಿಪ್ ಬಳಸಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ.
1. ಪೈಥಾನ್ ಸ್ಥಾಪನೆ:
ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಈ ಲೇಖನ ಬರೆಯುವ ಸಮಯದಲ್ಲಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಪೈಥಾನ್ 3.6 ರಿಂದ 3.9 ರವರೆಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. ನೀವು ಅಧಿಕೃತ ಪೈಥಾನ್ ವೆಬ್ಸೈಟ್ನಿಂದ ಪೈಥಾನ್ ಅನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು.
2. ವರ್ಚುವಲ್ ಪರಿಸರ:
ನಿಮ್ಮ ಟೆನ್ಸರ್ಫ್ಲೋ ಯೋಜನೆಯನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಲು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ:
"`ಶ್
ಪೈಥಾನ್ -ಎಂ ವೆನ್ವಿ ಮೈನ್ವಿ
ಮೂಲ myenv/bin/activate ಮ್ಯಾಕ್/ಲಿನಕ್ಸ್ ಬಳಕೆದಾರರಿಗೆ
ವಿಂಡೋಸ್ ಬಳಕೆದಾರರಿಗೆ myenv\ಸ್ಕ್ರಿಪ್ಟ್ಗಳು\ಸಕ್ರಿಯಗೊಳಿಸಿ
""
3. ಟೆನ್ಸರ್ ಫ್ಲೋ ಸ್ಥಾಪನೆ:
ಈಗ, ಪಿಪ್ ಬಳಸಿ ಟೆನ್ಸರ್ ಫ್ಲೋ ಅನ್ನು ಸ್ಥಾಪಿಸಿ:
"`ಶ್
ಪಿಪ್ ಇನ್ಸ್ಟಾಲ್ ಟೆನ್ಸರ್ಫ್ಲೋ
""
3. ಟೆನ್ಸರ್ ಫ್ಲೋ ಜೊತೆ ಹಲೋ ವರ್ಲ್ಡ್
ಈಗ ಟೆನ್ಸರ್ಫ್ಲೋ ಸ್ಥಾಪಿಸಲಾಗಿದೆ, ಅನುಸ್ಥಾಪನೆಯನ್ನು ಪರಿಶೀಲಿಸಲು ಸರಳವಾದ ಪೈಥಾನ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸೋಣ. ಹೊಸ ಪೈಥಾನ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದಕ್ಕೆ `hello_tensorflow.py` ಎಂದು ಹೆಸರಿಸಿ.
"ಹೆಬ್ಬಾವು
ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಟಿಎಫ್ ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
ಸ್ಥಿರಾಂಕವನ್ನು ರಚಿಸಿ
ಹಲೋ = tf.constant('ಹಲೋ, ಟೆನ್ಸರ್ಫ್ಲೋ!')
ಅಧಿವೇಶನ ಪ್ರಾರಂಭಿಸಿ
tf.Session() ಅನ್ನು ಸೆಸ್ ಆಗಿ ಬಳಸಿ:
ಫಲಿತಾಂಶ = sess.run(ಹಲೋ)
ಮುದ್ರಣ (ಫಲಿತಾಂಶ)
""
ಟೆನ್ಸರ್ಫ್ಲೋ ಆವೃತ್ತಿ 2.x ಪ್ರಕಾರ ಕೋಡ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ:
"ಹೆಬ್ಬಾವು
ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಟಿಎಫ್ ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
ಸ್ಥಿರಾಂಕವನ್ನು ರಚಿಸಿ
ಹಲೋ = tf.constant('ಹಲೋ, ಟೆನ್ಸರ್ಫ್ಲೋ!')
ಆಜರ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಬಳಸಿ ರನ್ ಮಾಡಿ (ಡೀಫಾಲ್ಟ್ ಆಗಿ ಆನ್)
ಪ್ರಿಂಟ್(ಹಲೋ.ನಂಪಿ())
""
ಫೈಲ್ ಅನ್ನು ಉಳಿಸಿ, ನಂತರ ರನ್ ಮಾಡಿ:
"`ಶ್
ಪೈಥಾನ್ hello_tensorflow.py
""
4. ಟೆನ್ಸರ್ಗಳು ಮತ್ತು ಮೂಲ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು
ಟೆನ್ಸರ್ಫ್ಲೋದಲ್ಲಿ ಟೆನ್ಸರ್ಗಳು ಪ್ರಾಥಮಿಕ ದತ್ತಾಂಶ ರಚನೆಯಾಗಿದ್ದು, ಇವು ಬಹುಆಯಾಮದ ಶ್ರೇಣಿಗಳಾಗಿವೆ. ಟೆನ್ಸರ್ಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುವ ಕೆಲವು ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:
"ಹೆಬ್ಬಾವು
ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಟಿಎಫ್ ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
ಟೆನ್ಸರ್ಗಳನ್ನು ರಚಿಸುವುದು
ಸ್ಕೇಲಾರ್ = tf. ಸ್ಥಿರಾಂಕ(7) ಸ್ಕೇಲಾರ್
ವೆಕ್ಟರ್ = tf. ಸ್ಥಿರ ([1, 2, 3]) ವೆಕ್ಟರ್
ಮ್ಯಾಟ್ರಿಕ್ಸ್ = tf. ಸ್ಥಿರ([[1, 2], [3, 4]]) ಮ್ಯಾಟ್ರಿಕ್ಸ್
tensor3d = tf.constant([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]) 3D ಟೆನ್ಸರ್
ಪ್ರಿಂಟ್(f'ಸ್ಕೇಲಾರ್: {ಸ್ಕೇಲಾರ್}')
ಪ್ರಿಂಟ್(f'ವೆಕ್ಟರ್: {ವೆಕ್ಟರ್}')
ಪ್ರಿಂಟ್(f'ಮ್ಯಾಟ್ರಿಕ್ಸ್: {ಮ್ಯಾಟ್ರಿಕ್ಸ್}')
ಪ್ರಿಂಟ್(f'ಟೆನ್ಸರ್ 3D: {ಟೆನ್ಸರ್3d}')
""
ಟೆನ್ಸರ್ಗಳ ಮೇಲೆ ಮೂಲಭೂತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು:
"ಹೆಬ್ಬಾವು
a = tf.ಸ್ಥಿರ([[1, 2], [3, 4]])
b = tf.ಸ್ಥಿರ([[5, 6], [7, 8]])
ಸೇರ್ಪಡೆ ಕಾರ್ಯಾಚರಣೆ
ಸೇರಿಸಿ = tf. ಸೇರಿಸಿ(a, b)
ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರ ಕಾರ್ಯಾಚರಣೆಗಳು
ಮುಲ್ = tf.ಮತ್ಮುಲ್(ಎ, ಬಿ)
ಮುದ್ರಿಸು(f'ಸೇರ್ಪಡೆ: {ಸೇರಿಸಿ}')
ಪ್ರಿಂಟ್(f'ಮ್ಯಾಟ್ರಿಕ್ಸ್ ಗುಣಾಕಾರ: {mul}')
""
5. ಸರಳ ನರಮಂಡಲ ಜಾಲ ಮಾದರಿಯನ್ನು ರಚಿಸುವುದು
ಮುಂದಿನ ಹಂತವು ಸರಳವಾದ ನರಮಂಡಲ ಜಾಲ ಮಾದರಿಯನ್ನು ರಚಿಸುವುದು. ನಾವು ಕೈಬರಹದ ಅಂಕಿ ಚಿತ್ರಗಳ ಡೇಟಾಬೇಸ್ ಆದ MNIST ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಚಿತ್ರ ವರ್ಗೀಕರಣ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ. ಪ್ರಾರಂಭಿಸೋಣ:
"ಹೆಬ್ಬಾವು
ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಟಿಎಫ್ ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
tensorflow.keras ನಿಂದ ಆಮದು ಡೇಟಾಸೆಟ್ಗಳು, ಲೇಯರ್ಗಳು, ಮಾದರಿಗಳು
MNIST ಡೇಟಾಸೆಟ್ ಅನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
(ರೈಲು_ಚಿತ್ರಗಳು, ರೈಲು_ಲೇಬಲ್ಗಳು), (ಪರೀಕ್ಷೆ_ಚಿತ್ರಗಳು, ಪರೀಕ್ಷಾ_ಲೇಬಲ್ಗಳು) = ಡೇಟಾಸೆಟ್ಗಳು.mnist.load_data()
ಚಿತ್ರ ಸಾಮಾನ್ಯೀಕರಣ
ರೈಲು_ಚಿತ್ರಗಳು, ಪರೀಕ್ಷಾ_ಚಿತ್ರಗಳು = ರೈಲು_ಚಿತ್ರಗಳು / 255.0, ಪರೀಕ್ಷಾ_ಚಿತ್ರಗಳು / 255.0
ಮಾದರಿಯನ್ನು ತಯಾರಿಸುವುದು
ಮಾದರಿ = ಮಾದರಿಗಳು. ಅನುಕ್ರಮ([
ಪದರಗಳು.ಚಪ್ಪಟೆಯಾಗಿಸಿ(ಇನ್ಪುಟ್_ಆಕಾರ=(28, 28)),
ಪದರಗಳು.ದಟ್ಟವಾದ(128, ಸಕ್ರಿಯಗೊಳಿಸುವಿಕೆ='ರೆಲು'),
ಪದರಗಳು.ದಟ್ಟ(10)
])
ಮಾದರಿ ಸಂಕಲನ
ಮಾಡೆಲ್.ಕಂಪೈಲ್(ಆಪ್ಟಿಮೈಜರ್='ಆಡಮ್',
ನಷ್ಟ=tf.keras.losses.SparseCategoricalCrossentropy(logits_from=True),
ಮೆಟ್ರಿಕ್ಸ್=['ನಿಖರತೆ'])
ಮಾದರಿ ತರಬೇತಿ
ಮಾದರಿ.ಫಿಟ್(ಟ್ರೇನ್_ಇಮೇಜಸ್, ಟ್ರೈನ್_ಲೇಬಲ್ಸ್, ಯುಗಗಳು=5)
ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
test_loss, test_acc = model.evaluate(test_images, test_labels)
ಪ್ರಿಂಟ್(f'ಪರೀಕ್ಷಾ ನಿಖರತೆ: {test_acc}')
""
ವಿವರಣೆ:
– ಡೇಟಾಸೆಟ್ಗಳು: ನಾವು MNIST ಡೇಟಾಸೆಟ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಲೋಡ್ ಮಾಡುತ್ತೇವೆ.
– ಪೂರ್ವ-ಸಂಸ್ಕರಣೆ: ಪಿಕ್ಸೆಲ್ ಮೌಲ್ಯಗಳನ್ನು 255 ರಿಂದ ಭಾಗಿಸುವ ಮೂಲಕ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸಿ.
– ಮಾದರಿ: ನಾವು ಎರಡು ಪದರಗಳನ್ನು ಹೊಂದಿರುವ ಸರಳ ಮಾದರಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. ಮೊದಲ ಪದರವು 2D ಚಿತ್ರವನ್ನು 1D ಶ್ರೇಣಿಯಾಗಿ ಪರಿವರ್ತಿಸಲು `ಚಪ್ಪಟೆಯಾದ` ಪದರವಾಗಿದೆ. ಎರಡನೇ ಪದರವು 128 ನ್ಯೂರಾನ್ಗಳು ಮತ್ತು ಸಕ್ರಿಯಗೊಳಿಸುವ ಕಾರ್ಯವಾಗಿ `ರೆಲು` ಹೊಂದಿರುವ `ದಟ್ಟವಾದ` ಪದರವಾಗಿದೆ, ಮತ್ತು ಕೊನೆಯದು 10 ವರ್ಗಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ 10 ನ್ಯೂರಾನ್ಗಳನ್ನು ಹೊಂದಿರುವ `ದಟ್ಟವಾದ` ಪದರವಾಗಿದೆ.
– ಕಂಪೈಲ್: ನಾವು `adam` ಆಪ್ಟಿಮೈಜರ್ ಮತ್ತು `SparseCategoricalCrossentropy` ಅನ್ನು ನಷ್ಟ ಕಾರ್ಯವಾಗಿ ಬಳಸಿಕೊಂಡು ಮಾದರಿಯನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತೇವೆ.
– ರೈಲು: ಮಾದರಿಯನ್ನು 5 ಯುಗಗಳಿಗೆ ತರಬೇತಿ ನೀಡಿ.
- ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ: ಪರೀಕ್ಷಾ ದತ್ತಾಂಶದ ವಿರುದ್ಧ ಮಾದರಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಿ.
6. ಮಾದರಿಗಳನ್ನು ಉಳಿಸುವುದು ಮತ್ತು ಲೋಡ್ ಮಾಡುವುದು
ಮಾದರಿಗೆ ತರಬೇತಿ ನೀಡಿದ ನಂತರ, ಅದನ್ನು ಮರುತರಬೇತಿ ನೀಡದೆಯೇ ನಂತರದ ಬಳಕೆಗಾಗಿ ಉಳಿಸಲು ನೀವು ಬಯಸಬಹುದು. ಮಾದರಿಯನ್ನು ಹೇಗೆ ಉಳಿಸುವುದು ಮತ್ತು ಲೋಡ್ ಮಾಡುವುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:
"ಹೆಬ್ಬಾವು
ಮಾದರಿಯನ್ನು ಉಳಿಸಲಾಗುತ್ತಿದೆ
ಮಾದರಿ.ಸೇವ್('ನನ್ನ_ಮಾದರಿ.h5')
ಮಾದರಿಯನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಹೊಸ_ಮಾದರಿ = tf.keras.models.load_model('ನನ್ನ_ಮಾದರಿ.h5′)
ಲೋಡ್ ಮಾಡಲಾದ ಮಾದರಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ
ನಷ್ಟ, acc = new_model.evaluate(ಪರೀಕ್ಷೆ_ಚಿತ್ರಗಳು, ಪರೀಕ್ಷಾ_ಲೇಬಲ್ಗಳು)
print(f'ಲೋಡ್ ಮಾಡಲಾದ ಮಾದರಿಯ ನಿಖರತೆ: {acc}')
""
ತೀರ್ಮಾನ
ಈ ಮಾರ್ಗದರ್ಶಿ ಆರಂಭಿಕರಿಗಾಗಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಬಗ್ಗೆ ವಿವರವಾದ ಪರಿಚಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಾವು ಸ್ಥಾಪನೆ, ಮೂಲ ಟೆನ್ಸರ್ ಕಾರ್ಯಾಚರಣೆಗಳು ಮತ್ತು MNIST ಡೇಟಾಸೆಟ್ ಬಳಸಿ ಸರಳ ನರಮಂಡಲ ನೆಟ್ವರ್ಕ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ಒಳಗೊಂಡಿದ್ದೇವೆ. ಟೆನ್ಸರ್ಫ್ಲೋ ಅನ್ವೇಷಿಸಲು ಹಲವು ಸುಧಾರಿತ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಸುಧಾರಿತ ಡೇಟಾ ಸಂಸ್ಕರಣೆ, ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಮಾದರಿಗಳು ಮತ್ತು TPU ಗಳು ಮತ್ತು GPU ಗಳಂತಹ ಸಾಧನಗಳಲ್ಲಿ ಟೆನ್ಸರ್ಫ್ಲೋ ಬಳಸುವುದು. ಈ ಟ್ಯುಟೋರಿಯಲ್ ಟೆನ್ಸರ್ಫ್ಲೋನೊಂದಿಗೆ ಯಂತ್ರ ಕಲಿಕೆಯ ಜಗತ್ತಿನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.
