ಈ ಲೇಖನದಲ್ಲಿ, 30 ನಿಮಿಷಗಳಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆಯ ಪರಿಸರವನ್ನು ಹೇಗೆ ಹೊಂದಿಸುವುದು, ಇಮೇಜ್ ಗುರುತಿಸುವಿಕೆಗಾಗಿ ನರಮಂಡಲವನ್ನು ರಚಿಸುವುದು ಮತ್ತು ನಂತರ ಅದೇ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಗ್ರಾಫಿಕ್ಸ್ ಪ್ರೊಸೆಸರ್ (ಜಿಪಿಯು) ನಲ್ಲಿ ಹೇಗೆ ಚಲಾಯಿಸುವುದು ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ.
ಮೊದಲಿಗೆ, ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಎಂದರೇನು ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸೋಣ.
ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಗಣಿತದ ಮಾದರಿ, ಹಾಗೆಯೇ ಅದರ ಸಾಫ್ಟ್‌ವೇರ್ ಅಥವಾ ಹಾರ್ಡ್‌ವೇರ್ ಸಾಕಾರ, ಜೈವಿಕ ನರಮಂಡಲಗಳ ಸಂಘಟನೆ ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಣೆಯ ತತ್ವದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ - ಜೀವಂತ ಜೀವಿಗಳ ನರ ಕೋಶಗಳ ಜಾಲಗಳು. ಮೆದುಳಿನಲ್ಲಿ ಸಂಭವಿಸುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಅಧ್ಯಯನ ಮಾಡುವಾಗ ಮತ್ತು ಈ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ರೂಪಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ಈ ಪರಿಕಲ್ಪನೆಯು ಹುಟ್ಟಿಕೊಂಡಿತು.
ನರಗಳ ಜಾಲಗಳು ಪದದ ಸಾಮಾನ್ಯ ಅರ್ಥದಲ್ಲಿ ಪ್ರೋಗ್ರಾಮ್ ಮಾಡಲಾಗಿಲ್ಲ, ಅವು ತರಬೇತಿ ಪಡೆದಿವೆ. ಕಲಿಯುವ ಸಾಮರ್ಥ್ಯವು ಸಾಂಪ್ರದಾಯಿಕ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ಮೇಲೆ ನರ ಜಾಲಗಳ ಮುಖ್ಯ ಪ್ರಯೋಜನಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ತಾಂತ್ರಿಕವಾಗಿ, ಕಲಿಕೆಯು ನರಕೋಶಗಳ ನಡುವಿನ ಸಂಪರ್ಕಗಳ ಗುಣಾಂಕಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ತರಬೇತಿ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ನರಮಂಡಲವು ಇನ್ಪುಟ್ ಡೇಟಾ ಮತ್ತು ಔಟ್ಪುಟ್ ಡೇಟಾದ ನಡುವಿನ ಸಂಕೀರ್ಣ ಅವಲಂಬನೆಗಳನ್ನು ಗುರುತಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಜೊತೆಗೆ ಸಾಮಾನ್ಯೀಕರಣವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
ಯಂತ್ರ ಕಲಿಕೆಯ ದೃಷ್ಟಿಕೋನದಿಂದ, ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಮಾದರಿ ಗುರುತಿಸುವಿಕೆ ವಿಧಾನಗಳು, ತಾರತಮ್ಯ ವಿಶ್ಲೇಷಣೆ, ಕ್ಲಸ್ಟರಿಂಗ್ ವಿಧಾನಗಳು ಮತ್ತು ಇತರ ವಿಧಾನಗಳ ವಿಶೇಷ ಪ್ರಕರಣವಾಗಿದೆ.
ಸಲಕರಣೆ
ಮೊದಲಿಗೆ, ಸಲಕರಣೆಗಳನ್ನು ನೋಡೋಣ. ನಮಗೆ ಲಿನಕ್ಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿದ ಸರ್ವರ್ ಅಗತ್ಯವಿದೆ. ಯಂತ್ರ ಕಲಿಕೆ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಗತ್ಯವಿರುವ ಉಪಕರಣಗಳು ಸಾಕಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿದೆ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ, ದುಬಾರಿಯಾಗಿದೆ. ಕೈಯಲ್ಲಿ ಉತ್ತಮ ಯಂತ್ರವನ್ನು ಹೊಂದಿರದವರಿಗೆ, ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರ ಕೊಡುಗೆಗಳಿಗೆ ಗಮನ ಕೊಡಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ. ನೀವು ಅಗತ್ಯವಿರುವ ಸರ್ವರ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಬಾಡಿಗೆಗೆ ಪಡೆಯಬಹುದು ಮತ್ತು ಬಳಕೆಯ ಸಮಯಕ್ಕೆ ಮಾತ್ರ ಪಾವತಿಸಬಹುದು.
ನರಮಂಡಲವನ್ನು ರಚಿಸಲು ಅಗತ್ಯವಿರುವ ಯೋಜನೆಗಳಲ್ಲಿ, ನಾನು ರಷ್ಯಾದ ಕ್ಲೌಡ್ ಪೂರೈಕೆದಾರರ ಸರ್ವರ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇನೆ. ಕಂಪನಿಯು ಎನ್‌ವಿಡಿಯಾದಿಂದ ಶಕ್ತಿಯುತವಾದ ಟೆಸ್ಲಾ ವಿ100 ಗ್ರಾಫಿಕ್ಸ್ ಪ್ರೊಸೆಸರ್‌ಗಳೊಂದಿಗೆ (ಜಿಪಿಯು) ಯಂತ್ರ ಕಲಿಕೆಗಾಗಿ ನಿರ್ದಿಷ್ಟವಾಗಿ ಕ್ಲೌಡ್ ಸರ್ವರ್‌ಗಳನ್ನು ಬಾಡಿಗೆಗೆ ನೀಡುತ್ತದೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ: ಲೆಕ್ಕಾಚಾರಗಳಿಗಾಗಿ CPU (ಪ್ರಸಿದ್ಧ ಕೇಂದ್ರೀಯ ಸಂಸ್ಕರಣಾ ಘಟಕ) ಬಳಸುವ ಒಂದೇ ರೀತಿಯ ವೆಚ್ಚದ ಸರ್ವರ್‌ಗೆ ಹೋಲಿಸಿದರೆ GPU ನೊಂದಿಗೆ ಸರ್ವರ್ ಅನ್ನು ಬಳಸುವುದು ಹತ್ತಾರು ಪಟ್ಟು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ (ವೇಗವಾಗಿ). ಜಿಪಿಯು ಆರ್ಕಿಟೆಕ್ಚರ್‌ನ ವೈಶಿಷ್ಟ್ಯಗಳಿಂದಾಗಿ ಇದನ್ನು ಸಾಧಿಸಲಾಗುತ್ತದೆ, ಇದು ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ವೇಗವಾಗಿ ನಿಭಾಯಿಸುತ್ತದೆ.
ಕೆಳಗೆ ವಿವರಿಸಿದ ಉದಾಹರಣೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಾವು ಹಲವಾರು ದಿನಗಳವರೆಗೆ ಕೆಳಗಿನ ಸರ್ವರ್ ಅನ್ನು ಖರೀದಿಸಿದ್ದೇವೆ:
- SSD ಡಿಸ್ಕ್ 150 GB
- RAM 32 GB
- Tesla V100 16 Gb ಪ್ರೊಸೆಸರ್ ಜೊತೆಗೆ 4 ಕೋರ್
ನಾವು ನಮ್ಮ ಗಣಕದಲ್ಲಿ ಉಬುಂಟು 18.04 ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದೇವೆ.
ಪರಿಸರವನ್ನು ಹೊಂದಿಸುವುದು
ಈಗ ಸರ್ವರ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಸ್ಥಾಪಿಸೋಣ. ನಮ್ಮ ಲೇಖನವು ಪ್ರಾಥಮಿಕವಾಗಿ ಆರಂಭಿಕರಿಗಾಗಿ ಆಗಿರುವುದರಿಂದ, ಅವರಿಗೆ ಉಪಯುಕ್ತವಾದ ಕೆಲವು ಅಂಶಗಳ ಬಗ್ಗೆ ನಾನು ಮಾತನಾಡುತ್ತೇನೆ.
ಪರಿಸರವನ್ನು ಹೊಂದಿಸುವಾಗ ಬಹಳಷ್ಟು ಕೆಲಸವನ್ನು ಆಜ್ಞಾ ಸಾಲಿನ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ಬಳಕೆದಾರರು ವಿಂಡೋಸ್ ಅನ್ನು ತಮ್ಮ ಕೆಲಸದ ಓಎಸ್ ಆಗಿ ಬಳಸುತ್ತಾರೆ. ಈ OS ನಲ್ಲಿನ ಪ್ರಮಾಣಿತ ಕನ್ಸೋಲ್ ಅಪೇಕ್ಷಿತವಾಗಿರುವುದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. ಆದ್ದರಿಂದ, ನಾವು ಅನುಕೂಲಕರ ಸಾಧನವನ್ನು ಬಳಸುತ್ತೇವೆ . ಮಿನಿ ಆವೃತ್ತಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು Cmder.exe ಅನ್ನು ರನ್ ಮಾಡಿ. ಮುಂದೆ ನೀವು SSH ಮೂಲಕ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಬೇಕು:
ssh root@server-ip-or-hostnameಸರ್ವರ್-ಐಪಿ-ಅಥವಾ-ಹೋಸ್ಟ್ ಹೆಸರಿನ ಬದಲಿಗೆ, ನಿಮ್ಮ ಸರ್ವರ್‌ನ ಐಪಿ ವಿಳಾಸ ಅಥವಾ ಡಿಎನ್‌ಎಸ್ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ. ಮುಂದೆ, ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಸಂಪರ್ಕವು ಯಶಸ್ವಿಯಾದರೆ, ನಾವು ಇದೇ ರೀತಿಯ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಬೇಕು.
Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)ML ಮಾದರಿಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಮುಖ್ಯ ಭಾಷೆ ಪೈಥಾನ್ ಆಗಿದೆ. ಮತ್ತು Linux ನಲ್ಲಿ ಅದರ ಬಳಕೆಗಾಗಿ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ವೇದಿಕೆಯಾಗಿದೆ .
ಅದನ್ನು ನಮ್ಮ ಸರ್ವರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸೋಣ.
ನಾವು ಸ್ಥಳೀಯ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ನವೀಕರಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:
sudo apt-get updateಕರ್ಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ (ಕಮಾಂಡ್ ಲೈನ್ ಉಪಯುಕ್ತತೆ):
sudo apt-get install curlಅನಕೊಂಡ ಡಿಸ್ಟ್ರಿಬ್ಯೂಷನ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ:
cd /tmp
curl –O https://repo.anaconda.com/archive/Anaconda3-2019.10-Linux-x86_64.shಅನುಸ್ಥಾಪನೆಯನ್ನು ಪ್ರಾರಂಭಿಸೋಣ:
bash Anaconda3-2019.10-Linux-x86_64.shಅನುಸ್ಥಾಪನಾ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ, ಪರವಾನಗಿ ಒಪ್ಪಂದವನ್ನು ಖಚಿತಪಡಿಸಲು ನಿಮ್ಮನ್ನು ಕೇಳಲಾಗುತ್ತದೆ. ಯಶಸ್ವಿ ಅನುಸ್ಥಾಪನೆಯ ನಂತರ ನೀವು ಇದನ್ನು ನೋಡಬೇಕು:
Thank you for installing Anaconda3!ML ಮಾದರಿಗಳ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಈಗ ಅನೇಕ ಚೌಕಟ್ಟುಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ; ನಾವು ಹೆಚ್ಚು ಜನಪ್ರಿಯವಾದವುಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ: и .
ಚೌಕಟ್ಟನ್ನು ಬಳಸುವುದರಿಂದ ಅಭಿವೃದ್ಧಿಯ ವೇಗವನ್ನು ಹೆಚ್ಚಿಸಲು ಮತ್ತು ಪ್ರಮಾಣಿತ ಕಾರ್ಯಗಳಿಗಾಗಿ ಸಿದ್ಧ ಸಾಧನಗಳನ್ನು ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ನಾವು PyTorch ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ. ಅದನ್ನು ಸ್ಥಾಪಿಸೋಣ:
conda install pytorch torchvision cudatoolkit=10.1 -c pytorchಈಗ ನಾವು ಎಂಎಲ್ ತಜ್ಞರಿಗೆ ಜನಪ್ರಿಯ ಅಭಿವೃದ್ಧಿ ಸಾಧನವಾದ ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗಿದೆ. ಇದು ಕೋಡ್ ಅನ್ನು ಬರೆಯಲು ಮತ್ತು ಅದರ ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ತಕ್ಷಣವೇ ನೋಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಜೂಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ಅನಕೊಂಡದೊಂದಿಗೆ ಸೇರಿಸಲಾಗಿದೆ ಮತ್ತು ಈಗಾಗಲೇ ನಮ್ಮ ಸರ್ವರ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ. ನಮ್ಮ ಡೆಸ್ಕ್‌ಟಾಪ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ನೀವು ಅದನ್ನು ಸಂಪರ್ಕಿಸಬೇಕು.
ಇದನ್ನು ಮಾಡಲು, ನಾವು ಮೊದಲು ಪೋರ್ಟ್ 8080 ಅನ್ನು ಸೂಚಿಸುವ ಸರ್ವರ್‌ನಲ್ಲಿ ಜುಪಿಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ:
jupyter notebook --no-browser --port=8080 --allow-rootಮುಂದೆ, ನಮ್ಮ Cmder ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಮತ್ತೊಂದು ಟ್ಯಾಬ್ ತೆರೆಯುವುದು (ಟಾಪ್ ಮೆನು - ಹೊಸ ಕನ್ಸೋಲ್ ಡೈಲಾಗ್) ನಾವು ಪೋರ್ಟ್ 8080 ಮೂಲಕ SSH ಮೂಲಕ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸುತ್ತೇವೆ:
ssh -L 8080:localhost:8080 root@server-ip-or-hostnameನಾವು ಮೊದಲ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿದಾಗ, ನಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಜುಪಿಟರ್ ತೆರೆಯಲು ನಮಗೆ ಲಿಂಕ್‌ಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ:
To access the notebook, open this file in a browser:
file:///root/.local/share/jupyter/runtime/nbserver-18788-open.html
Or copy and paste one of these URLs:
http://localhost:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
or http://127.0.0.1:8080/?token=cca0bd0b30857821194b9018a5394a4ed2322236f116d311
ಲೋಕಲ್ ಹೋಸ್ಟ್:8080 ಗಾಗಿ ಲಿಂಕ್ ಅನ್ನು ಬಳಸೋಣ. ಪೂರ್ಣ ಮಾರ್ಗವನ್ನು ನಕಲಿಸಿ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ PC ಯ ಸ್ಥಳೀಯ ಬ್ರೌಸರ್‌ನ ವಿಳಾಸ ಪಟ್ಟಿಗೆ ಅಂಟಿಸಿ. ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ತೆರೆಯುತ್ತದೆ.
ಹೊಸ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ರಚಿಸೋಣ: ಹೊಸ - ನೋಟ್‌ಬುಕ್ - ಪೈಥಾನ್ 3.
ನಾವು ಸ್ಥಾಪಿಸಿದ ಎಲ್ಲಾ ಘಟಕಗಳ ಸರಿಯಾದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಶೀಲಿಸೋಣ. ನಾವು ಉದಾಹರಣೆ PyTorch ಕೋಡ್ ಅನ್ನು Jupyter ಗೆ ನಮೂದಿಸಿ ಮತ್ತು ಎಕ್ಸಿಕ್ಯೂಶನ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ (ರನ್ ಬಟನ್):
from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)
ಫಲಿತಾಂಶವು ಈ ರೀತಿ ಇರಬೇಕು:
ನೀವು ಇದೇ ರೀತಿಯ ಫಲಿತಾಂಶವನ್ನು ಹೊಂದಿದ್ದರೆ, ನಾವು ಎಲ್ಲವನ್ನೂ ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇವೆ ಮತ್ತು ನಾವು ನರಮಂಡಲವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ಪ್ರಾರಂಭಿಸಬಹುದು!
ನರಮಂಡಲವನ್ನು ರಚಿಸುವುದು
ಚಿತ್ರ ಗುರುತಿಸುವಿಕೆಗಾಗಿ ನಾವು ನರಮಂಡಲವನ್ನು ರಚಿಸುತ್ತೇವೆ. ಇದನ್ನು ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಳ್ಳೋಣ .
ನೆಟ್ವರ್ಕ್ಗೆ ತರಬೇತಿ ನೀಡಲು ನಾವು ಸಾರ್ವಜನಿಕವಾಗಿ ಲಭ್ಯವಿರುವ CIFAR10 ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಇದು ತರಗತಿಗಳನ್ನು ಹೊಂದಿದೆ: "ವಿಮಾನ", "ಕಾರು", "ಪಕ್ಷಿ", "ಬೆಕ್ಕು", "ಜಿಂಕೆ", "ನಾಯಿ", "ಕಪ್ಪೆ", "ಕುದುರೆ", "ಹಡಗು", "ಟ್ರಕ್". CIFAR10 ನಲ್ಲಿನ ಚಿತ್ರಗಳು 3x32x32, ಅಂದರೆ, 3x32 ಪಿಕ್ಸೆಲ್‌ಗಳ 32-ಚಾನಲ್ ಬಣ್ಣದ ಚಿತ್ರಗಳು.
ಕೆಲಸಕ್ಕಾಗಿ, ನಾವು ಚಿತ್ರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು PyTorch ರಚಿಸಿದ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ - ಟಾರ್ಚ್ವಿಷನ್.
ನಾವು ಈ ಕೆಳಗಿನ ಕ್ರಮಗಳನ್ನು ಕ್ರಮವಾಗಿ ಮಾಡುತ್ತೇವೆ:
- ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷಾ ಡೇಟಾ ಸೆಟ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವುದು ಮತ್ತು ಸಾಮಾನ್ಯಗೊಳಿಸುವುದು
- ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ವ್ಯಾಖ್ಯಾನ
- ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ತರಬೇತಿ
- ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಪರೀಕ್ಷೆ
- GPU ಬಳಸಿಕೊಂಡು ತರಬೇತಿ ಮತ್ತು ಪರೀಕ್ಷೆಯನ್ನು ಪುನರಾವರ್ತಿಸೋಣ
ನಾವು ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್‌ನಲ್ಲಿ ಕೆಳಗಿನ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ.
CIFAR10 ಅನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ ಮತ್ತು ಸಾಮಾನ್ಯಗೊಳಿಸಲಾಗುತ್ತಿದೆ
ಜುಪಿಟರ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಿ ಮತ್ತು ರನ್ ಮಾಡಿ:
import torch
import torchvision
import torchvision.transforms as transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')ಉತ್ತರ ಹೀಗಿರಬೇಕು:
Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz
Extracting ./data/cifar-10-python.tar.gz to ./data
Files already downloaded and verifiedಪರೀಕ್ಷೆಗಾಗಿ ಹಲವಾರು ತರಬೇತಿ ಚಿತ್ರಗಳನ್ನು ಪ್ರದರ್ಶಿಸೋಣ:
import matplotlib.pyplot as plt
import numpy as np
# functions to show an image
def imshow(img):
img = img / 2 + 0.5 # unnormalize
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
plt.show()
# get some random training images
dataiter = iter(trainloader)
images, labels = dataiter.next()
# show images
imshow(torchvision.utils.make_grid(images))
# print labels
print(' '.join('%5s' % classes[labels[j]] for j in range(4)))
ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ವ್ಯಾಖ್ಯಾನ
ಚಿತ್ರ ಗುರುತಿಸುವಿಕೆಗಾಗಿ ನರಮಂಡಲವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಮೊದಲು ಪರಿಗಣಿಸೋಣ. ಇದು ಸರಳವಾದ ಪಾಯಿಂಟ್-ಟು-ಪಾಯಿಂಟ್ ನೆಟ್ವರ್ಕ್ ಆಗಿದೆ. ಇದು ಇನ್ಪುಟ್ ಡೇಟಾವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಹಲವಾರು ಲೇಯರ್‌ಗಳ ಮೂಲಕ ಒಂದೊಂದಾಗಿ ಹಾದುಹೋಗುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಔಟ್ಪುಟ್ ಡೇಟಾವನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.
ನಮ್ಮ ಪರಿಸರದಲ್ಲಿ ಇದೇ ರೀತಿಯ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ರಚಿಸೋಣ:
import torch.nn as nn
import torch.nn.functional as F
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(F.relu(self.conv1(x)))
x = self.pool(F.relu(self.conv2(x)))
x = x.view(-1, 16 * 5 * 5)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
net = Net()
ನಾವು ನಷ್ಟ ಕಾರ್ಯ ಮತ್ತು ಆಪ್ಟಿಮೈಜರ್ ಅನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)ತರಬೇತಿ ಡೇಟಾದಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ತರಬೇತಿ
ನಮ್ಮ ನರಮಂಡಲದ ತರಬೇತಿಯನ್ನು ಪ್ರಾರಂಭಿಸೋಣ. ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ಕೆಲಸವು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ನೀವು ಸ್ವಲ್ಪ ಸಮಯ ಕಾಯಬೇಕಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಇದು ನನಗೆ 5 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ನೆಟ್ವರ್ಕ್ಗೆ ತರಬೇತಿ ನೀಡಲು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')
ನಾವು ಈ ಕೆಳಗಿನ ಫಲಿತಾಂಶವನ್ನು ಪಡೆಯುತ್ತೇವೆ:
ನಮ್ಮ ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಯನ್ನು ನಾವು ಉಳಿಸುತ್ತೇವೆ:
PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)ಪರೀಕ್ಷಾ ಡೇಟಾದಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಪರೀಕ್ಷೆ
ತರಬೇತಿ ಡೇಟಾವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ನೆಟ್ವರ್ಕ್ಗೆ ತರಬೇತಿ ನೀಡಿದ್ದೇವೆ. ಆದರೆ ನೆಟ್ವರ್ಕ್ ಏನನ್ನಾದರೂ ಕಲಿತಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸಬೇಕಾಗಿದೆ.
ನ್ಯೂರಲ್ ನೆಟ್ವರ್ಕ್ ಔಟ್ಪುಟ್ ಮಾಡುವ ಕ್ಲಾಸ್ ಲೇಬಲ್ ಅನ್ನು ಊಹಿಸುವ ಮೂಲಕ ಮತ್ತು ಅದು ನಿಜವೇ ಎಂದು ಪರೀಕ್ಷಿಸುವ ಮೂಲಕ ನಾವು ಇದನ್ನು ಪರೀಕ್ಷಿಸುತ್ತೇವೆ. ಭವಿಷ್ಯವು ಸರಿಯಾಗಿದ್ದರೆ, ನಾವು ಮಾದರಿಯನ್ನು ಸರಿಯಾದ ಮುನ್ನೋಟಗಳ ಪಟ್ಟಿಗೆ ಸೇರಿಸುತ್ತೇವೆ.
ಪರೀಕ್ಷಾ ಸೆಟ್‌ನಿಂದ ಚಿತ್ರವನ್ನು ತೋರಿಸೋಣ:
dataiter = iter(testloader)
images, labels = dataiter.next()
# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join('%5s' % classes[labels[j]] for j in range(4)))
ಈಗ ಈ ಚಿತ್ರಗಳಲ್ಲಿ ಏನಿದೆ ಎಂದು ಹೇಳಲು ನರಮಂಡಲವನ್ನು ಕೇಳೋಣ:
net = Net()
net.load_state_dict(torch.load(PATH))
outputs = net(images)
_, predicted = torch.max(outputs, 1)
print('Predicted: ', ' '.join('%5s' % classes[predicted[j]]
for j in range(4)))
ಫಲಿತಾಂಶಗಳು ತುಂಬಾ ಚೆನ್ನಾಗಿವೆ: ನೆಟ್ವರ್ಕ್ ನಾಲ್ಕು ಚಿತ್ರಗಳಲ್ಲಿ ಮೂರನ್ನು ಸರಿಯಾಗಿ ಗುರುತಿಸಿದೆ.
ಇಡೀ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ.
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))
ನೆಟ್ವರ್ಕ್ಗೆ ಏನೋ ತಿಳಿದಿದೆ ಮತ್ತು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂದು ತೋರುತ್ತಿದೆ. ಅವನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ತರಗತಿಗಳನ್ನು ನಿರ್ಧರಿಸಿದರೆ, ನಿಖರತೆ 10% ಆಗಿರುತ್ತದೆ.
ನೆಟ್ವರ್ಕ್ ಯಾವ ವರ್ಗಗಳನ್ನು ಉತ್ತಮವಾಗಿ ಗುರುತಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಈಗ ನೋಡೋಣ:
class_correct = list(0. for i in range(10))
class_total = list(0. for i in range(10))
with torch.no_grad():
for data in testloader:
images, labels = data
outputs = net(images)
_, predicted = torch.max(outputs, 1)
c = (predicted == labels).squeeze()
for i in range(4):
label = labels[i]
class_correct[label] += c[i].item()
class_total[label] += 1
for i in range(10):
print('Accuracy of %5s : %2d %%' % (
classes[i], 100 * class_correct[i] / class_total[i]))
ಕಾರುಗಳು ಮತ್ತು ಹಡಗುಗಳನ್ನು ಗುರುತಿಸುವಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಉತ್ತಮವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ: 71% ನಿಖರತೆ.
ಆದ್ದರಿಂದ ನೆಟ್ವರ್ಕ್ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ. ಈಗ ಅದರ ಕೆಲಸವನ್ನು ಗ್ರಾಫಿಕ್ಸ್ ಪ್ರೊಸೆಸರ್ (ಜಿಪಿಯು) ಗೆ ವರ್ಗಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ ಮತ್ತು ಯಾವ ಬದಲಾವಣೆಗಳನ್ನು ನೋಡೋಣ.
GPU ನಲ್ಲಿ ನರಮಂಡಲದ ತರಬೇತಿ
ಮೊದಲಿಗೆ, CUDA ಎಂದರೇನು ಎಂದು ನಾನು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ವಿವರಿಸುತ್ತೇನೆ. CUDA (ಕಂಪ್ಯೂಟ್ ಯುನಿಫೈಡ್ ಡಿವೈಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್) ಗ್ರಾಫಿಕ್ಸ್ ಪ್ರೊಸೆಸಿಂಗ್ ಯೂನಿಟ್‌ಗಳ (ಜಿಪಿಯುಗಳು) ಸಾಮಾನ್ಯ ಕಂಪ್ಯೂಟಿಂಗ್‌ಗಾಗಿ ಎನ್‌ವಿಡಿಯಾ ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಸಮಾನಾಂತರ ಕಂಪ್ಯೂಟಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಆಗಿದೆ. CUDA ಯೊಂದಿಗೆ, ಡೆವಲಪರ್‌ಗಳು GPU ಗಳ ಶಕ್ತಿಯನ್ನು ಹೆಚ್ಚಿಸುವ ಮೂಲಕ ಕಂಪ್ಯೂಟಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಾಟಕೀಯವಾಗಿ ವೇಗಗೊಳಿಸಬಹುದು. ನಾವು ಖರೀದಿಸಿದ ನಮ್ಮ ಸರ್ವರ್‌ನಲ್ಲಿ ಈ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಈಗಾಗಲೇ ಸ್ಥಾಪಿಸಲಾಗಿದೆ.
ನಾವು ಮೊದಲು ನಮ್ಮ GPU ಅನ್ನು ಮೊದಲ ಗೋಚರ cuda ಸಾಧನವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸೋಣ.
device = torch . device ( "cuda:0" if torch . cuda . is_available () else "cpu" )
# Assuming that we are on a CUDA machine, this should print a CUDA device:
print ( device )
ನೆಟ್ವರ್ಕ್ ಅನ್ನು GPU ಗೆ ಕಳುಹಿಸಲಾಗುತ್ತಿದೆ:
net.to(device)ನಾವು ಪ್ರತಿ ಹಂತದಲ್ಲೂ ಇನ್‌ಪುಟ್‌ಗಳು ಮತ್ತು ಗುರಿಗಳನ್ನು GPU ಗೆ ಕಳುಹಿಸಬೇಕಾಗುತ್ತದೆ:
inputs, labels = data[0].to(device), data[1].to(device)GPU ನಲ್ಲಿ ನೆಟ್ವರ್ಕ್ ಅನ್ನು ಮರು-ತರಬೇತಿ ಮಾಡೋಣ:
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)
for epoch in range(2): # loop over the dataset multiple times
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# get the inputs; data is a list of [inputs, labels]
inputs, labels = data[0].to(device), data[1].to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss = 0.0
print('Finished Training')ಈ ಸಮಯದಲ್ಲಿ, ನೆಟ್ವರ್ಕ್ ತರಬೇತಿಯು ಸುಮಾರು 3 ನಿಮಿಷಗಳ ಕಾಲ ನಡೆಯಿತು. ಸಾಂಪ್ರದಾಯಿಕ ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಅದೇ ಹಂತವು 5 ನಿಮಿಷಗಳವರೆಗೆ ಇರುತ್ತದೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳೋಣ. ವ್ಯತ್ಯಾಸವು ಗಮನಾರ್ಹವಾಗಿಲ್ಲ, ನಮ್ಮ ನೆಟ್ವರ್ಕ್ ಅಷ್ಟು ದೊಡ್ಡದಲ್ಲದ ಕಾರಣ ಇದು ಸಂಭವಿಸುತ್ತದೆ. ತರಬೇತಿಗಾಗಿ ದೊಡ್ಡ ಶ್ರೇಣಿಗಳನ್ನು ಬಳಸುವಾಗ, GPU ಮತ್ತು ಸಾಂಪ್ರದಾಯಿಕ ಪ್ರೊಸೆಸರ್ ವೇಗದ ನಡುವಿನ ವ್ಯತ್ಯಾಸವು ಹೆಚ್ಚಾಗುತ್ತದೆ.
ಅದು ಎಲ್ಲ ಎಂದು ತೋರುತ್ತದೆ. ನಾವು ಏನು ಮಾಡಿದ್ದೇವೆ:
- ನಾವು ಜಿಪಿಯು ಏನೆಂದು ನೋಡಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ಸ್ಥಾಪಿಸಿದ ಸರ್ವರ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇವೆ;
- ನರಮಂಡಲವನ್ನು ರಚಿಸಲು ನಾವು ಸಾಫ್ಟ್‌ವೇರ್ ಪರಿಸರವನ್ನು ಹೊಂದಿಸಿದ್ದೇವೆ;
- ಚಿತ್ರ ಗುರುತಿಸುವಿಕೆಗಾಗಿ ನಾವು ನರಮಂಡಲವನ್ನು ರಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದಕ್ಕೆ ತರಬೇತಿ ನೀಡಿದ್ದೇವೆ;
- ನಾವು GPU ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೆಟ್ವರ್ಕ್ ತರಬೇತಿಯನ್ನು ಪುನರಾವರ್ತಿಸಿದ್ದೇವೆ ಮತ್ತು ವೇಗದಲ್ಲಿ ಹೆಚ್ಚಳವನ್ನು ಸ್ವೀಕರಿಸಿದ್ದೇವೆ.
ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ನಾನು ಸಂತೋಷಪಡುತ್ತೇನೆ.
ಮೂಲ: www.habr.com