ਗ੍ਰਾਫਿਕਸ ਪ੍ਰੋਸੈਸਿੰਗ ਯੂਨਿਟ (GPU) 'ਤੇ ਤੁਹਾਡਾ ਪਹਿਲਾ ਨਿਊਰਲ ਨੈੱਟਵਰਕ। ਸ਼ੁਰੂਆਤੀ ਗਾਈਡ

ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਤੁਹਾਨੂੰ ਦੱਸਾਂਗਾ ਕਿ ਕਿਵੇਂ 30 ਮਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਵਾਤਾਵਰਨ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ, ਚਿੱਤਰ ਪਛਾਣ ਲਈ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ ਹੈ, ਅਤੇ ਫਿਰ ਉਸੇ ਨੈੱਟਵਰਕ ਨੂੰ ਗ੍ਰਾਫਿਕਸ ਪ੍ਰੋਸੈਸਰ (GPU) 'ਤੇ ਚਲਾਉਣਾ ਹੈ।

ਪਹਿਲਾਂ, ਆਓ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ ਕਿ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਕੀ ਹੈ।

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇਹ ਇੱਕ ਗਣਿਤਿਕ ਮਾਡਲ ਹੈ, ਨਾਲ ਹੀ ਇਸਦੇ ਸੌਫਟਵੇਅਰ ਜਾਂ ਹਾਰਡਵੇਅਰ ਦਾ ਰੂਪ ਹੈ, ਜੋ ਕਿ ਜੀਵ-ਵਿਗਿਆਨਕ ਤੰਤੂ ਨੈਟਵਰਕਾਂ ਦੇ ਸੰਗਠਨ ਅਤੇ ਕੰਮਕਾਜ ਦੇ ਸਿਧਾਂਤ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ - ਇੱਕ ਜੀਵਤ ਜੀਵ ਦੇ ਨਰਵ ਸੈੱਲਾਂ ਦੇ ਨੈਟਵਰਕ. ਇਹ ਧਾਰਨਾ ਦਿਮਾਗ ਵਿੱਚ ਹੋਣ ਵਾਲੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦਾ ਅਧਿਐਨ ਕਰਨ ਅਤੇ ਇਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਮਾਡਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਪੈਦਾ ਹੋਈ।

ਨਿਊਰਲ ਨੈਟਵਰਕ ਸ਼ਬਦ ਦੇ ਆਮ ਅਰਥਾਂ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਨਹੀਂ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਸਿਖਲਾਈ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਸਿੱਖਣ ਦੀ ਯੋਗਤਾ ਪਰੰਪਰਾਗਤ ਐਲਗੋਰਿਦਮ ਨਾਲੋਂ ਨਿਊਰਲ ਨੈਟਵਰਕ ਦੇ ਮੁੱਖ ਫਾਇਦਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਤਕਨੀਕੀ ਤੌਰ 'ਤੇ, ਸਿੱਖਣ ਵਿੱਚ ਨਿਊਰੋਨਸ ਦੇ ਵਿਚਕਾਰ ਕੁਨੈਕਸ਼ਨਾਂ ਦੇ ਗੁਣਾਂ ਨੂੰ ਲੱਭਣਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਸਿਖਲਾਈ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ, ਨਿਊਰਲ ਨੈਟਵਰਕ ਇਨਪੁਟ ਡੇਟਾ ਅਤੇ ਆਉਟਪੁੱਟ ਡੇਟਾ ਦੇ ਵਿਚਕਾਰ ਗੁੰਝਲਦਾਰ ਨਿਰਭਰਤਾ ਦੀ ਪਛਾਣ ਕਰਨ ਦੇ ਨਾਲ-ਨਾਲ ਸਧਾਰਣਕਰਨ ਕਰਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ।

ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇੱਕ ਨਿਊਰਲ ਨੈਟਵਰਕ ਪੈਟਰਨ ਮਾਨਤਾ ਵਿਧੀਆਂ, ਵਿਤਕਰੇ ਦੇ ਵਿਸ਼ਲੇਸ਼ਣ, ਕਲੱਸਟਰਿੰਗ ਵਿਧੀਆਂ ਅਤੇ ਹੋਰ ਤਰੀਕਿਆਂ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕੇਸ ਹੈ।

