10 ਅਪ੍ਰੈ 2025·8 ਮਿੰਟ
NVIDIA ਦਾ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਸਟੈਕ: GPUs, CUDA ਅਤੇ AI ਢਾਂਚਾ
ਜਾਣੋ ਕਿ NVIDIA GPUs ਅਤੇ CUDA ਨੇ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਕਿਵੇਂ ਸੰਭਵ ਬਣਾਈ, ਅਤੇ ਅੱਜ ਦਾ AI ਢਾਂਚਾ — ਚਿਪ, ਨੈਟਵਰਕਿੰਗ ਅਤੇ ਸਾਫਟਵੇਅਰ — ਆਧੁਨਿਕ ਤਕਨਾਲੋਜੀ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ।
ਜਾਣੋ ਕਿ NVIDIA GPUs ਅਤੇ CUDA ਨੇ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਕਿਵੇਂ ਸੰਭਵ ਬਣਾਈ, ਅਤੇ ਅੱਜ ਦਾ AI ਢਾਂਚਾ — ਚਿਪ, ਨੈਟਵਰਕਿੰਗ ਅਤੇ ਸਾਫਟਵੇਅਰ — ਆਧੁਨਿਕ ਤਕਨਾਲੋਜੀ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਂਦਾ ਹੈ।
ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਇਕ ਸਧਾਰਨ ਵਿਚਾਰ ਹੈ: ਆਮ-ਮਕਸਦ CPU ਨੂੰ ਹਰ ਕੰਮ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਭਾਰੀ ਅਤੇ ਦੁਹਰਾਉਂਦੇ ਹਿੱਸਿਆਂ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪ੍ਰੋਸੈਸਰ (ਅਕਸਰ GPU) 'ਤੇ ਆਫਲੋਡ ਕਰਦੇ ਹੋ ਜੋ ਉਹ ਕੰਮ ਕਾਫ਼ੀ ਤੇਜ਼ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕਰ ਸਕਦਾ ਹੈ।
CPU ਛੋਟੇ-ਛੋਟੇ ਮਿਕਸ ਕੰਮਾਂ — ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਚਲਾਉਣਾ, ਐਪਸ ਦੇ ਸਮੰਵਯ, ਫੈਸਲੇ ਲੈਣਾ — ਲਈ ਬਹੁਤ ਵਧੀਆ ਹੈ। GPU ਇਸ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ ਕਿ ਉਹ ਇਕੋ-ਜਿਹੀਆਂ ਗਣਨਾਵਾਂ ਨੂੰ ਇੱਕ ਹੀ ਸਮੇਂ ਵਿੱਚ ਕਈ ਕੇਂਦਰਾਂ 'ਤੇ ਚਲਾ ਸਕੇ। ਜਦੋਂ ਕਿਸੇ ਵਰਕਲੋਡ ਨੂੰ ਹਜ਼ਾਰਾਂ (ਜਾਂ ਲੱਖਾਂ) ਪੈਰਲੇਲ ਆਪਰੇਸ਼ਨਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ — ਜਿਵੇਂ ਵੱਡੀਆਂ ਮੈਟ੍ਰਿਕਸ ਗੁਣਾ ਜਾਂ ਵੱਡੇ ਬੈਚ ਡੇਟੇ 'ਤੇ ਉਹੀ ਗਣਿਤ ਲਾਗੂ ਕਰਨਾ — ਤਾਂ GPU ਇਕ “ਐਕਸਲੇਰੇਟਰ” ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ throughput ਨੂੰ ਕਾਫ਼ੀ ਵਧਾ ਦਿੰਦਾ ਹੈ।
ਗੇਮਾਂ ਨੇ GPUs ਨੂੰ ਮਸ਼ਹੂਰ ਕੀਤਾ, ਪਰ ਉਹੀ ਪੈਰਲੇਲ ਗਣਿਤ ਆਧੁਨਿਕ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਕਈ ਥਾਵਾਂ ਤੇ ਮਿਲਦੀ ਹੈ:
ਇਸ ਕਰਕੇ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਕੰਜ਼ਿਊਮਰ PCs ਤੋਂ ਡੇਟਾ ਸੈਂਟਰਾਂ ਤਕ ਆ ਗਿਆ। ਇਹ ਸਿਰਫ਼ “ਤੇਜ਼ ਚਿਪ” ਬਾਰੇ ਨਹੀਂ—ਇਹ ਉਹ ਕੰਮ ਸੰਭਵ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਪਹਿਲਾਂ ਲਾਗਤ, ਸਮਾਂ, ਜਾਂ ਸ਼ਕਤੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ ਅਣਜਾਂਚੇ ਸਨ।
ਜਦੋਂ ਲੋਕ “NVIDIA ਦੀ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਸਟੈਕ” ਕਹਿੰਦੇ ਹਨ, ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਤਿੰਨ ਪਰਤਾਂ ਦੀ ਗੱਲ ਕਰਦੇ ਹਨ ਜੋ ਇਕੱਠੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ:
ਇਸ ਗਾਈਡ ਦੇ ਅਖੀਰ ਤੱਕ, ਤੁਹਾਡੇ ਕੋਲ GPU ਵਿਰੁੱਧ CPU ਲਈ ਇੱਕ ਸਧਾਰਨ ਮਾਨਸਿਕ ਮਾਡਲ ਹੋਵੇਗਾ, ਕਿਉਂ AI GPUs ਨਾਲ ਚੰਗਾ ਫਿੱਟ ਹੁੰਦਾ ਹੈ, CUDA ਕੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਵਾਸਤਵਿਕ AI ਸਿਸਟਮਾਂ ਨੂੰ ਸਕੇਲ ਕਰਨ ਲਈ GPU ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਕੀ-ਕੀ ਚੀਜ਼ਾਂ ਲੋੜੀਂਦੀਆਂ ਹਨ।
CPU ਨੂੰ ਇੱਕ ਛੋਟੀ ਸੋਧਿਆ ਹੋਈ ਟੀਮ ਸਮਝੋ। ਉਹ ਜ਼ਿਆਦਾ ਨਹੀਂ ਹੁੰਦੇ, ਪਰ ਹਰ ਇੱਕ ਵਿਅਕਤੀ ਫੈਸਲੇ ਕਰਨ, ਟਾਸਕ ਤਬਦੀਲ ਕਰਨ ਅਤੇ ਜਟਿਲ "ਜੇ ਇਹ, ਤਾਂ ਉਹ" ਲੋਜਿਕ ਸੰਭਾਲਣ ਵਿੱਚ ਮਹਿਰ ਹੈ।
ਇਸਦੇ ਉਲਟ, GPU ਵਜੋਂ ਸੌਂਖੇ ਜਾਂ ਕੈਪੇਬਲ ਸਹਾਇਕਾਂ ਦੀ ਸੈਂਕੜੇ ਜਾਂ ਹਜ਼ਾਰਾਂ ਦੀ ਟੀਮ ਹੈ। ਹਰ ਸਹਾਇਕ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਮਾਹਿਰ ਨਾਲੋਂ ਸਧਾਰਣ ਹੋਵੇ, ਪਰ ਇਕੱਠੇ ਉਹ ਇੱਕ ਵੱਡੀ ਮਾਤਰਾ ਵਾਲਾ ਇਕੋ ਜਿਹਾ ਕੰਮ ਤੇਜ਼ੀ ਨਾਲ ਨਿਪਟਾ ਸਕਦੇ ਹਨ।
CPU ਨਿਯੰਤਰਣ ਅਤੇ ਸਮਨਵય ਵਿੱਚ ਮਹਿਰ ਹਨ: ਓਐਸ ਚਲਾਉਣਾ, ਫਾਈਲਾਂ ਸੰਭਾਲਣਾ, ਨੈੱਟਵਰਕ ਰਿਕਵੇਸਟ ਹੈਂਡਲ ਕਰਨਾ, ਅਤੇ ਬ੍ਰਾਂਚਿੰਗ ਵਾਲੇ ਕੋਡ ਪਾਥ ਚਲਾਉਣਾ। ਉਹ ਸੀਰੀਅਲ ਲੋਜਿਕ ਲਈ ਬਣੇ ਹਨ—ਕਦਮ 1, ਫਿਰ ਕਦਮ 2—ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਹਰ ਕਦਮ ਪਿਛਲੇ 'ਤੇ ਨਿਰਭਰ ਹੋਵੇ।
GPU ਉਹ ਸਮੇਂ ਚਮਕਦੇ ਹਨ ਜਦੋਂ ਇੱਕੋ ਹੀ ਆਪਰੇਸ਼ਨ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਡੇਟਾ ਹਿੱਸਿਆਂ 'ਤੇ ਪੈਰਲੇਲ ਤਰੀਕੇ ਨਾਲ ਲਗਾਉਣਾ ਹੋਵੇ। ਇੱਕ ਕੋਰ ਨੂੰ ਬਾਰ-ਬਾਰ ਕੰਮ ਕਰਨ ਦੀ ਬਜਾਏ, ਕਈ ਕੋਰ ਉਸੇ ਸਮੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।
ਆਮ GPU-ਪੁਸ਼ਟ ਵਰਕਲੋਡ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹਨ:
ਅਧਿਕਤਮ ਅਸਲ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ, GPUs CPUs ਦੀ ਜਗ੍ਹਾ ਨਹੀਂ ਲੈਂਦੇ—ਉਹ ਉਨ੍ਹਾਂ ਦੀ ਪੂਰੀਕਰਤਾ ਹੁੰਦੇ ਹਨ।
CPU ਆਮ ਤੌਰ 'ਤੇ ਐਪਲੀਕੇਸ਼ਨ ਚਲਾਉਂਦਾ, ਡੇਟਾ ਤਿਆਰ ਕਰਦਾ, ਅਤੇ ਕੰਮ ਦੀ ਸੰਚਾਲਨਾ ਕਰਦਾ ਹੈ। GPU ਭਾਰੀ ਪੈਰਲੇਲ ਗਣਨਾ ਸੰਭਾਲਦਾ ਹੈ।ਇਸੀ ਲਈ ਆਧੁਨਿਕ AI ਸਰਵਰਾਂ ਵਿੱਚ ਤਾਕ਼ਤਵਰ CPUs ਹੁੰਦੇ ਹਨ: ਚੰਗੀ “ਮਾਹਿਰ” ਸੰਚਾਲਨਾ ਦੇ ਬਗੈਰ, ਸਾਰੇ ਉਹ ਸਹਾਇਕ ਬੈਠੇ ਰਹਿ ਸਕਦੇ ਹਨ ਬਦਲੇ ਵਿੱਚ ਕੰਮ ਕਰਨ ਦੇ।
GPUs ਪਹਿਲਾਂ ਪਿਕਸਲਾਂ ਅਤੇ 3D ਸੀਨ ਡਰਾਇੰਗ ਲਈ ਖਾਸ ਪ੍ਰੋਸੈਸਰ ਸਨ। 1990s ਦੇ ਅਖੀਰ ਅਤੇ 2000s ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ, NVIDIA ਅਤੇ ਹੋਰ ਕੰਪਨੀਆਂ ਨੇ ਸ਼ੇਡਿੰਗ ਅਤੇ ਜਿਓਮੈਟਰੀ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ ਹੋਰ ਪੈਰਲੇਲ ਯੂਨਿਟ ਜੋੜਦੇ ਰਹੇ। ਖੋਜਕਾਰਾਂ ਨੇ ਨੋਟ ਕੀਤਾ ਕਿ ਕਈ ਗੈਰ-ਗ੍ਰਾਫਿਕਸ ਸਮੱਸਿਆਵਾਂ ਵੀ ਬਹੁਤ ਸਾਰੇ ਡੇਟਾ ਪੌਇੰਟਾਂ 'ਤੇ ਇਕੋ ਜਿਹੇ ਆਪਰੇਸ਼ਨ ਨੂੰ ਦੁਹਰਾਉਂਦੀਆਂ ਹਨ—ਸਿੱਧਾ ਉਹੀ ਜਿਹੜਾ ਗ੍ਰਾਫਿਕਸ ਪਾਈਪਲਾਈਨ ਲਈ ਬਣਿਆ ਸੀ।
ਮੁਖ਼ਤਸਰ, ਪ੍ਰਾਇਕਟਿਕ ਟਾਈਮਲਾਈਨ:
ਗ੍ਰਾਫਿਕਸ ਵਰਕਲੋਡ ਬਹੁਤ ਹੱਦ ਤੱਕ ਲੀਨੀਅਰ ਅਲਜੀਬਰਾ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦੇ ਹਨ: ਵੈਕਟਰੇ, ਮੈਟ੍ਰਿਕਸ, ਡੌਟ ਪ੍ਰੋਡਕਟ, ਕਨਵੋਲੂਸ਼ਨ, ਅਤੇ ਭਾਰੀ ਮਲਟੀਪਲੀ-ਐਡ آپਰੇਸ਼ਨ। ਵਿਗਿਆਨਕ ਕੰਪਿਊਟਿੰਗ ਵੀ ਉਹੀ ਬਿਲਡਿੰਗ ਬਲਾਕ ਵਰਤਦੀ ਹੈ (ਜਿਵੇਂ ਸਿਮੂਲੇਸ਼ਨ, ਸਿਗਨਲ ਪ੍ਰੋਸੈਸਿੰਗ), ਅਤੇ ਆਧੁਨਿਕ ਮਸ਼ੀਨ ਲਰਨਿੰਗ انہاں 'ਤੇ ਹੋਰ ਜ਼ੋਰ ਦਿੰਦੀ ਹੈ—ਖਾਸ ਕਰਕੇ ਡੈਂਸ ਮੈਟ੍ਰਿਕਸ ਮਲਟੀਪਲੀਕੇਸ਼ਨ ਅਤੇ ਕਨਵੋਲੂਸ਼ਨ।
ਮੁੱਖ ਮਿਲਾਪ ਹੈ ਪੈਰਲੇਲਿਸਮ: ਬਹੁਤ ਸਾਰੇ ML ਟਾਸਕ ਵੱਡੇ ਬੈਚਾਂ ਦੇ ਉੱਪਰ ਇਕੋ-ਜਿਹੇ ਆਪਰੇਸ਼ਨ ਲਗਾਉਂਦੇ ਹਨ (ਪਿਕਸਲ, ਟੋਕਨ, ਫੀਚਰ)। GPUs ਹਜ਼ਾਰਾਂ ਸਮਾਨ ਥ੍ਰੇਡਜ਼ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਚਲਾ ਸਕਦੇ ਹਨ, ਇਸ ਲਈ ਇਹ ਉਹ ਮਾਪਦੰਡਾਂ ਲਈ CPU ਨਾਲੋਂ ਕਾਫ਼ੀ ਵੱਧ ਅੰਕਿਤ ਮਹਿਤਾ ਦਿੰਦੇ ਹਨ।
NVIDIA ਦਾ ਪ੍ਰਭਾਵ ਸਿਰਫ਼ ਤੇਜ਼ ਚਿਪ ਨਹੀਂ ਸੀ; ਇਹ GPU ਨੂੰ ਰੋਜ਼ਮਰਰਾ ਵਿਕਸਿਤਕਾਰਾਂ ਲਈ ਉਪਯੋਗ ਬਣਾਉਣਾ ਵੀ ਸੀ। CUDA ਨੇ GPU ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਨੁੰ ਆਸਾਨ ਕੀਤਾ, ਅਤੇ ਵਧਦੀ ਲਾਇਬ੍ਰੇਰੀਆਂ (ਲਿਨਿਅਰ ਅਲਜੀਬਰਾ, ਨ્યુਰਲ ਨੈੱਟਵਰਕ, ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ) ਨੇ ਕਸਟਮ kernel ਲਿਖਣ ਦੀ ਲੋੜ ਘਟਾ ਦਿੱਤੀ।
ਜਿਵੇਂ ਜ਼ਿਆਦਾ ਟੀਮਾਂ GPU-ਐਕਸਲੇਰੇਟਡ ਉਤਪਾਦ ਸ਼ਿਪ ਕਰਨ ਲੱਗੀਆਂ, ਇੱਕੋ ਹਰੇਕ ਇਕੋ ਪ੍ਰਭਾਵ ਨੇ ਇਕ ਦੂਜੇ ਨੂੰ ਮਜ਼ਬੂਤ ਕੀਤਾ: ਹੋਰ ਟਿਊਟੋਰਿਯਲਜ਼, ਬਿਹਤਰ ਟੂਲਿੰਗ, ਤਜ਼ਰਬੇਕਾਰ ਇੰਜੀਨੀਅਰ, ਅਤੇ ਫਰੇਮਵਰਕ ਸਪੋਰਟ—ਜਿਸ ਨਾਲ ਅਗਲੀ ਟੀਮ ਲਈ GPUs ਅਪਣਾਉਣਾ ਆਸਾਨ ਹੋ ਗਿਆ।
ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ GPU ਤਦ ਹੀ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਵਿਕਸਿਤਕਾਰ ਉਸਨੂੰ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਦੱਸ ਸਕਣ ਕਿ ਕੀ ਕਰਣਾ ਹੈ। CUDA (Compute Unified Device Architecture) NVIDIA ਦੀ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ GPUs ਨੂੰ ਸਧਾਰਨ ਹਿਸਾਬ ਦਾ ਨਿਸ਼ਾਨਾ ਬਣਾਉਂਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਗ੍ਰਾਫਿਕਸ ਦਾ ਐਡ-ਆਨ।
CUDA ਦੋ ਵੱਡੇ ਕੰਮ ਇੱਕੋ ਵਾਰੀ ਕਰਦਾ ਹੈ:
ਬਿਨਾਂ ਇਸ ਪਰਤ ਦੇ, ਹਰ ਟੀਮ ਨੂੰ ਹਰ ਨਵੇਂ ਚਿਪ ਜਨਰੇਸ਼ਨ ਲਈ ਨੀਵ-ਸਤਰ GPU ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ, ਪ੍ਰਦਰਸ਼ਨ ਟਿਊਨਿੰਗ, ਅਤੇ ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਦੁਬਾਰਾ ਤੋਂ ਬਣਾਉਣੀ ਪੈ ਸਕਦੀ ਸੀ।
CUDA ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ kernel ਲਿਖਦੇ ਹੋ, ਜੋ ਬੁਨਿਆਦੀ ਤੌਰ ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਜਿਸ ਨੂੰ ਇੱਕੋ ਸਮੇਂ ਕਈ ਵਾਰੀ ਚਲਾਉਣ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ। CPU 'ਤੇ ਜਿਵੇਂ ਤੁਸੀਂ ਇੱਕ ਵਾਰੀ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦੇ ਹੋ, ਇੱਥੇ ਤੁਸੀਂ ਇਸਨੂੰ ਹਜ਼ਾਰਾਂ (ਜਾਂ ਲੱਖਾਂ) ਹਲਕੇ threads 'ਤੇ ਲਾਂਚ ਕਰਦੇ ਹੋ। ਹਰ thread ਸਮੂਹ ਕੰਮ ਦਾ ਇੱਕ ਛੋਟਾ ਹਿੱਸਾ ਸੰਭਾਲਦਾ ਹੈ—ਇਕ ਪਿਕਸਲ, ਇੱਕ ਮੈਟ੍ਰਿਕਸ ਦੀ ਸਤਰ, ਜਾਂ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਗਣਨਾ ਦਾ ਇਕ ਚੰਕ।
ਕੁੰਜੀ خیال: ਜੇ ਤੁਹਾਡੀ ਸਮੱਸਿਆ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਅਜ਼ਾਦ ਕੰਮਾਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ CUDA ਉਹਨਾਂ ਕੰਮਾਂ ਨੂੰ GPU ਦੇ ਬਹੁਤ ਸਾਰੇ ਕੋਰਾਂ 'ਤੇ ਕੁਸ਼ਲਤਾਪੂਰਵਕ ਸ਼ਡਿਊਲ ਕਰ ਸਕਦਾ ਹੈ।
ਜ਼ਿਆਦਾਤਰ ਲੋਕ ਸਿੱਧਾ raw CUDA ਨਹੀਂ ਲਿਖਦੇ। ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਟੂਲਜ਼ ਦੇ ਹੇਠਾਂ ਹੁੰਦਾ ਹੈ ਜੋ ਉਹ ਪਹਿਲਾਂ ਹੀ ਵਰਤਦੇ ਹਨ:
ਇਸੇ ਲਈ “CUDA ਸਹਿਯੋਗ” ਅਕਸਰ AI ਇੰਫਰਾਸਟ੍ਰਕਚਰ ਯੋਜਨਾ ਵਿੱਚ ਇੱਕ ਚੈਕਬਾਕਸ ਹੁੰਦਾ ਹੈ: ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਤੁਹਾਡੀ ਸਟੈਕ ਕਿਹੜੇ ਓਪਟੀਮਾਈਜ਼ਡ ਬਿਲਡਿੰਗ ਬਲਾਕ ਵਰਤ ਸਕਦੀ ਹੈ।
CUDA ਤਗੜੀ ਤਰ੍ਹਾਂ NVIDIA GPUs ਨਾਲ ਜੁੜੀ ਹੋਈ ਹੈ। ਇਹ ਘਣੀ ਇন্টਿਗ੍ਰੇਸ਼ਨ ਤੇਜ਼ ਅਤੇ ਪ੍ਰਮੁੱਖ ਕਾਰਨ ਹੈ—ਪਰ ਇਸਦਾ ਮਤਲਬ ਇਹ ਵੀ ਹੈ ਕਿ ਉਥੇ ਦੀਆਂ ਕੋਡਾਂ ਨੂੰ ਬਿਨਾ ਬਦਲਾਅ ਦੇ ਨਾਨ-NVIDIA ਹਾਰਡਵੇਅਰ 'ਤੇ ਚਲਾਉਣਾ ਮੁਸ਼ਕਲ ਹੋ ਸਕਦਾ ਹੈ; ਬੈਕਐਂਡ ਜਾਂ ਵੱਖ-ਵੱਖ ਫਰੇਮਵਰਕਾਂ ਦੀ ਲੋੜ ਪੈ ਸਕਦੀ ਹੈ।
AI ਮਾਡਲ ਜ਼ਿਆਦਾ ਜਟਿਲ ਦਿੱਸ ਸਕਦੇ ਹਨ, ਪਰ ਭਾਰੀ ਭਾਗ ਵਾਸਤਵ ਵਿੱਚ ਬਹੁਤ ਵਾਰੀ ਇੱਕੋ ਹੀ ਗਣਿਤ ਨੂੰ ਵੱਡੇ ਪੱਧਰ 'ਤੇ ਦੁਹਰਾ ਰਹੇ ਹੁੰਦੇ ਹਨ।
ਟੈਨਸਰ ਸਿਰਫ਼ ਨੰਬਰਾਂ ਦੀ ਇੱਕ ਬਹੁ-ਆਯਾਮੀ ਐਰੇ ਹੈ: ਇੱਕ ਵੈਕਟਰ (1D), ਇੱਕ ਮੈਟ੍ਰਿਕਸ (2D), ਜਾਂ ਉੱਪਰ-ਆਯਾਮੀ ਬਲੌਕ (3D/4D+)। ਨਿਊਰਲ ਨੈੱਟਵਰਕਸ ਵਿੱਚ, ਟੈਨਸਰ ਇੰਪੁਟ, ਵਜ਼ਨ, ਇੰਟਰਮੀਡੀਏਟ ਐਕਟੀਵੇਸ਼ਨਾਂ, ਅਤੇ ਆਉਟਪੁੱਟ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ।
ਮੁੱਖ ਆਪਰੇਸ਼ਨ ਇਹਨਾਂ ਟੈਨਸਰਾਂ ਨੂੰ ਗੁਣਾ ਅਤੇ ਜੋੜਨਾ ਹੈ—ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਮੈਟ੍ਰਿਕਸ ਗੁਣਾ (ਤੇ ਇਸ ਨਾਲ ਸਬੰਧਤ convolution)। ਟਰੇਨਿੰਗ ਅਤੇ ਇਨਫਰੰਸ ਇਹ ਪੈਟਰਨ ਮਿਲੀਅਨ ਤੋਂ ਟ੍ਰਿੱਲੀਅਨ ਵਾਰੀ ਚਲਾਉਂਦੇ ਹਨ। ਇਸੀ ਲਈ AI ਪ੍ਰਦਰਸ਼ਨ ਅਕਸਰ ਇਸ ਗੱਲ ਨਾਲ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਇੱਕ ਸਿਸਟਮ ਡੈਂਸ ਮਲਟੀਪਲੀ-ਐਡ ਕੰਮ ਕਿੰਨੀ ਤੇਜ਼ੀ ਨਾਲ ਕਰ ਸਕਦਾ ਹੈ।
GPUs ਬਹੁਤ ਸਾਰੇ ਸਮਾਨ ਗਣਨਾਵਾਂ ਨੂੰ ਪੈਰਲੇਲ ਚਲਾਉਣ ਲਈ ਬਣੇ ਹਨ। ਇੱਕ-ਦੋ ਤੇਜ਼ ਕੋਰਾਂ ਦੀ ਥਾਂ (ਜੋ ਆਮ CPU ਡਿਜ਼ਾਇਨ ਹੁੰਦਾ ਹੈ), GPUs ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਛੋਟੇ ਕੋਰ ਹੋਂਦੇ ਹਨ ਜੋ ਵੱਡੇ ਗ੍ਰਿਡਸ ਦੇ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੇ ਹਨ—ਇਹ tensor-ਭਾਰਤਕ ਲੋਡਾਂ ਲਈ ਬੇਹੱਦ ਉਚਿਤ ਹੈ।
ਆਧੁਨਿਕ GPUs ਵਿੱਚ ਖਾਸ units ਵੀ ਹੁੰਦੀਆਂ ਹਨ ਜਿਹੜੀਆਂ ਇਸ ਹੀ ਉਦੇਸ਼ ਲਈ ਬਣੀਆਂ ਹਨ। ਧਾਰਣਾਤਮਕ ਤੌਰ 'ਤੇ, ਇਹਨਾਂ tensor-ਕੇਂਦ੍ਰਿਤ ਏਕਾਈਆਂ ਨੇ AI ਦੇ ਮਲਟੀਪਲੀ-ਐਡ ਪੈਟਰਨ ਨੂੰ ਜਨਰਲ ਕੋਰਾਂ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹੈਂਡਲ ਕਰਨ ਲਈ ਪ੍ਰਸੰਸਾ ਕੀਤੀ ਹੈ, ਜਿਸ ਨਾਲ ਪ੍ਰਤੀ ਵੈੱਟ ਵੱਧ ਥਰੂਪੁੱਟ ਮਿਲਦਾ ਹੈ।
ਟ੍ਰੇਨਿੰਗ ਮਾਡਲ ਵਜ਼ਨਾਂ ਨੂੰ ਅਪਟਾਈਜ਼ ਕਰਦੀ ਹੈ। ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਕੁੱਲ ਕੰਪਿਊਟ ਅਤੇ ਵੱਡੀਆਂ ਟੈਨਸਰਾਂ ਨੂੰ ਬਾਰ-ਬਾਰ ਮੈਮੋਰੀ ਰਾਹੀਂ ਮੂਵ ਕਰਨ ਨਾਲ ਸੀਮਿਤ ਹੁੰਦੀ ਹੈ।
ਇਨਫਰੰਸ ਪ੍ਰਡਿਕਸ਼ਨਾਂ ਸਰਵ ਕਰਦੀ ਹੈ। ਇਹ ਅਕਸਰ ਲੇਟੈਂਸੀ ਟਾਰਗਟਾਂ, ਥਰੂਪੁੱਟ, ਅਤੇ ਇਸGallਿ ਬੇੜੇ-ਡੇਟਾ ਫੀਡ ਕਰਨ ਦੀ ਕਸ਼ਮਕਸ਼ ਨਾਲ ਸੀਮਿਤ ਹੁੰਦੀ ਹੈ।
AI ਟੀਮਾਂ ਇਹ ਚੀਜ਼ਾਂ ਦੇਖਦੀਆਂ ਹਨ:
ਆਧੁਨਿਕ "GPU ਸਰਵਰ" (ਅਕਸਰ GPU ਬਾਕਸ ਆਖਿਆ ਜਾਂਦਾ) ਬਾਹਰੋਂ ਇੱਕ ਆਮ ਸਰਵਰ ਵਰਗਾ ਲਗਦਾ ਹੈ, ਪਰ ਅੰਦਰ ਇਸ ਨੂੰ ਇਕ ਜਾਂ ਹੋਰ ਉੱਚ-ਪਾਵਰ ਏਕਸਲੇਰੇਟਰ ਕਾਰਡਾਂ ਨੂੰ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਡੇਟਾ ਦੇਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਹਰ GPU ਦੀ ਆਪਣੀ ਉੱਚ-ਗਤੀ ਮੈਮੋਰੀ ਹੁੰਦੀ ਹੈ ਜਿਸਨੂੰ VRAM ਕਹਿੰਦੇ ਹਨ। ਕਈ AI ਨੌਕਰੀਆਂ ਇਸ ਲਈ ਫੇਲ ਹੁੰਦੀਆਂ ਹਨ ਕਿ GPU "ਬਹੁਤ ਧੀਮਾ" ਨਹੀਂ ਹੈ—ਉਹ ਇਸ ਲਈ ਫੇਲ ਹੁੰਦੀਆਂ ਹਨ ਕਿ ਮਾਡਲ, ਐਕਟੀਵੇਸ਼ਨ ਅਤੇ ਬੈਚ ਸਾਈਜ਼ VRAM ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦੇ।
ਇਸ ਕਰਕੇ ਤੁਸੀਂ ਲੋਕਾਂ ਨੂੰ “80GB GPUs” ਜਾਂ “ਕਿੰਨੇ ਟੋਕਨ ਫਿੱਟ ਹੁੰਦੇ ਹਨ” ਬਾਰੇ ਗੱਲ ਕਰਦੇ ਦੇਖੋਗੇ। ਜੇ ਤੁਹਾਡੀ VRAM ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਛੋਟੀ ਬੈਚ, ਘੱਟ ਪ੍ਰਿਸੀਜ਼ਨ, ਮਾਡਲ ਸ਼ਾਰਡਿੰਗ, ਜਾਂ ਹੋਰ GPUs ਦੀ ਲੋੜ ਪੈ ਸਕਦੀ ਹੈ।
ਇੱਕ ਬਾਕਸ ਵਿੱਚ ਕਈ GPUs ਰੱਖਣਾ ਮਦਦਗਾਰ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਸਕੇਲਿੰਗ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ GPUs ਨੂੰ ਕਿੰਨਾ ਸੰਚਾਰ ਦੀ ਲੋੜ ਹੈ। ਕੁਝ ਵਰਕਲੋਡ ਲਗਭਗ ਰੇਖਿਕ ਤੌਰ 'ਤੇ ਸਕੇਲ ਕਰਦੇ ਹਨ; ਹੋਰ ਸੰਕਲਨ ਖਰਚ, VRAM ਨਕਲ, ਜਾਂ ਡੇਟਾ-ਲੋਡਿੰਗ ਬੋਤਲਨੇਕ ਕਾਰਨ ਸੀਮਤ ਹੋ ਜਾਂਦੇ ਹਨ।
ਉੱਚ-ਕੁਆਲਟੀ GPUs ਹਰ ਇੱਕ ਸੈਂਕੜੇ ਵਾਟ ਖਿੱਚ ਸਕਦੇ ਹਨ। ਇੱਕ 8‑GPU ਸਰਵਰ ਇੱਕ "ਆਮ" ਰੈਕ ਸਰਵਰ ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਗਰਮੀ ਨਿਕਲਦਾ ਹੈ। ਇਸਦਾ ਮਤਲਬ:
ਇੱਕ GPU ਬਾਕਸ ਸਿਰਫ਼ “GPU ਵਾਲਾ ਸਰਵਰ” ਨਹੀਂ—ਇਹ ਇੱਕ ਐਸਾ ਸਿਸਟਮ ਹੈ ਜੋ ਐਕਸਲੇਰੇਟਰਾਂ ਨੂੰ ਪੂਰਾ ਖੁਰਾਕ, ਕੁਲਿੰਗ, ਅਤੇ ਸੰਚਾਰ ਦੇ ਰਾਹੀਂ ਅਪਣੇ ਪੂਰੇ ਸਪੀਡ 'ਤੇ ਰੱਖਦਾ ਹੈ।
ਇੱਕ GPU ਉਸ ਸਿਸਟਮ ਦੇ ਅਨੁਕੂਲ ਤੇਜ਼ ਹੈ ਜੋ ਉਸਦੇ ਆਲੇ-ਦੁਆਲੇ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ "ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਰਵਰ" ਤੋਂ "ਕਈ GPUs ਇਕੱਠੇ ਕੰਮ ਕਰਨ" ਵੱਲ ਜਾਦੇ ਹੋ, ਤਾਂ ਸੀਮਾਰੂਪ ਅਕਸਰ ਕਚੀ ਕੰਪਿਊਟ ਤੋਂ ਬਦਲ ਕੇ ਡੇਟਾ ਨੂੰ ਜਲਦੀ ਹਿਲਾਉਣ, ਨਤੀਜੇ ਸਾਂਝੇ ਕਰਨ, ਅਤੇ ਹਰ GPU ਨੂੰ ਰੁਚਾਰੂ ਰੱਖਣ ਦੀ ਸਮਰੱਥਾ 'ਤੇ ਰੁਕ ਜਾਂਦਾ ਹੈ।
ਇਕਕ-GPU ਨੌਕਰੀਆਂ ਆਮ ਤੌਰ 'ਤੇ ਸਥਾਨਕ ਸਟੋਰੇਜ ਤੋਂ ਡੇਟਾ ਖਿੱਚਦੀਆਂ ਹਨ ਅਤੇ ਚੱਲਦੀਆਂ ਹਨ। ਮਲਟੀ-GPU ਟਰੇਨਿੰਗ (ਅਤੇ ਬਹੁਤ ਸਾਰੇ ਇਨਫਰੰਸ ਸੈਟਅਪ) ਲਗਾਤਾਰ ਡੇਟਾ ਅਦला-ਬਦਲੀ ਕਰਦੇ ਹਨ: gradients, activations, model parameters, ਅਤੇ ਇੰਟਰਮੀਡੀਏਟ ਨਤੀਜੇ। ਜੇ ਇਹ ਅਦਲਾ-ਬਦਲੀ ਧੀਮੀ ਹੈ, ਤਾਂ GPUs ਉਡੀਕ ਕਰਦੇ ਹਨ—ਅਤੇ ਆਈਡਲ GPU ਸਮਾਂ ਸਭ ਤੋਂ ਮਹਿੰਗਾ ਹੁੰਦਾ ਹੈ।
ਦੋ ਆਮ ਲੱਛਣ ਜੋ ਨੈੱਟਵਰਕ ਬੋਤਲਨੇਕ ਨੂੰ ਦਿਖਾਉਂਦੇ ਹਨ:
ਇੱਕ ਸਰਵਰ ਦੇ ਅੰਦਰ, GPUs ਬਹੁਤ ਤੇਜ਼, ਘੱਟ-ਲੇਟੈਂਸੀ ਕਨੈਕਸ਼ਨ ਨਾਲ ਜੋੜੇ ਜਾ ਸਕਦੇ ਹਨ ਤਾਂ ਜੋ ਉਹ ਸਿੱਧੇ ਸਮੇਂ ਬਿਨਾਂ ਧੀਮੀ ਰਾਹਾਂ ਨੂੰ ਵਰਤੇ ਸਹਿਯੋਗ ਕਰ ਸਕਣ। ਸਰਵਰਾਂ ਦੇ ਪਾਰ, ਡੇਟਾ ਸੈਂਟਰ ਭਾਰੀ ਲੋਡ ਹੇਠਾਂ ਪੇਸ਼ਾਨਗੀਯੋਗ ਕਾਰਗੁਜ਼ਾਰੀ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤੇ ਗਏ ਉੱਚ-ਬੈਂਡਵਿਡਥ ਨੈੱਟਵਰਕ ਫੈਬਰਿਕ ਵਰਤਦੇ ਹਨ।
ਧਾਰਨਾਤਮਿਕ ਤੌਰ 'ਤੇ, ਇਸਨੂੰ ਦੋ ਪਰਤਾਂ ਵਜੋਂ ਸੋਚੋ:
ਇਸੇ ਲਈ “GPUਆਂ ਦੀ ਗਿਣਤੀ” ਹੀ ڪਾਫ਼ੀ ਨਹੀਂ—ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਪੁੱਛਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਉਹ GPUs ਕਿਵੇਂ ਗੱਲ-ਬਾਤ ਕਰਦੇ ਹਨ।
GPUs "ਫਾਇਲਾਂ" 'ਤੇ ਨਹੀਂ, ਬੈਚਾਂ ਦੇ ਪ੍ਰਵਾਹ 'ਤੇ ਟਰੇਨ ਕਰਦੇ ਹਨ। ਜੇ ਡੇਟਾ ਲੋਡਿੰਗ ਧੀਮੀ ਹੈ, ਤਾਂ ਕਮਪਿਊਟ ਰੁੱਕ ਜਾਂਦਾ ਹੈ। ਪ੍ਰਭਾਵੀ ਪਾਈਪਲਾਈਨ ਆਮ ਤੌਰ 'ਤੇ ਇਨ੍ਹਾਂ ਚੀਜ਼ਾਂ ਨੂੰ ਮਿਲਾਉਂਦੀ ਹੈ:
ਇੱਕ ਚੰਗੀ ਤਿਆਰ ਕੀਤੀ ਪਾਈਪਲਾਈਨ ਉਨ੍ਹਾਂ ਸੇਮ GPUs ਨੂੰ ਕਾਫ਼ੀ ਤੇਜ਼ ਮਹਿਸੂਸ ਕਰਵਾ ਸਕਦੀ ਹੈ।
ਅਸਲ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਈ ਟੀਮਾਂ ਇੱਕੋ ਕਲਸਟਰ ਸਾਂਝਾ ਕਰਦੀਆਂ ਹਨ। ਸ਼ੈਡਿਊਲਿੰਗ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀਆਂ ਨੌਕਰੀਆਂ ਨੂੰ GPUs ਮਿਲਦੇ ਹਨ, ਕਿੰਨੇ ਸਮੇਂ ਲਈ, ਅਤੇ ਕਿਸ ਸੰਸਾਧਨ (CPU, ਮੈਮੋਰੀ, ਨੈੱਟਵਰਕ) ਦੇ ਨਾਲ। ਚੰਗੀ ਸ਼ੈਡਿਊਲਿੰਗ “GPU starvation” (ਨੌਕਰੀਆਂ ਉਡੀਕ ਕਰ ਰਹੀਆਂ) ਅਤੇ “GPU waste” (ਨਿਰਧਾਰਤ ਪਰ ਬੇਕਾਰ) ਨੂੰ ਘੱਟ ਕਰਦੀ ਹੈ। ਇਹ ਪ੍ਰਾਇਰਟੀ ਕਿਊਜ਼, ਪ੍ਰੀਏਮਸ਼ਨ, ਅਤੇ ਰਾਈਟ-ਸਾਈਜ਼ਿੰਗ ਵਰਗੀਆਂ ਨੀਤੀਆਂ ਨੂੰ ਯੋਗ ਬਣਾਉਂਦੀ ਹੈ—ਜਦੋਂ GPU ਘੰਟੇ ਇੱਕ ਬਜਟ ਆਈਟਮ ਹੁੰਦੇ ਹਨ, ਨਿੱਕੀ-ਨਿੱਕੀ ਨੀਤੀਆਂ ਅਹੰਕਾਰਪੂਰਕ ਹੋ ਜਾਂਦੀਆਂ ਹਨ।
ਹਾਰਡਵੇਅਰ ਕਹਾਣੀ ਦਾ ਸਿਰਫ਼ ਅੱਧਾ ਪਾਸਾ ਹੈ। NVIDIA ਦੀ ਅਸਲ ਫ਼ਾਇਦਾ ਉਹ ਸਾਫਟਵੇਅਰ ਸਟੈਕ ਹੈ ਜੋ GPU ਨੂੰ ਇੱਕ ਤੇਜ਼ ਚਿਪ ਤੋਂ ਇਕ ਐਸਾ ਪਲੇਟਫਾਰਮ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਟੀਮਾਂ ਬਣਾਉਂਦੀਆਂ, ਤੈਨਾਤ ਕਰਦੀਆਂ, ਅਤੇ ਬਰਹਾਲ ਰੱਖਦੀਆਂ ਹਨ।
ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਰਾ੍ ਸਿੱਧਾ GPU ਕੋਡ ਨਹੀਂ ਲਿਖਦੀਆਂ। ਉਹ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਉਸੇ ਬਿਲਡਿੰਗ ਬਲਾਕ ਤੋਂ ਜੋੜਦੀਆਂ ਹਨ: ਓਪਟੀਮਾਈਜ਼ਡ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ SDKs ਜੋ ਆਮ, ਮਹਿੰਗੇ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ। ਉਨ੍ਹਾਂ ਨੂੰ LEGO ਪੀਸز ਵਾਂਗ ਸੋਚੋ—ਮੈਟ੍ਰਿਕਸ ਮੈਥ, ਕਨਵੋਲੂਸ਼ਨ, ਵੀਡੀਓ ਪ੍ਰੋਸੈਸਿੰਗ, ਡੇਟਾ ਮੂਵਮੈਂਟ—ਤਾਂ ਜੋ ਤੁਸੀਂ ਨੀਚੇ-ਸਤਰ kernels ਦੁਬਾਰਾ ਨਾ ਲਿਖੋ ਅਤੇ ਪ੍ਰੋਡਕਟ ਲੋਜਿਕ 'ਤੇ ਧਿਆਨ ਦੇ ਸਕੋ।
ਪ੍ਰਸਿੱਧ ML ਫਰੇਮਵਰਕਸ (ਟਰੇਨਿੰਗ ਅਤੇ ਇਨਫਰੰਸ ਲਈ) NVIDIA ਦੇ ਸਟੈਕ ਨਾਲ ਇੰਟਿਗਰੇਟ ਕਰਦੇ ਹਨ ਤਾਂ ਜੋ ਜਦੋਂ ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ GPU 'ਤੇ ਚਲਾਉਂਦੇ ਹੋ, ਫਰੇਮਵਰਕ ਮੁੱਖ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਓਪਟੀਮਾਈਜ਼ਡ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵੱਲ ਰੂਟ ਕਰ ਦੇਵੇ। ਉਪਭੋਗੀ ਨਜ਼ਰੀਏ ਤੋਂ ਇਹ ਸਿਰਫ਼ ਇਕ ਡਿਵਾਈਸ ਸਵਿੱਚ ਜਿਹਾ ਲੱਗ ਸਕਦਾ ਹੈ (“use GPU”), ਪਰ ਉਸ ਸਵਿੱਚ ਦੇ ਪਿੱਛੇ ਇੱਕ ਸੰਗਠਿਤ ਚੇਨ ਹੁੰਦੀ ਹੈ: ਫਰੇਮਵਰਕ, CUDA ਰਨਟਾਈਮ, ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀਆਂ ਇੱਕੱਠੇ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।
ਘੱਟੋ-ਘੱਟ, ਤੁਸੀਂ ਇਹ ਚੀਜ਼ਾਂ ਮੈਨੇਜ ਕਰ ਰਹੇ ਹੋਵੋਗੇ:
ਇੱਥੇ ਕਈ ਪ੍ਰੋਜੈਕਟ ਠੋਕਰ ਖਾਂਦੇ ਹਨ। ਡਰਾਈਵਰ, CUDA ਵਰਜਨ, ਅਤੇ ਫਰੇਮਵਰਕ ਰਿਲੀਜ਼ਾਂ ਵਿੱਚ ਅਨੁਕੂਲਤਾ ਸੀਮਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਅਤੇ ਮਿਸਮੈਚ ਸ্লੋਡਾਉਨ ਤੋਂ ਲੈ ਕੇ ਵਿਫਲ ਡਿਪਲੋਇਮੈਂਟ ਤੱਕ ਸਭ ਕੁਝ ਕਰ ਸਕਦੇ ਹਨ। ਕਈ ਟੀਮ "known-good" ਕੰਬਿਨੇਸ਼ਨਾਂ 'ਤੇ ਸਟੈਂਡਰਡ ਕਰਦੀਆਂ ਹਨ, ਕੰਟੇਨਰ ਵਿੱਚ ਵਰਜਨਾਂ ਨੂੰ ਪਿਨ ਕਰਦੀਆਂ ਹਨ, ਅਤੇ ਅੱਪਡੇਟ ਲਈ staged rollouts (dev → staging → production) ਵਰਤਦੀਆਂ ਹਨ। GPU ਸਾਫਟਵੇਅਰ ਸਟੈਕ ਨੂੰ ਇਕ ਮਹੱਤਵਪੂਰਕ ਡਿਪੈਂਡੈਂਸੀ ਵਾਂਗੋਂ ਰੱਖੋ, ਇੱਕ ਵਾਰੀ ਦੀ ਇੰਸਟਾਲ ਵਾਂਗ ਨਹੀਂ।
ਜਦੋਂ ਤੁਹਾਨੂੰ ਮਾਡਲ ਇੱਕ GPU 'ਤੇ ਚਲਾਉਣ ਲੱਗੇ, ਅਗਲਾ ਸਵਾਲ ਇਹ ਹੁੰਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਤੇਜ਼ ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ (ਜਾਂ ਵੱਡਾ ਮਾਡਲ ਕਿਵੇਂ ਫਿੱਟ ਕਰਾਇਆ ਜਾਵੇ)। ਦੋ ਮੁੱਖ ਰਾਹ ਹਨ: scale up (ਇੱਕ ਮਸ਼ੀਨ ਵਿੱਚ ਵੱਧ/ਬਿਹਤਰ GPUs) ਅਤੇ scale out (ਕਈ ਮਸ਼ੀਨਾਂ ਇਕੱਠੇ ਕੰਮ ਕਰਦੀਆਂ)।
ਇੱਕ GPU ਨਾਲ, ਸਭ ਕੁਝ ਲੋਕਲ ਹੁੰਦਾ ਹੈ: ਮਾਡਲ, ਡੇਟਾ, ਅਤੇ GPU ਦੀ ਮੈਮੋਰੀ। ਕਈ GPUs ਨਾਲ, ਤੁਸੀਂ ਡਿਵਾਈਸਾਂ ਵਿਚਕਾਰ ਕੰਮ ਦੀ ਸਾਂਝ ਕਰਨ ਲੱਗਦੇ ਹੋ।
Scale up ਆਮ ਤੌਰ 'ਤੇ 2–8 GPUs ਵਾਲੇ ਸਰਵਰ 'ਤੇ ਜਾਣਾ ਹੁੰਦਾ ਹੈ ਜੋ ਤੇਜ਼ ਲਿੰਕਾਂ ਨਾਲ ਜੁੜੇ ਹੁੰਦੇ ਹਨ। ਇਹ ਇੱਕ ਵੱਡਾ ਅਪਗ੍ਰੇਡ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ GPUs ਤੇਜ਼ੀ ਨਾਲ ਨਤੀਜੇ ਸਾਂਝੇ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਇੱਕੋ host CPU ਅਤੇ ਸਟੋਰੇਜ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹਨ।
Scale out ਦਾ ਮਤਲਬ ਹੋਰ ਸਰਵਰ ਜੋੜਨਾ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਤੇਜ਼ ਨੈੱਟਵਰਕ ਨਾਲ ਕਨੈਕਟ ਕਰਨਾ ਹੈ। ਇਸ ਤਰੀਕੇ ਨਾਲ ਟਰੇਨਿੰਗ ਦੌਰਾਨ ਦਹਾਕਿਆਂ ਜਾਂ ਹਜ਼ਾਰਾਂ GPUs ਤੱਕ ਪਹੁੰਚ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ—ਪਰ ਸੰਚਾਰ ਅਤੇ ਸਹਿਯੋਗ ਪਹਿਲੀ ਤਰਜ਼ ਦੀ ਚਿੰਤਾ ਬਣ ਜਾਂਦੇ ਹਨ।
Data parallel: ਹਰ GPU ਕੋਲ ਮਾਡਲ ਦੀ ਪੂਰੀ ਨਕਲ ਹੁੰਦੀ ਹੈ, ਪਰ ਹਰ GPU ਵੱਖ-ਵੱਖ ਡੇਟਾ ਸਲਾਇਸ 'ਤੇ ਟ੍ਰੇਨ ਕਰਦਾ ਹੈ। ਹਰ ਸਟੈਪ ਤੋਂ ਬਾਦ, GPUs gradients ਸਾਂਝੇ ਕਰਦੇ ਹੋਏ ਵਜ਼ਨਾਂ 'ਤੇ ਸਹਿਮਤ ਹੁੰਦੇ ਹਨ। ਇਹ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਸਭ ਤੋਂ ਆਮ ਹੈ ਕਿਉਂਕਿ ਇਹ ਸੋਚਣ ਵਿੱਚ ਆਸਾਨ ਹੈ।
Model parallel: ਮਾਡਲ ਆਪ ਹੀ GPUs ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇਕ ਹੀ ਡਿਵਾਈਸ 'ਤੇ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦਾ। GPUs ਨੂੰ ਫਾਰਵਰਡ ਅਤੇ ਬੈਕਵਰਡ ਪਾਸ ਦੌਰਾਨ ਗੱਲ-ਬਾਤ ਕਰਨੀ ਪੈਂਦੀ ਹੈ, ਨਾ ਕਿ ਸਿਰਫ਼ ਇਕ ਸਟੈਪ ਦੇ ਅੰਤ 'ਤੇ। ਇਹ ਵੱਡੇ ਮਾਡਲ ਖੋਲ੍ਹ ਸਕਦਾ ਹੈ, ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਸੰਚਾਰ ਵਾਧਾ ਕਰ ਦਿੰਦਾ ਹੈ।
ਅਸਲ ਸਿਸਟਮ ਅਕਸਰ ਦੋਹਾਂ ਨੂੰ ਮਿਲਾਉਂਦੇ ਹਨ: ਇੱਕ ਸਰਵਰ ਦੇ ਅੰਦਰ ਮਾਡਲ ਪੈਰਲੇਲ, ਅਤੇ ਸਰਵਰਾਂ 'ਚ ਡੇਟਾ ਪੈਰਲੇਲ।
ਹੋਰ GPUs ਨਾਲ “ਗੱਲ-ਬਾਤ” 'ਤੇ ਵੱਧ ਸਮਾਂ ਖਰਚ ਹੁੰਦਾ ਹੈ। ਜੇ ਵਰਕਲੋਡ ਛੋਟਾ ਹੈ, ਜਾਂ ਨੈੱਟਵਰਕ ਧੀਮਾ ਹੈ, ਤਾਂ GPUs ਅਪਡੇਟਾਂ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋਏ ਆਈਡਲ ਹੋ ਸਕਦੇ ਹਨ। ਤੁਸੀਂ ਘਟੂ ਲਾਭ ਵੇਖੋਗੇ ਜਦ:
ਤੁਹਾਨੂੰ ਮਲਟੀ-GPU ਜਾਂ ਕਲਸਟਰ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ ਜਦ:
ਇਸ ਮੋੜ 'ਤੇ, “ਸਟੈਕ” ਸਿਰਫ਼ GPUs ਨਹੀਂ ਰਹਿੰਦਾ—ਇਸ ਵਿੱਚ ਤੇਜ਼ ਇੰਟਰਕਨੈਕਟਸ, ਨੈੱਟਵਰਕਿੰਗ, ਅਤੇ ਸ਼ੈਡਿਊਲਿੰਗ ਵੀ ਸ਼ਾਮਿਲ ਹੋ ਜਾਂਦੀ ਹੈ—ਕਿਉਂਕਿ ਸਕੇਲਿੰਗ ਕच्चे ਕੰਪਿਊਟ ਤੋਂ ਜ਼ਿਆਦਾ ਸੰਚਾਰ ਅਤੇ ਸਹਿਯੋਗ ਬਾਰੇ ਹੈ।
ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਕੋਈ "ਬੈਕ-ਸਟੀਜ" ਚਾਲ ਨਹੀਂ ਰਹੀ; ਇਹ ਇੱਕ ਕਾਰਨ ਹੈ ਕਿ ਕਈ ਹਰਰੋਜ਼ ਦੀਆਂ ਉਤਪਾਦਾਂ ਨੂੰ ਤੁਰੰਤ, ਫਲੂ, ਅਤੇ ਵਾਧੂ ਬੁੱਧਿਮਾਨ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ—ਕਿਉਂਕਿ ਕੁਝ ਕੰਮ ਬਹੁਤ ਛੋਟੇ ਗਣਨਾਂ ਨੂੰ ਪੈਰਲੇਲ ਤਰੀਕੇ ਨਾਲ ਚਲਾਉਂਕੇ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੋ ਜਾਂਦੇ ਹਨ।
ਜ਼ਿਆਦਾਤਰ ਲੋਕ ਸਰਵਿੰਗ ਪਾਸੇ ਨੋਟਿਸ ਕਰਦੇ ਹਨ: ਚੈਟ ਸਹਾਇਕ, ਇਮੇਜ ਜੈਨਰੇਟਰ, ਰੀਅਲ-ਟਾਈਮ ਅਨੁਵਾਦ, ਅਤੇ ਐਪਾਂ ਵਿੱਚ “ਸਮਾਰਟ” ਫੀਚਰ। ਪਿੱਛੇ GPUs ਦੋ ਪੜਾਵਾਂ ਨੂੰ ਪਾਵਰ ਦਿੰਦੇ ਹਨ:
ਉਤਪਾਦ ਵਿੱਚ, ਇਹ ਤੇਜ਼ ਜਵਾਬ, ਉੱਚ ਥਰੂਪੁੱਟ (ਹੋਰ ਯੂਜ਼ਰ ਪ੍ਰਤੀ ਸਰਵਰ), ਅਤੇ ਇੱਕ ਦਿੱਤੇ ਡੇਟਾ ਸੈਂਟਰ ਬਜਟ ਵਿੱਚ ਵੱਡੇ ਜਾਂ ਜ਼ਿਆਦਾ ਸਮਰੱਥਾ ਵਾਲੇ ਮਾਡਲ ਚਲਾਉਣ ਦੀ ਸਮਰੱਥਾ ਵਜੋਂ ਉਭਰਦਾ ਹੈ।
ਸਟ੍ਰੀਮਿੰਗ ਪਲੇਟਫਾਰਮ ਅਤੇ ਵੀਡੀਓ ਐਪਸ ਐਕਸਲੇਰੇਸ਼ਨ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ ਉਦਾਹਰਨ ਲਈ ਐਂਕੋਡਿੰਗ, ਡੀਕੋਡਿੰਗ, ਅਪਸਕੇਲਿੰਗ, ਬੈਕਗ੍ਰਾਊਂਡ ਰਿਮੂਵਲ, ਅਤੇ ਪ੍ਰਭਾਵ। ਕ੍ਰੀਏਟਿਵ ਟੂਲਜ਼ ਟਾਈਮਲਾਈਨ ਪਲੇਬੈਕ, ਰੰਗ-ਗ੍ਰੇਡਿੰਗ, 3D ਰੇਂਡਰਿੰਗ, ਅਤੇ AI-ਸਹਾਇਤ ਫੀਚਰਾਂ ਲਈ ਇਸਤੇਮਾਲ ਕਰਦੇ ਹਨ (ਨੋਇਜ਼ ਰੀਮੂਵਲ, ਜਰੇਸ਼ਨਰਟਿਵ ਭਰਾਈ, ਸਟਾਈਲ ਟ੍ਰਾਂਸਫਰ)। ਨਤੀਜਾ ਘੱਟ ਉਡੀਕ ਅਤੇ ਐੱਡਿਟ ਕਰਦੇ ਸਮੇਂ ਜ਼ਿਆਦਾ ਰੀਅਲ-ਟਾਈਮ ਫੀਡਬੈਕ ਹੁੰਦੀ ਹੈ।
ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਉਹਨਾਂ ਸਿਮੂਲੇਸ਼ਨਾਂ ਵਿੱਚ ਬਹੁਤ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਆਮ ਤੌਰ 'ਤੇ ਇਕੋ ਹੀ ਗਣਿਤ ਨੂੰ ਵੱਡੇ ਗ੍ਰਿਡਸ ਜਾਂ ਬਹੁਤ ਸਾਰੇ ਪਾਰਟੀਕਲਾਂ 'ਤੇ ਦੁਹਰਾ ਰਹੇ ਹੁੰਦੇ ਹੋ: ਮੌਸਮ ਅਤੇ ਕਲਾਈਮেট ਮਾਡਲ, ਕੰਪਿਊਟੇਸ਼ਨਲ ਫਲੂਇਡ ਡਾਇਨੇਮਿਕਸ, ਮੋਲੈਕੂਲਰ ਡਾਇਨੈਮਿਕਸ, ਅਤੇ ਇੰਜੀਨੀਅਰਿੰਗ ਡਿਜ਼ਾਇਨ ਵੇਰੀਫਿਕੇਸ਼ਨ। ਛੋਟੀ simulation ਚੱਕੜੀ R&D ਤੇਜ਼ ਕਰ ਸਕਦੀ ਹੈ, ਹੋਰ ਡਿਜ਼ਾਈਨ ਇਟਰੇਸ਼ਨ ਅਤੇ ਬਿਹਤਰ ਨਤੀਜੇ ਲਿਆ ਸਕਦੀ ਹੈ।
ਰਿਕਮੈਂਡੇਸ਼ਨ, سرچ ਰੈਂਕਿੰਗ, ਐਡ ਅਪਟੀਮਾਈਜ਼ੇਸ਼ਨ, ਅਤੇ ਫਰਾਡ ਡਿਟੈਕਸ਼ਨ ਆਮ ਤੌਰ 'ਤੇ ਵੱਡੇ ਘਟਨਾ ਸਟ੍ਰੀਮਜ਼ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਪ੍ਰੋਸੈਸ ਕਰਨ ਦੀ ਲੋੜ ਰੱਖਦੇ ਹਨ। GPUs ਕੁਝ ਫੀਚਰ ਪ੍ਰੋਸੈਸਿੰਗ ਅਤੇ ਮਾਡਲ ਐਗਜ਼ਿਕਿਊਸ਼ਨ ਨੂੰ ਤੇਜ਼ ਕਰ ਸਕਦੇ ਹਨ, ਤਾਂ ਜੋ ਫੈਸਲੇ ਉਪਭੋਗਤਾ ਅਜੇ ਵੀ ਪੇਜ 'ਤੇ ਹੋਣ ਸਮੇਂ ਵੀ ਹੋ ਸਕਣ।
ਹਰ ਚੀਜ਼ GPU 'ਤੇ ਰਹਿਣੀ ਨਹੀਂ। ਜੇ ਤੁਹਾਡਾ ਵਰਕਲੋਡ ਛੋਟਾ, ਬ੍ਰਾਂਚ-ਭਰਿਆ, ਜਾਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਸੀਰੀਅਲ ਲੋਜਿਕ ਵਾਲਾ ਹੈ, ਤਾਂ CPU ਸਧਾਰਨ ਅਤੇ ਸਸਤਾ ਹੋ ਸਕਦਾ ਹੈ। ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਉਸ ਵੇਲੇ ਚਮਕਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ ਬਹੁਤ ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਗਣਿਤ ਇਕੱਠੇ ਚਲਾ ਸਕਦੇ ਹੋ—ਜਾਂ ਜਦੋਂ ਲੇਟੈਂਸੀ ਅਤੇ ਥਰੂਪੁੱਟ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਉਤਪਾਦ ਅਨੁਭਵ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ।
ਇੱਕ ਪ੍ਰਾਇਕਟਿਕ ਨੋਟ: ਜਿਵੇਂ ਜ਼ਿਆਦਾ ਟੀਮਾਂ AI-ਪਾਵਰਡ ਫੀਚਰ ਬਣਾਉਂਦੀਆਂ ਹਨ, ਰੁਕਾਵਟ ਅਕਸਰ ਹੁਣ “ਕੀ ਅਸੀਂ CUDA ਲਿਖ ਸਕਦੇ ਹਾਂ?” ਨਹੀਂ ਰਹਿੰਦੀ, ਬਲਕਿ “ਕੀ ਅਸੀਂ ਐਪ ਸ਼ਿਪ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਦੁਹਰਾਵਾਂ ਕਰ ਸਕਦੇ ਹਾਂ?” ਬਣ ਜਾਂਦੀ ਹੈ। ऐसे ਪਲੇਟਫਾਰਮ ਜਿਵੇਂ Koder.ai ਇੱਥੇ ਮਦਦਗਾਰ ਹੁੰਦੇ ਹਨ: ਤੁਸੀਂ ਚੈਟ-ਡ੍ਰਿਵਨ ਵਰਕਫਲੋ ਰਾਹੀਂ ਵੈੱਬ/ਬੈਕਐਂਡ/ਮੋਬਾਈਲ ਐਪਸ ਦਾ ਪ੍ਰੋਟੋਟਾਈਪ ਤੇਜ਼ੀ ਨਾਲ ਬਣਾਉਂਦੇ ਹੋ, ਫਿਰ ਜਦੋਂ ਤੁਹਾਨੂੰ ਐਕਸਲੇਰੇਸ਼ਨ ਦੀ ਲੋੜ ਹੋਵੇ ਤਾਂ GPU-ਬੈਕਡ inference ਸਰਵਿਸز ਨੂੰ ਪਿੱਛੇ ਸ਼ਾਮਿਲ ਕਰੋ—ਪੂਰੀ ਡਿਲਿਵਰੀ ਪਾਈਪਲਾਈਨ ਮੁੜ ਬਣਾਉਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ।
AI ਲਈ “ਇੱਕ GPU” ਖਰੀਦਣਾ ਅਸਲ ਵਿੱਚ ਇੱਕ ਛੋਟਾ ਪਲੇਟਫਾਰਮ ਖਰੀਦਣਾ ਹੁੰਦਾ ਹੈ: ਕੰਪਿਊਟ, ਮੈਮੋਰੀ, ਨੈਟਵਰਕਿੰਗ, ਸਟੋਰੇਜ, ਪਾਵਰ, ਕੂਲਿੰਗ, ਅਤੇ ਸਾਫਟਵੇਅਰ ਸਪੋਰਟ। ਸ਼ੁਰੂ 'ਚ ਥੋੜ੍ਹਾ ਢਾਂਚਾ ਤੁਹਾਨੂੰ ਮਾਡਲ ਵੱਡੇ ਹੋਣ ਜਾਂ ਉਪਯੋਗਤਾ ਵਧਣ ਸਮੇਂ ਦਰਦੋਂ ਬਚਾ ਸਕਦਾ ਹੈ।
ਆਪਣੇ ਅਗਲੇ 12–18 ਮਹੀਨਿਆਂ ਵਿੱਚ ਤੁਸੀਂ ਸਭ ਤੋਂ ਆਮ ਤੌਰ 'ਤੇ ਕੀ ਚਲਾਉਂਗੇ—ਟਰੇਨਿੰਗ, ਫਾਈਨ-ਟਿਊਨਿੰਗ, ਜਾਂ ਇਨਫਰੰਸ—ਅਤੇ ਮਾਡਲ ਸਾਈਜ਼ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਓ।
ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ GPU ਵੀ ਗਲਤ-ਮੈਚ ਬਾਕਸ ਵਿੱਚ ਘੱਟ ਪ੍ਰਦਰਸ਼ਨ ਦੇ ਸਕਦਾ ਹੈ। ਆਮ ਛੁਪੇ ਖ਼ਰਚ:
ਹਾਇਬ੍ਰਿਡ ਰੁਖ ਆਮ ਹੈ: ਬੇਸਲਾਈਨ ਸਮਰੱਥਾ ਓਨ-ਪ੍ਰੇਮ, ਸ਼ਿਖਰ ਟ੍ਰੇਨਿੰਗ ਦੌਰਾਨ ਕਲਾਉਡ 'ਤੇ ਬਰਸਟ।
ਵੈਂਡਰ ਜਾਂ ਅੰਦਰੂਨੀ ਪਲੇਟਫਾਰਮ ਟੀਮ ਨੂੰ ਪڇੋ:
ਇਨ੍ਹਾਂ ਜਵਾਬਾਂ ਨੂੰ ਇਕ ਉਤਪਾਦ ਦੇ ਅੰਗ ਵਾਂਗ ਲਓ: ਕਾਗ਼ਜ਼ 'ਤੇ ਸਭ ਤੋਂ ਵਧੀਆ GPU ਉਸ ਸਮੇਂ ਬਿਹਤਰ ਨਾਹ ਹੋਵੇ ਜੇ ਤੁਸੀਂ ਉਸਨੂੰ ਪਾਵਰ, ਕੂਲ, ਜਾਂ ਡੇਟਾ ਨਾਲ ਨਿਭਾ ਸਕਣੇ ਨਹੀਂ।
ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਵਿੱਚ ਅਸਲੀ ਲਾਭ ਹਾਂ, ਪਰ ਇਹ "ਮੁਫ਼ਤ ਪ੍ਰਦਰਸ਼ਨ" ਨਹੀਂ ਹੈ। ਜਿਹੜੇ ਚੋਣ ਤੁਸੀਂ GPUs, ਸਾਫਟਵੇਅਰ, ਅਤੇ ਆਪਰੇਸ਼ਨਾਂ ਲਈ ਕਰਦੇ ਹੋ, ਉਹ ਲੰਬੇ ਸਮੇਂ ਲਈ ਬਧੇ ਪਾਬੰਦੀਆਂ ਬਣ ਸਕਦੇ ਹਨ—ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਇਕ ਟੀਮ ਕਿਸੇ ਸਟੈਕ ਨੂੰ ਮਾਇਨਸ ਕਰ ਲੈਂਦੀ ਹੈ।
CUDA ਅਤੇ NVIDIA ਦੀ ਲਾਇਬ੍ਰੇਰੀ ਇਕੋਸਿਸਟਮ ਟੀਮਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਉਤਪਾਦਕ ਬਣਾਉਂਦੇ ਹਨ, ਪਰ ਉਹੀ ਸੌਖੀਅਤ ਪੋਰਟੇਬਿਲਟੀ ਘਟਾ ਸਕਦੀ ਹੈ। CUDA-ਨਿਰਭਰ ਕੋਡ, ਮੈਮੋਰੀ ਮੈਨੇਜਮੈਂਟ ਪੈਟਰਨ, ਜਾਂ ਮਾਲਕੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਨਾਨ-एनवीਡੀੀਆ ਐਕਸਲੇਰੇਟਰ 'ਤੇ ਲਿਜਾਣ ਲਈ ਮਹੱਤਵਪੂਰਕ ਰੀਵਰਕ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।
ਪ੍ਰਾਇਕਟਿਕ ਰੁਖ: “ਬਿਜ਼ਨਸ ਲਾਜਿਕ” ਨੂੰ “ਏਕਸਲੇਰੇਟਰ ਲਾਜਿਕ” ਤੋਂ ਵੱਖ ਕਰੋ: ਮਾਡਲ ਕੋਡ, ਡੇਟਾ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ, ਅਤੇ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਜ਼ਿਆਦਾ ਪੋਰਟੇਬਲ ਰੱਖੋ, ਅਤੇ ਕਸਟਮ GPU kernels ਨੂੰ ਇੱਕ ਸਾਫ ਇੰਟਰਫੇਸ ਦੇ ਪਿੱਛੇ ਛੱਡੋ। ਜੇ ਪੋਰਟੇਬਿਲਟੀ ਮਹੱਤਵਪੂਰਣ ਹੈ, ਤਾਂ ਅਹਿਮ ਵਰਕਲੋਡਾਂ ਨੂੰ ਘੱਟੋ-ਘੱਟ ਇੱਕ ਬਦਲਵੀਂ ਰਾਹ 'ਤੇ ਜਲਦੀ ਤੱਯਾਰ ਕਰਕੇ ਵੈਰਿਫਾਈ ਕਰੋ (ਭਾਵੇਂ ਉਹ ਹੌਲੇ ਹੋਵੇ) ਤਾਂ ਜੋ ਅਸਲੀ ਸਵਿੱਚਿੰਗ ਲਾਗਤ ਸਮਝ ਆ ਜਾਵੇ।
GPU ਸਪਲਾਈ ਅਸਥਿਰ ਹੋ ਸਕਦੀ ਹੈ, ਅਤੇ ਕੀਮਤਾਂ ਮੰਗ ਨਾਲ ਹਿਲਦੀਆਂ-ਦੁੰਦੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ। ਕੁੱਲ ਲਾਗਤ ਵੀ ਸਿਰਫ਼ ਹਾਰਡਵੇਅਰ ਨਹੀਂ: ਪਾਵਰ, ਕੁਲਿੰਗ, ਰੈਕ ਸਪੇਸ, ਅਤੇ ਸਟਾਫ਼ ਸਮਾਂ ਅਕਸਰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤੌਰ 'ਤੇ ਵੱਧ ਹੁੰਦੇ ਹਨ।
ਉਰਜਾ ਇੱਕ ਪਹਿਲਾ ਦਰਜੇ ਦਾ ਰੁਕਾਵਟ ਹੈ। ਤੇਜ਼ ਟਰੇਨਿੰਗ ਚੰਗੀ ਗੱਲ ਹੈ, ਪਰ ਜੇ ਇਸ ਨਾਲ ਪਾਵਰ ਖਪਤ ਦੂਣਾ ਹੋ ਜਾਂਦੀ ਹੈ ਬਿਨਾਂ ਸਮੇਂ-ਤੱਕ-ਨਤੀਜੇ ਸੁਧਾਰ ਦੇ, ਤਾਂ ਤੁਸੀਂ ਹੋਰ ਖਰਚਾਂ ਭੁਗਤਣਗੇ। ਉਹ ਮੈਟਰਿਕਸ ਜਿਵੇਂ cost per training run, tokens per joule, ਅਤੇ utilization ਟਰੈਕ ਕਰੋ—ਸਿਰਫ਼ “GPU ਘੰਟੇ” ਨਹੀਂ।
ਜਦੋਂ ਕਈ ਟੀਮ GPUs ਸਾਂਝਾ ਕਰਦੀਆਂ ਹਨ, ਬੁਨਿਆਦੀ ਸੁਰੱਖਿਆ ਵੀ ਮਹੱਤਵਪੂਰਕ ਹੁੰਦੀ ਹੈ: ਮਜ਼ਬੂਤ ਟੈਨੈਂਸੀ ਬਾਊਂਡਰੀਜ਼, ਡੀਟ ਕੀਤੀ ਪਹੁੰਚ, ਪੈਚ ਕੀਤੇ ਡਰਾਈਵਰ, ਅਤੇ ਮਾਡਲ ਵਜ਼ਨ/ਡੇਟਾਸੇਟਾਂ ਦੀ ਸੰਭਾਲ। ਉਹ ਇਜਾਜ਼ਤ ਆਧਾਰ-ਸਹਾਇਕ ਪ੍ਰਿਮਿਟਿਵ ਪ੍ਰੇਫਰ ਕਰੋ (ਕন্টੇਨਰ/VMs, ਪਰ-ਜੌਬ ਕਰੈਡੈਂਸ਼ਲਸ, ਨੈੱਟਵਰਕ ਸੈਗਮੈਂਟੇਸ਼ਨ) ਅਤੇ GPU ਨੋਡਾਂ ਨੂੰ ਉੱਚ-ਮੁੱਲ ਵਾਲੇ ਐੱਸੈੱਟ ਸਮਝੋ—ਕਿਉਂਕਿ ਉਹ ਹਕੀਕਤ ਵਿੱਚ ਹਨ।
ਤਿੰਨ ਖੇਤਰਾਂ ਵਿੱਚ ਤਰੱਕੀ ਦੀ ਉਮੀਦ ਕਰੋ: ਵਧੀਕ ਪ੍ਰਭਾਵਸ਼ੀਲਤਾ (ਪ੍ਰਤੀ ਵੈੱਟ ਪ੍ਰਦਰਸ਼ਨ), GPUs/ਨੋਡਾਂ ਵਿਚਕਾਰ ਤੇਜ਼ ਨੈੱਟਵਰਕਿੰਗ, ਅਤੇ ਹੋਰ ਪਰਿਪੱਕ੍ਵ ਸਾਫਟਵੇਅਰ ਪਰਤਾਂ ਜੋ ਓਪਰੇਸ਼ਨਲ friction ਘਟਾਉਂਦੀਆਂ ਹਨ (ਪਰੋਫ਼ਾਈਲਿੰਗ, ਸ਼ੈਡਿਊਲਿੰਗ, ਦੁਹਰਾਵਤਾ, ਅਤੇ ਸੁਰੱਖਿਅਤ ਬਹੁ-ਟੈਨੈਂਟ ਸ਼ੇਅਰਿੰਗ)।
ਜੇ ਤੁਸੀਂ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਅਪਨਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਕ ਜਾਂ ਦੋ ਪ੍ਰਤੀਨਿਧਿ ਵਰਕਲੋਡਾਂ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਐਂਡ-ਟੂ-ਐਂਡ ਲਾਗਤ ਅਤੇ ਲੇਟੈਂਸੀ ਨੂੰ ਮਾਪੋ, ਅਤੇ ਪੋਰਟੇਬਿਲਟੀ ਅਨੁਮਾਨ ਦਸਤਾਵੇਜ਼ ਕਰੋ। ਫਿਰ ਇਕ ਛੋਟਾ “ਗੋਲਡਨ ਪਾਥ” ਬਣਾਓ (ਸਟੈਂਡਰਡ ਇਮੇਜ, ਡਰਾਈਵਰ, ਮਾਨੀਟਰਿੰਗ, ਅਤੇ ਪਹੁੰਚ ਨਿਯੰਤਰਣ) ਪੈਦਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਹੋਰ ਟੀਮਾਂ ਲਈ ਸਕੇਲ ਕਰੋ।
For related planning, see /blog/choosing-gpus-and-platforms and /blog/scaling-up-and-scaling-out.
ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਦਾ ਅਰਥ ਸਧਾਰਨ ਸ਼ਬਦਾਂ ਵਿੱਚ ਇਹ ਹੈ ਕਿ “ਭਾਰੀ, ਦੁਹਰਾਉਂਦੇ ਗਣਿਤ” ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪ੍ਰੋਸੈਸਰ (ਅਕਸਰ GPU) 'ਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਨਾ ਕਿ ਆਮ-ਮਕਸਦ CPU ਨੂੰ ਹਰ ਕੰਮ ਕਰਨ ਲਈ ਮਜ਼ਬੂਰ ਕੀਤਾ ਜਾਵੇ।
ਅਮਲ ਵਿੱਚ, CPU ਐਪਲੀਕੇਸ਼ਨ ਅਤੇ ਡਾਟਾ ਫਲੋ ਨੂੰ ਸੰਚਾਲਿਤ ਕਰਦਾ ਹੈ, ਜਦਕਿ GPU ਹਜ਼ਾਰਾਂ ਮਿਲਦੇ-ਜੁਲਦੇ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਚਲਾਉਂਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਮੈਟ੍ਰਿਕਸ ਗੁਣਾ)।
CPU ਨਿਯੰਤਰਣ ਪ੍ਰਵਾਹ ਲਈ ਅਨੁਕੂਲ ਬਣੇ ਹੁੰਦੇ ਹਨ: ਬਹੁਤ ਸਾਰੀ ਸ਼ਾਖਾ, ਟਾਸਕ ਸਵਿੱਚਿੰਗ, ਅਤੇ ਓਐਸ ਚਲਾਉਣਾ।
GPU ਥਰੂਪੁੱਟ ਲਈ ਅਨੁਕੂਲ ਹੁੰਦੇ ਹਨ: ਵੱਡੀ ਰਕਮ ਦੇ ਡੇਟੇ 'ਤੇ ਇੱਕੋ ਹੀ ਆਪਰੇਸ਼ਨ ਨੂੰ ਇੱਕ ਵਾਰੀ ਵਿਚ ਲਾ ਕੇ। ਬਹੁਤ ਸਾਰੇ AI, ਵੀਡੀਓ, ਅਤੇ ਸਿਮੂਲੇਸ਼ਨ ਕੁਝ ਐਸੇ ਪੈਟਰਨਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ, ਇਸ ਲਈ GPU ਵਿਸ਼ੇਸ਼ ਹਿੱਸਿਆਂ ਲਈ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੋ ਸਕਦੇ ਹਨ।
ਨਹੀਂ—ਜਿਆਦਾਤਰ ਅਸਲ ਪ੍ਰਣਾਲੀਆਂ ਦੋਹਾਂ ਵਰਤਦੀਆਂ ਹਨ।
ਜੇ CPU, ਸਟੋਰੇਜ ਜਾਂ ਨੈੱਟਵਰਕ ਨਾਲ ਗੈਰ-ਸਮਰੱਥਾ ਹੋਵੇ, ਤਾਂ GPU ਬੇਕਾਰ ਬੈਠ ਸਕਦਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਉਮੀਦ ਕੀਤੀ ਗਈ ਤੇਜ਼ੀ ਨਹੀਂ ਦੇਖੋਗੇ।
ਲੋਕ ਅਕਸਰ ਤਿੰਨ ਪਰਤਾਂ ਨੂੰ ਮਿਲ ਕੇ “NVIDIA ਦੀ ਤੇਜ਼-ਤਰਾਰ ਕੰਪਿਊਟਿੰਗ ਸਟੈਕ” ਮੰਨਦੇ ਹਨ:
CUDA NVIDIA ਦਾ ਸਾਫਟਵੇਅਰ ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ ਵਿਕਸਿਤਕਾਰਾਂ ਨੂੰ NVIDIA GPUs 'ਤੇ ਜਨਰਲ-ਪਰਪਜ਼ ਗਣਨਾ ਚਲਾਉਣ ਦਿੰਦਾ ਹੈ।
ਇਸ ਵਿੱਚ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਮਾਡਲ (kernels/threads), ਕੰਪਾਈਲਰ ਟੂਲਚੇਨ, ਰਨਟਾਈਮ ਅਤੇ ਡਰਾਈਵਰ ਸ਼ਾਮਿਲ ਹਨ—ਤਾਂ ਜੋ ਅਕਸਰ ਤੁਸੀਂ ਆਮ ਕੰਮਾਂ ਲਈ ਕੁੜੀ CUDA ਨਹੀਂ ਲਿਖਣੀ ਪੈਦੀ।
ਇੱਕ kernel ਉਹ ਫੰਕਸ਼ਨ ਹੁੰਦੀ ਹੈ ਜੋ ਤੁਹਾਡਾ ਕੰਮ ਹੁਣੇ-ਹੁਣੇ ਕਈ ਵਾਰੀ ਚਲਾਉਣ ਲਈ ਬਣਾਈਦੀ ਹੈ।
ਇਸ ਦੀ ਜਗ੍ਹਾ, ਤੁਸੀਂ ਇਸਨੂੰ ਹਜ਼ਾਰਾਂ ਜਾਂ ਲੱਖਾਂ ਹਲਕੇ threads 'ਤੇ ਲਾਂਚ ਕਰਦੇ ਹੋ, ਜਿੱਥੇ ਹਰ thread ਕੰਮ ਦਾ ਇੱਕ ਛੋਟਾ ਹਿੱਸਾ ਸੰਭਾਲਦਾ ਹੈ (ਇੱਕ ਐਲਿਮੈਂਟ, ਇੱਕ ਪਿਕਸਲ, ਇੱਕ ਮੈਟ੍ਰਿਕਸ ਰੋ)। GPU ਇਹਨਾਂ threads ਨੂੰ ਆਪਣੇ ਬਹੁਤ ਸਾਰੇ ਕੋਰਾਂ 'ਤੇ ਸਮਰੱਥਾ ਨਾਲ ਸ਼ਡਿਊਲ ਕਰਦਾ ਹੈ।
ਕਿਸੇ ਨੀਤੀ ਦੇ ਮੁਤਾਬਕ, ਸਭ ਤੋਂ ਮਹਿੰਗਾ ਕੰਮ ਟੈਨਸਰ ਗਣਿਤ 'ਤੇ ਆਧਾਰਿਤ ਹੁੰਦਾ ਹੈ—ਖਾਸ ਤੌਰ 'ਤੇ ਮੈਟ੍ਰਿਕਸ ਗੁਣਾ ਅਤੇ convolution ਵਰਗੀਆਂ ਕਾਰਵਾਈਆਂ।
GPUs ਹਜ਼ਾਰਾਂ ਇੱਕੋ ਜਿਹੇ ਗਣਨਾ-ਐਕਸ਼ਨਾਂ ਨੂੰ ਇਕੱਠੇ ਚਲਾਉਣ ਲਈ ਬਣੇ ਹਨ, ਅਤੇ ਆਧੁਨਿਕ GPUs ਵਿੱਚ ਖਾਸ units ਵੀ ਹੁੰਦੀਆਂ ਹਨ ਜੋ tensor-ਭਾਰਤਕ ਨਮੂਨਿਆਂ ਨੂੰ ਵੱਧ ਪ੍ਰਭਾਵੀ ਤਰੀਕੇ ਨਾਲ ਸਲਾਹ ਦਿੰਦੇ ਹਨ।
Training ਆਮ ਤੌਰ ਤੇ ਕੁੱਲ ਕੰਪਿਊਟ ਅਤੇ ਵੱਡੀਆਂ ਟੈਨਸਰਾਂ ਨੂੰ ਯਾਦاشت 'ਚ ਵਾਰ-ਵਾਰ ਲਿਜਾਣ ਨਾਲ ਸੀਮਿਤ ਹੁੰਦਾ ਹੈ (ਅਤੇ ਜੇ ਵੰਡਿਆ ਹੋਇਆ ਹੋਵੇ ਤਾਂ ਸੰਚਾਰ ਨਾਲ)।
Inference ਅਕਸਰ ਲੇਟੈਂਸੀ ਹਦਾਂ, ਥਰੂਪੁੱਟ, ਅਤੇ ਡੇਟਾ ਮੂਵਮੈਂਟ ਨਾਲ ਸੀਮਿਤ ਹੁੰਦਾ ਹੈ—GPU ਨੂੰ ਲਗਾਤਾਰ ਰੱਖਣ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਸਮਾਂ ਪੂਰਾ ਕਰਨ ਲਈ। ਦੋਹਾਂ ਲਈ ਅਲੱਗ-ਅਲੱਗ ਅਪਟਾਈਮਾਈਜ਼ੇਸ਼ਨਾਂ (ਬੈਚਿੰਗ, ਕਵਾਂਟਾਈਜ਼ੇਸ਼ਨ, ਬਿਹਤਰ ਪਾਈਪਲਾਈਨ) ਦੀ ਲੋੜ ਪੈ ਸਕਦੀ ਹੈ।
VRAM ਇਹ ਸਿਮਿਤੀ ਹੈ ਕਿ ਇੱਕ ਵੇਲੇ GPU 'ਤੇ ਕੀ ਰਹਿ ਸਕਦਾ ਹੈ: ਮਾਡਲ ਵਜ਼ਨ, ਐਕਟੀਵੇਸ਼ਨ ਅਤੇ ਬੈਚ ਡੇਟਾ।
ਜੇ VRAM ਖਤਮ ਹੋ ਜਾਏ, ਤਾਂ ਆਮ ਤੌਰ 'ਤੇ ਤੁਹਾਨੂੰ:
ਕਈ ਪ੍ਰੋਜੈਕਟ ਪਹਿਲਾਂ ਮੈਮੋਰੀ ਸੀਮਾਵਾਂ ਨਾਲ ਟਕਰਾਉਂਦੇ ਹਨ, ਨਿਰਪੱਖ “ਕੱਚਾ ਕੰਪਿਊਟ” ਸੀਮੇ ਤੋਂ ਪਹਿਲਾਂ।
GPU ਖਰੀਦਣਾ ਅਸਲ ਵਿੱਚ ਇੱਕ ਛੋਟਾ ਪਲੇਟਫਾਰਮ ਖਰੀਦਣ ਜਿਹਾ ਹੈ: ਕੰਪਿਊਟ, ਮੈਮੋਰੀ, ਨੈਟਵਰਕਿੰਗ, ਸਟੋਰੇਜ, ਪਾਵਰ, ਕੂਲਿੰਗ ਅਤੇ ਸਾਫਟਵੇਅਰ ਸਪੋਰਟ।
ਖਰੀਦਣ ਤੋਂ ਪਹਿਲਾਂ ਪੁੱਛੋ:
ਇਹ ਜਵਾਬ ਇੱਕ ਉਤਪਾਦ ਦੇ ਅંਸ਼ ਵਾਂਗ ਗਿਣੋ: ਸਭ ਤੋਂ ਵਧੀਆ GPU ਕਾਗਜ਼ 'ਤੇ ਸਾਰਥਕ ਨਹੀਂ ਜਦੋਂ ਤਕ ਤੁਸੀਂ ਉਸਨੂੰ ਚਲਾਉਣ ਜਾਂ ਸਪੋਰਟ ਕਰਨ ਦੀ ਯੋਜਨਾ ਨਾ ਬਣਾਓ।