ਉਪਕਰਣ

ਪਹਿਲਾਂ, ਆਓ ਸਾਜ਼-ਸਾਮਾਨ ਨੂੰ ਵੇਖੀਏ. ਸਾਨੂੰ ਇਸ 'ਤੇ ਸਥਾਪਿਤ ਲੀਨਕਸ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਾਲਾ ਸਰਵਰ ਚਾਹੀਦਾ ਹੈ। ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਚਲਾਉਣ ਲਈ ਲੋੜੀਂਦਾ ਉਪਕਰਣ ਕਾਫ਼ੀ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ ਅਤੇ ਨਤੀਜੇ ਵਜੋਂ, ਮਹਿੰਗਾ ਹੈ। ਉਹਨਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਕੋਲ ਹੱਥ ਵਿੱਚ ਚੰਗੀ ਮਸ਼ੀਨ ਨਹੀਂ ਹੈ, ਮੈਂ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾਵਾਂ ਦੀਆਂ ਪੇਸ਼ਕਸ਼ਾਂ ਵੱਲ ਧਿਆਨ ਦੇਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ. ਤੁਸੀਂ ਲੋੜੀਂਦੇ ਸਰਵਰ ਨੂੰ ਜਲਦੀ ਕਿਰਾਏ 'ਤੇ ਲੈ ਸਕਦੇ ਹੋ ਅਤੇ ਵਰਤੋਂ ਦੇ ਸਮੇਂ ਲਈ ਹੀ ਭੁਗਤਾਨ ਕਰ ਸਕਦੇ ਹੋ।

ਉਹਨਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਜਿੱਥੇ ਨਿਊਰਲ ਨੈਟਵਰਕ ਬਣਾਉਣਾ ਜ਼ਰੂਰੀ ਹੈ, ਮੈਂ ਰੂਸੀ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੇ ਸਰਵਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹਾਂ. ਕੰਪਨੀ NVIDIA ਤੋਂ ਸ਼ਕਤੀਸ਼ਾਲੀ Tesla V100 ਗ੍ਰਾਫਿਕਸ ਪ੍ਰੋਸੈਸਰਾਂ (GPU) ਨਾਲ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਲਈ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਕਿਰਾਏ 'ਤੇ ਕਲਾਉਡ ਸਰਵਰ ਪੇਸ਼ ਕਰਦੀ ਹੈ। ਸੰਖੇਪ ਵਿੱਚ: ਇੱਕ GPU ਦੇ ਨਾਲ ਇੱਕ ਸਰਵਰ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਮਾਨ ਲਾਗਤ ਵਾਲੇ ਸਰਵਰ ਦੀ ਤੁਲਨਾ ਵਿੱਚ ਕਈ ਗੁਣਾ ਵਧੇਰੇ ਕੁਸ਼ਲ (ਤੇਜ਼) ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਗਣਨਾ ਲਈ ਇੱਕ CPU (ਮਸ਼ਹੂਰ ਕੇਂਦਰੀ ਪ੍ਰੋਸੈਸਿੰਗ ਯੂਨਿਟ) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ GPU ਆਰਕੀਟੈਕਚਰ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਕਾਰਨ ਪ੍ਰਾਪਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ ਗਣਨਾਵਾਂ ਦਾ ਤੇਜ਼ੀ ਨਾਲ ਮੁਕਾਬਲਾ ਕਰਦਾ ਹੈ.

ਹੇਠਾਂ ਦਿੱਤੀਆਂ ਉਦਾਹਰਣਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਅਸੀਂ ਕਈ ਦਿਨਾਂ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ ਸਰਵਰ ਨੂੰ ਖਰੀਦਿਆ ਹੈ:

• SSD ਡਿਸਕ 150 GB
• ਰੈਮ 32 ਜੀ.ਬੀ
• ਟੇਸਲਾ V100 16 ਜੀਬੀ ਪ੍ਰੋਸੈਸਰ 4 ਕੋਰ ਦੇ ਨਾਲ

ਅਸੀਂ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਉਬੰਟੂ 18.04 ਸਥਾਪਿਤ ਕੀਤਾ ਹੈ।

ਵਾਤਾਵਰਣ ਦੀ ਸਥਾਪਨਾ

ਆਉ ਹੁਣ ਸਰਵਰ ਤੇ ਕੰਮ ਲਈ ਲੋੜੀਂਦੀ ਹਰ ਚੀਜ਼ ਨੂੰ ਸਥਾਪਿਤ ਕਰੀਏ. ਕਿਉਂਕਿ ਸਾਡਾ ਲੇਖ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂਆਤ ਕਰਨ ਵਾਲਿਆਂ ਲਈ ਹੈ, ਮੈਂ ਕੁਝ ਨੁਕਤਿਆਂ ਬਾਰੇ ਗੱਲ ਕਰਾਂਗਾ ਜੋ ਉਹਨਾਂ ਲਈ ਲਾਭਦਾਇਕ ਹੋਣਗੇ.

ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕਰਨ ਵੇਲੇ ਬਹੁਤ ਸਾਰਾ ਕੰਮ ਕਮਾਂਡ ਲਾਈਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜ਼ਿਆਦਾਤਰ ਉਪਭੋਗਤਾ ਵਿੰਡੋਜ਼ ਨੂੰ ਆਪਣੇ ਕੰਮ ਕਰਨ ਵਾਲੇ ਓਐਸ ਵਜੋਂ ਵਰਤਦੇ ਹਨ. ਇਸ OS ਵਿੱਚ ਮਿਆਰੀ ਕੰਸੋਲ ਲੋੜੀਂਦੇ ਹੋਣ ਲਈ ਬਹੁਤ ਕੁਝ ਛੱਡਦਾ ਹੈ। ਇਸ ਲਈ, ਅਸੀਂ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਸਾਧਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ Cmder/. ਮਿੰਨੀ ਸੰਸਕਰਣ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ ਅਤੇ Cmder.exe ਚਲਾਓ। ਅੱਗੇ ਤੁਹਾਨੂੰ SSH ਦੁਆਰਾ ਸਰਵਰ ਨਾਲ ਜੁੜਨ ਦੀ ਲੋੜ ਹੈ:

ssh root@server-ip-or-hostname

ਸਰਵਰ-ਆਈਪੀ-ਜਾਂ-ਹੋਸਟਨਾਮ ਦੀ ਬਜਾਏ, ਆਪਣੇ ਸਰਵਰ ਦਾ IP ਪਤਾ ਜਾਂ DNS ਨਾਮ ਦਿਓ। ਅੱਗੇ, ਪਾਸਵਰਡ ਦਰਜ ਕਰੋ ਅਤੇ ਜੇਕਰ ਕੁਨੈਕਸ਼ਨ ਸਫਲ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਾਨੂੰ ਇਸ ਵਰਗਾ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

Welcome to Ubuntu 18.04.3 LTS (GNU/Linux 4.15.0-74-generic x86_64)

ML ਮਾਡਲਾਂ ਦੇ ਵਿਕਾਸ ਲਈ ਮੁੱਖ ਭਾਸ਼ਾ ਪਾਈਥਨ ਹੈ। ਅਤੇ ਲੀਨਕਸ ਉੱਤੇ ਇਸਦੀ ਵਰਤੋਂ ਲਈ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਪਲੇਟਫਾਰਮ ਹੈ ਐਨਾਕਾਂਡਾ.

ਆਓ ਇਸਨੂੰ ਸਾਡੇ ਸਰਵਰ 'ਤੇ ਸਥਾਪਿਤ ਕਰੀਏ।

ਅਸੀਂ ਸਥਾਨਕ ਪੈਕੇਜ ਮੈਨੇਜਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ:

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

ਹੁਣ ਸਾਨੂੰ Jupyter Notebook, ML ਮਾਹਿਰਾਂ ਲਈ ਇੱਕ ਪ੍ਰਸਿੱਧ ਵਿਕਾਸ ਸਾਧਨ ਲਾਂਚ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਹ ਤੁਹਾਨੂੰ ਕੋਡ ਲਿਖਣ ਅਤੇ ਇਸ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਨਤੀਜੇ ਤੁਰੰਤ ਦੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ ਐਨਾਕਾਂਡਾ ਦੇ ਨਾਲ ਸ਼ਾਮਲ ਹੈ ਅਤੇ ਸਾਡੇ ਸਰਵਰ 'ਤੇ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਸਥਾਪਿਤ ਹੈ। ਤੁਹਾਨੂੰ ਸਾਡੇ ਡੈਸਕਟਾਪ ਸਿਸਟਮ ਤੋਂ ਇਸ ਨਾਲ ਜੁੜਨ ਦੀ ਲੋੜ ਹੈ।

ਅਜਿਹਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਪਹਿਲਾਂ ਪੋਰਟ 8080 ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਵਾਲੇ ਸਰਵਰ 'ਤੇ Jupyter ਨੂੰ ਲਾਂਚ ਕਰਾਂਗੇ:

jupyter notebook --no-browser --port=8080 --allow-root

ਅੱਗੇ, ਸਾਡੇ Cmder ਕੰਸੋਲ (ਟੌਪ ਮੀਨੂ - ਨਵਾਂ ਕੰਸੋਲ ਡਾਇਲਾਗ) ਵਿੱਚ ਇੱਕ ਹੋਰ ਟੈਬ ਖੋਲ੍ਹਣ ਨਾਲ ਅਸੀਂ SSH ਰਾਹੀਂ ਸਰਵਰ ਨਾਲ ਪੋਰਟ 8080 ਰਾਹੀਂ ਕਨੈਕਟ ਕਰਾਂਗੇ:

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 ਲਈ ਲਿੰਕ ਦੀ ਵਰਤੋਂ ਕਰੀਏ। ਪੂਰੇ ਮਾਰਗ ਨੂੰ ਕਾਪੀ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਆਪਣੇ ਪੀਸੀ ਦੇ ਸਥਾਨਕ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਐਡਰੈੱਸ ਬਾਰ ਵਿੱਚ ਪੇਸਟ ਕਰੋ। ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ ਖੁੱਲ੍ਹ ਜਾਵੇਗੀ।

ਚਲੋ ਇੱਕ ਨਵੀਂ ਨੋਟਬੁੱਕ ਬਣਾਈਏ: ਨਵੀਂ - ਨੋਟਬੁੱਕ - ਪਾਈਥਨ 3।

ਆਉ ਅਸੀਂ ਸਥਾਪਿਤ ਕੀਤੇ ਸਾਰੇ ਭਾਗਾਂ ਦੀ ਸਹੀ ਕਾਰਵਾਈ ਦੀ ਜਾਂਚ ਕਰੀਏ। ਚਲੋ ਜੁਪੀਟਰ ਵਿੱਚ ਉਦਾਹਰਨ ਪਾਈਟੋਰਚ ਕੋਡ ਦਰਜ ਕਰੀਏ ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ (ਰਨ ਬਟਨ) ਨੂੰ ਚਲਾਓ:

from __future__ import print_function
import torch
x = torch.rand(5, 3)
print(x)

ਨਤੀਜਾ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਇੱਕ ਸਮਾਨ ਨਤੀਜਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਸਭ ਕੁਝ ਸਹੀ ਢੰਗ ਨਾਲ ਕੌਂਫਿਗਰ ਕਰ ਲਿਆ ਹੈ ਅਤੇ ਅਸੀਂ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿਕਸਿਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ!

ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ

ਅਸੀਂ ਚਿੱਤਰ ਪਛਾਣ ਲਈ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਵਾਂਗੇ। ਚਲੋ ਇਸ ਨੂੰ ਇੱਕ ਅਧਾਰ ਵਜੋਂ ਲੈਂਦੇ ਹਾਂ ਅਗਵਾਈ.

ਅਸੀਂ ਨੈੱਟਵਰਕ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਜਨਤਕ ਤੌਰ 'ਤੇ ਉਪਲਬਧ CIFAR10 ਡੇਟਾਸੈਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇਸ ਦੀਆਂ ਕਲਾਸਾਂ ਹਨ: “ਹਵਾਈ ਜਹਾਜ਼”, “ਕਾਰ”, “ਪੰਛੀ”, “ਬਿੱਲੀ”, “ਹਿਰਨ”, “ਕੁੱਤਾ”, “ਡੱਡੂ”, “ਘੋੜਾ”, “ਜਹਾਜ਼”, “ਟਰੱਕ”। CIFAR10 ਵਿੱਚ ਚਿੱਤਰ 3x32x32 ਹਨ, ਯਾਨੀ 3x32 ਪਿਕਸਲ ਦੇ 32-ਚੈਨਲ ਰੰਗ ਚਿੱਤਰ।

ਕੰਮ ਲਈ, ਅਸੀਂ ਚਿੱਤਰਾਂ - torchvision ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ 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) ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਾਂ ਅਤੇ ਦੇਖਦੇ ਹਾਂ ਕਿ ਕੀ ਬਦਲਾਅ ਹੁੰਦੇ ਹਨ।

GPU 'ਤੇ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਸਿਖਲਾਈ

ਪਹਿਲਾਂ, ਮੈਂ ਸੰਖੇਪ ਵਿੱਚ ਦੱਸਾਂਗਾ ਕਿ CUDA ਕੀ ਹੈ. CUDA (ਕੰਪਿਊਟ ਯੂਨੀਫਾਈਡ ਡਿਵਾਈਸ ਆਰਕੀਟੈਕਚਰ) ਇੱਕ ਸਮਾਨਾਂਤਰ ਕੰਪਿਊਟਿੰਗ ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ NVIDIA ਦੁਆਰਾ ਗ੍ਰਾਫਿਕਸ ਪ੍ਰੋਸੈਸਿੰਗ ਯੂਨਿਟਾਂ (GPUs) 'ਤੇ ਜਨਰਲ ਕੰਪਿਊਟਿੰਗ ਲਈ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਹੈ। CUDA ਨਾਲ, ਡਿਵੈਲਪਰ GPUs ਦੀ ਸ਼ਕਤੀ ਦਾ ਲਾਭ ਉਠਾ ਕੇ ਕੰਪਿਊਟਿੰਗ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਨਾਟਕੀ ਢੰਗ ਨਾਲ ਤੇਜ਼ ਕਰ ਸਕਦੇ ਹਨ। ਇਹ ਪਲੇਟਫਾਰਮ ਸਾਡੇ ਸਰਵਰ 'ਤੇ ਪਹਿਲਾਂ ਹੀ ਸਥਾਪਿਤ ਹੈ ਜੋ ਅਸੀਂ ਖਰੀਦਿਆ ਹੈ।

ਚਲੋ ਪਹਿਲਾਂ ਸਾਡੇ 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 ਕੀ ਹੈ ਅਤੇ ਸਰਵਰ ਨੂੰ ਚੁਣਿਆ ਹੈ ਜਿਸ 'ਤੇ ਇਹ ਸਥਾਪਿਤ ਹੈ;
• ਅਸੀਂ ਇੱਕ ਨਿਊਰਲ ਨੈਟਵਰਕ ਬਣਾਉਣ ਲਈ ਇੱਕ ਸਾਫਟਵੇਅਰ ਵਾਤਾਵਰਣ ਸਥਾਪਤ ਕੀਤਾ ਹੈ;
• ਅਸੀਂ ਚਿੱਤਰ ਪਛਾਣ ਲਈ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਇਆ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਿਖਲਾਈ ਦਿੱਤੀ ਹੈ;
• ਅਸੀਂ GPU ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਨੈੱਟਵਰਕ ਸਿਖਲਾਈ ਨੂੰ ਦੁਹਰਾਇਆ ਅਤੇ ਗਤੀ ਵਿੱਚ ਵਾਧਾ ਪ੍ਰਾਪਤ ਕੀਤਾ।

ਮੈਨੂੰ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇਣ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ.

ਸਰੋਤ: www.habr.com