ਵੱਡੇ ਭਾਸ਼ਾ ਦੇ ਮਾਡਲਾਂ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ ਗਈ: ਐਲਐਲਐਮ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਅਤੇ ਕੁਬਰਨੇਟਸ 'ਤੇ ਆਪਣਾ ਖੁਦ ਦਾ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ

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

1. ਅਸਲ ਵਿੱਚ ਇੱਕ ਵੱਡੀ ਭਾਸ਼ਾ ਦਾ ਮਾਡਲ ਕੀ ਹੈ?

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

ਸ਼ਬਦ "ਵੱਡਾ" ਅਸਲ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। ਇਹਨਾਂ ਮਾਡਲਾਂ ਵਿੱਚ ਅਰਬਾਂ ਅੰਦਰੂਨੀ ਸੰਖਿਆਵਾਂ ਹੁੰਦੀਆਂ ਹਨ (ਜਿਸਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਪੈਰਾਮੀਟਰ) ਜੋ ਸਿਖਲਾਈ ਦੌਰਾਨ ਟਿਊਨ ਹੋ ਜਾਂਦੇ ਹਨ। ਜਦੋਂ ਲੋਕ ਕਹਿੰਦੇ ਹਨ ਕਿ ਇੱਕ ਮਾਡਲ "7B" ਜਾਂ "70B" ਹੈ, ਤਾਂ ਉਹਨਾਂ ਦਾ ਮਤਲਬ 7 ਬਿਲੀਅਨ ਜਾਂ 70 ਬਿਲੀਅਨ ਪੈਰਾਮੀਟਰ ਹੈ। ਵਧੇਰੇ ਮਾਪਦੰਡਾਂ ਦਾ ਆਮ ਤੌਰ 'ਤੇ ਮਤਲਬ ਹੁੰਦਾ ਹੈ ਵਧੇਰੇ ਸਮਰੱਥਾ - ਅਤੇ ਮੈਮੋਰੀ ਅਤੇ ਗਣਨਾ ਲਈ ਇੱਕ ਵੱਡੀ ਭੁੱਖ।

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

2. ਉਹ ਅਸਲ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

ਹੁੱਡ ਦੇ ਹੇਠਾਂ ਪੰਜ ਵਿਚਾਰ ਹਨ. ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ ਗਣਿਤ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ — ਹਰ ਇੱਕ ਦੀ ਰੋਜ਼ਾਨਾ ਸਮਾਨਤਾ ਹੁੰਦੀ ਹੈ।

2.1 ਟੋਕਨ - ਟੈਕਸਟ ਨੂੰ ਟੁਕੜਿਆਂ ਵਿੱਚ ਕੱਟਣਾ

ਮਾਡਲ ਪੂਰੇ ਸ਼ਬਦ ਨਹੀਂ ਪੜ੍ਹਦੇ। ਉਹ ਟੈਕਸਟ ਨੂੰ ਇਸ ਵਿੱਚ ਵੰਡਦੇ ਹਨ ਟੋਕਨ: ਅੱਖਰਾਂ ਦੇ ਸਾਂਝੇ ਹਿੱਸੇ। "ਕੁਬਰਨੇਟਸ" ਬਣ ਸਕਦਾ ਹੈ Kub + ernetes; "ਚੱਲਣਾ" ਹੋ ਸਕਦਾ ਹੈ run + ning. ਮੋਟੇ ਤੌਰ 'ਤੇ, 1 ਟੋਕਨ ≈ 0.75 ਅੰਗਰੇਜ਼ੀ ਸ਼ਬਦ, ਇਸ ਲਈ 1,000 ਟੋਕਨ ਲਗਭਗ 750 ਸ਼ਬਦ ਹਨ। ਇਹ ਵਪਾਰਕ ਤੌਰ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਹੈ: ਹੋਸਟ ਕੀਤੇ APIs ਬਿੱਲ ਪ੍ਰਤੀ ਟੋਕਨ, ਅਤੇ ਇੱਕ ਮਾਡਲ ਸੰਦਰਭ ਵਿੰਡੋ (ਇਹ ਇੱਕ ਵਾਰ ਵਿੱਚ ਕਿੰਨਾ "ਵੇਖ" ਸਕਦਾ ਹੈ) ਟੋਕਨਾਂ ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।

2.2 ਏਮਬੈਡਿੰਗਜ਼ - ਸ਼ਬਦਾਂ ਨੂੰ ਅਰਥ ਦੇ ਧੁਰੇ ਵਿੱਚ ਬਦਲਣਾ

ਹਰੇਕ ਟੋਕਨ ਨੂੰ ਸੰਖਿਆਵਾਂ ਦੀ ਇੱਕ ਲੰਮੀ ਸੂਚੀ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ - ਇੱਕ ਏਮਬੈਡਿੰਗ - ਜੋ ਸਪੇਸ ਵਿੱਚ ਇੱਕ ਬਿੰਦੂ ਦੇ ਰੂਪ ਵਿੱਚ ਇਸਦੇ ਅਰਥ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇੱਕੋ ਜਿਹੇ ਤਰੀਕਿਆਂ ਨਾਲ ਵਰਤੇ ਗਏ ਸ਼ਬਦ ਇੱਕ ਦੂਜੇ ਦੇ ਨੇੜੇ ਆ ਜਾਂਦੇ ਹਨ। "ਰਾਜਾ" ਅਤੇ "ਰਾਣੀ" ਇਕੱਠੇ ਬੈਠਦੇ ਹਨ; "ਰਾਜਾ" ਅਤੇ "ਕੇਲਾ" ਦੂਰ ਬੈਠਦੇ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਮਸ਼ੀਨ ਜੋ ਸਿਰਫ ਅੰਕ ਗਣਿਤ ਕਰਦੀ ਹੈ ਹੇਰਾਫੇਰੀ ਕਰ ਸਕਦੀ ਹੈ ਮਤਲਬ: ਅਰਥ ਨੂੰ ਜਿਓਮੈਟਰੀ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ।

2.3 ਟ੍ਰਾਂਸਫਾਰਮਰ ਅਤੇ "ਧਿਆਨ" - 2017 ਦੀ ਸਫਲਤਾ

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

2.4 ਸਿਖਲਾਈ - ਤਿੰਨ ਪੜਾਅ

1. ਪ੍ਰੀ-ਟ੍ਰੇਨਿੰਗ: ਮਾਡਲ ਨੂੰ ਲੁਕੇ ਹੋਏ ਆਖਰੀ ਸ਼ਬਦ ਦੇ ਨਾਲ ਅਰਬਾਂ ਵਾਕਾਂ ਨੂੰ ਦਿਖਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਇਸਦਾ ਅਨੁਮਾਨ ਲਗਾਉਣ ਲਈ ਕਿਹਾ ਗਿਆ ਹੈ। ਇਸਨੂੰ ਗਲਤ ਸਮਝੋ, ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਦਬਾਓ, ਦੁਹਰਾਓ — ਖਰਬਾਂ ਵਾਰ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਇਹ ਵਿਆਕਰਣ, ਤੱਥਾਂ, ਤਰਕ ਦੇ ਪੈਟਰਨਾਂ ਅਤੇ ਕੋਡ ਨੂੰ ਜਜ਼ਬ ਕਰਦਾ ਹੈ। ਇਹ ਮਹਿੰਗਾ ਹਿੱਸਾ ਵੀ ਹੈ, GPU ਸਮੇਂ ਵਿੱਚ ਲੱਖਾਂ ਪੌਂਡ ਦੀ ਲਾਗਤ.
2. ਫਾਈਨ ਟਿਊਨਿਂਗ: ਫਿਰ ਕੱਚੇ ਮਾਡਲ ਨੂੰ ਮਦਦਗਾਰ ਸਵਾਲ-ਜਵਾਬ ਵਿਵਹਾਰ ਦੀਆਂ ਕਿਊਰੇਟ ਕੀਤੀਆਂ ਉਦਾਹਰਣਾਂ 'ਤੇ ਸਿਖਲਾਈ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਇਸਲਈ ਇਹ ਸਵੈ-ਸੰਪੂਰਨ ਹੋਣ ਦੀ ਬਜਾਏ ਇੱਕ ਸਹਾਇਕ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ।
3. ਅਲਾਈਨਮੈਂਟ (RLHF): ਅੰਤ ਵਿੱਚ, ਮਨੁੱਖ ਮਾਡਲ ਦੇ ਜਵਾਬਾਂ ਨੂੰ ਦਰਜਾ ਦਿੰਦੇ ਹਨ ਅਤੇ ਉਸ ਫੀਡਬੈਕ ਦੀ ਵਰਤੋਂ ਇਸਨੂੰ ਵਧੇਰੇ ਮਦਦਗਾਰ, ਇਮਾਨਦਾਰ ਅਤੇ ਸੁਰੱਖਿਅਤ ਬਣਾਉਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹੀ ਕਾਰਨ ਹੈ ਕਿ ਇੱਕ ਚੈਟ ਮਾਡਲ ਹਾਨੀਕਾਰਕ ਬੇਨਤੀਆਂ ਨੂੰ ਅਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਇਕਸਾਰ ਸੁਰ ਅਪਣਾ ਲੈਂਦਾ ਹੈ।

2.5 ਅਨੁਮਾਨ - ਇਹ ਤੁਹਾਨੂੰ ਕਿਵੇਂ ਜਵਾਬ ਦਿੰਦਾ ਹੈ

ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਪ੍ਰੋਂਪਟ ਭੇਜਦੇ ਹੋ, ਤਾਂ ਮਾਡਲ ਜਵਾਬ ਤਿਆਰ ਕਰਦਾ ਹੈ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਟੋਕਨ: ਇਹ ਸਭ ਤੋਂ ਵੱਧ ਸੰਭਾਵਿਤ ਅਗਲੇ ਟੋਕਨ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ, ਇਸਨੂੰ ਜੋੜਦਾ ਹੈ, ਫਿਰ ਅਗਲੇ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਹੋਰ - ਜਿਵੇਂ ਇੱਕ ਤੇਜ਼, ਚੰਗੀ ਤਰ੍ਹਾਂ ਪੜ੍ਹਿਆ ਹੋਇਆ ਵਿਅਕਤੀ ਪਹਿਲਾਂ ਪੂਰੇ ਵਾਕ ਦੀ ਯੋਜਨਾ ਬਣਾਏ ਬਿਨਾਂ ਸ਼ਬਦ ਦੁਆਰਾ ਸ਼ਬਦ ਲਿਖਦਾ ਹੈ। ਇੱਕ ਸੈਟਿੰਗ ਕਹਿੰਦੇ ਹਨ ਤਾਪਮਾਨ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਕਿੰਨਾ ਸਾਹਸੀ ਹੈ: ਘੱਟ ਤਾਪਮਾਨ ਸੁਰੱਖਿਅਤ, ਦੁਹਰਾਉਣ ਯੋਗ ਜਵਾਬ ਦਿੰਦਾ ਹੈ (ਕੋਡ ਅਤੇ ਕੱਢਣ ਲਈ ਵਧੀਆ); ਉੱਚ ਤਾਪਮਾਨ ਰਚਨਾਤਮਕ, ਵੱਖੋ-ਵੱਖਰੇ ਜਵਾਬ ਦਿੰਦਾ ਹੈ (ਵਿਗਿਆਨੀ ਲਈ ਵਧੀਆ)। ਇਸ ਟੋਕਨ-ਬਾਈ-ਟੋਕਨ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਨੁਮਾਨ, ਅਤੇ ਇਹ ਉਹ ਹਿੱਸਾ ਹੈ ਜਿਸ ਲਈ ਤੁਸੀਂ ਉਤਪਾਦਨ ਵਿੱਚ ਭੁਗਤਾਨ ਕਰਦੇ ਹੋ — ਹਰ ਬੇਨਤੀ GPU ਚੱਕਰਾਂ ਨੂੰ ਸਾੜਦੀ ਹੈ।

3. LLM ਕੀ ਚੰਗੇ ਅਤੇ ਬੁਰੇ ਹਨ

ਟੂਲ ਦੇ ਕਿਨਾਰਿਆਂ ਨੂੰ ਜਾਣਨਾ ਮਹਿੰਗੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।

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

4. ਸ਼ਬਦਾਵਲੀ, ਡੀਕੋਡ ਕੀਤੀ ਗਈ

5. ਆਪਣਾ ਖੁਦ ਦਾ LLM ਕਿਉਂ ਚਲਾਓ?

ਹੋਸਟ ਕੀਤੇ API (ਓਪਨਏਆਈ, ਐਂਥਰੋਪਿਕ, ਅਤੇ ਹੋਰ) ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕਾ ਹੈ ਅਤੇ ਸ਼ਾਨਦਾਰ ਹਨ। ਪਰ ਚਾਰ ਕਾਰਨ ਹਨ ਕਿ ਸੰਸਥਾਵਾਂ ਇੱਕ ਓਪਨ-ਵੇਟ ਮਾਡਲ ਜਿਵੇਂ ਕਿ ਲਾਮਾ, ਮਿਸਟਰਲ, ਕਵੇਨ, ਜਾਂ ਜੇਮਾ ਨੂੰ ਸਵੈ-ਮੇਜ਼ਬਾਨੀ ਕਰਨ ਦੀ ਚੋਣ ਕਰਦੀਆਂ ਹਨ:

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

ਵਪਾਰ-ਬੰਦ ਉਹ ਹੈ ਤੁਸੀਂ ਹੁਣ ਹਾਰਡਵੇਅਰ, ਸਕੇਲਿੰਗ, ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ ਦੇ ਮਾਲਕ ਹੋ — ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕੁਬਰਨੇਟਸ ਚੰਗਾ ਹੈ।

6. ਹਾਰਡਵੇਅਰ ਅਸਲੀਅਤ (ਤੈਨਾਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਪੜ੍ਹੋ)

ਇੱਕ LLM ਦਾ ਵਜ਼ਨ GPU ਮੈਮੋਰੀ (VRAM) ਵਿੱਚ ਫਿੱਟ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। ਅੰਗੂਠੇ ਦਾ ਇੱਕ ਮੋਟਾ ਨਿਯਮ:

ਦੋ ਸਰਵਿੰਗ ਇੰਜਣ ਅਸਲ ਤੈਨਾਤੀਆਂ 'ਤੇ ਹਾਵੀ ਹਨ:

• ਓਲਾਮਾ — ਰੈਂਪ 'ਤੇ ਸਭ ਤੋਂ ਆਸਾਨ। ਵਿਕਾਸ, ਅੰਦਰੂਨੀ ਟੂਲਸ, ਅਤੇ CPU ਜਾਂ ਸਿੰਗਲ-GPU ਨੋਡਾਂ ਲਈ ਵਧੀਆ। ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਕੁਆਂਟਾਈਜ਼ਡ ਮਾਡਲਾਂ ਨੂੰ ਖਿੱਚਦਾ ਹੈ।
• vLLM - ਉਤਪਾਦਨ ਦਾ ਕੰਮ ਦਾ ਘੋੜਾ। ਉੱਚ-ਥਰੂਪੁਟ, ਬਹੁਤ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਬੈਚ ਕਰਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਦਾ ਹੈ OpenAI- ਅਨੁਕੂਲ API ਇਸ ਲਈ ਤੁਹਾਡਾ ਮੌਜੂਦਾ ਕੋਡ ਇੱਕ-ਲਾਈਨ URL ਤਬਦੀਲੀ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। (ਹੱਗਿੰਗ ਫੇਸ TGI ਇੱਕ ਨਜ਼ਦੀਕੀ ਵਿਕਲਪ ਹੈ।)

7. ਕੁਬਰਨੇਟਸ 'ਤੇ ਆਪਣੇ ਖੁਦ ਦੇ LLM ਨੂੰ ਤੈਨਾਤ ਕਰਨਾ

ਹੇਠਾਂ ਦਿੱਤੀ ਹਰ ਚੀਜ਼ ਘੱਟੋ-ਘੱਟ ਇੱਕ GPU ਨੋਡ ਦੇ ਨਾਲ ਇੱਕ ਕਲੱਸਟਰ ਮੰਨਦੀ ਹੈ ਅਤੇ NVIDIA ਡਿਵਾਈਸ ਪਲੱਗਇਨ ਸਥਾਪਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਜੋ GPUs ਨੂੰ ਤਹਿ ਕਰਨ ਯੋਗ ਸਰੋਤ ਵਜੋਂ ਉਜਾਗਰ ਕਰਦਾ ਹੈ nvidia.com/gpu. ਅਸੀਂ ਇਸ ਨੂੰ ਟੁਕੜੇ-ਟੁਕੜੇ ਬਣਾਵਾਂਗੇ।

7.1 ਇੱਕ ਨੇਮਸਪੇਸ ਅਤੇ ਮਾਡਲ ਵਜ਼ਨ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਜਗ੍ਹਾ

ਮਾਡਲ ਫਾਈਲਾਂ ਵੱਡੀਆਂ (ਗੀਗਾਬਾਈਟ) ਅਤੇ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਹੌਲੀ ਹੁੰਦੀਆਂ ਹਨ, ਇਸਲਈ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਏ ਸਥਾਈ ਵੌਲਯੂਮ ਦਾਅਵਾ ਹਰ ਪੌਡ ਰੀਸਟਾਰਟ 'ਤੇ ਦੁਬਾਰਾ ਖਿੱਚਣ ਦੀ ਬਜਾਏ.

apiVersion: v1
kind: Namespace
metadata:
  name: llm
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: model-cache
  namespace: llm
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 100Gi          # weights are big; size generously
  # storageClassName: fast-ssd   # use an SSD class if your cluster offers one

7.2 ਵਿਕਲਪ A — ਓਲਾਮਾ (ਆਸਾਨ ਸ਼ੁਰੂਆਤ)

ਓਲਾਮਾ ਪਹਿਲੀ ਤੈਨਾਤੀ ਜਾਂ ਅੰਦਰੂਨੀ ਟੂਲ ਲਈ ਆਦਰਸ਼ ਹੈ। ਇਹ ਇਸਨੂੰ ਇੱਕ GPU ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ; ਨੂੰ ਮਿਟਾਓ nvidia.com/gpu ਸੀਪੀਯੂ-ਸਿਰਫ਼ ਬੀਫੀ ਨੋਡ 'ਤੇ ਚਲਾਉਣ ਦੀ ਸੀਮਾ।

apiVersion: apps/v1
kind: Deployment
metadata:
  name: ollama
  namespace: llm
  labels:
    app: ollama
spec:
  replicas: 1
  selector:
    matchLabels:
      app: ollama
  template:
    metadata:
      labels:
        app: ollama
    spec:
      containers:
        - name: ollama
          image: ollama/ollama:latest
          ports:
            - containerPort: 11434
          resources:
            requests:
              cpu: "2"
              memory: 8Gi
            limits:
              nvidia.com/gpu: 1        # remove this line for CPU-only
              memory: 16Gi
          volumeMounts:
            - name: models
              mountPath: /root/.ollama
          readinessProbe:
            httpGet:
              path: /
              port: 11434
            initialDelaySeconds: 10
            periodSeconds: 10
      volumes:
        - name: models
          persistentVolumeClaim:
            claimName: model-cache
---
apiVersion: v1
kind: Service
metadata:
  name: ollama
  namespace: llm
spec:
  selector:
    app: ollama
  ports:
    - port: 80
      targetPort: 11434

ਇੱਕ ਵਾਰ ਪੌਡ ਚੱਲ ਰਿਹਾ ਹੈ, ਇੱਕ ਮਾਡਲ ਨੂੰ ਕੈਸ਼ ਵਿੱਚ ਖਿੱਚੋ ਅਤੇ ਇਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰੋ:

# pull a quantized model into the PVC (one-off)
kubectl -n llm exec deploy/ollama -- ollama pull llama3

# ask it something from inside the cluster
kubectl -n llm exec deploy/ollama -- \
  ollama run llama3 "Explain Kubernetes in one sentence."

7.3 ਵਿਕਲਪ B — vLLM (ਉਤਪਾਦਨ ਥਰੂਪੁੱਟ, OpenAI- ਅਨੁਕੂਲ)

ਅਸਲ ਟ੍ਰੈਫਿਕ ਲਈ, vLLM ਬਹੁਤ ਸਾਰੀਆਂ ਸਮਕਾਲੀ ਬੇਨਤੀਆਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਅਤੇ OpenAI API ਬੋਲੀ ਬੋਲਦਾ ਹੈ। ਗੇਟਡ ਮਾਡਲਾਂ (ਜਿਵੇਂ ਕਿ ਲਾਮਾ) ਨੂੰ ਇੱਕ ਹੱਗਿੰਗ ਫੇਸ ਟੋਕਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜੋ ਇੱਕ ਗੁਪਤ ਵਜੋਂ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

apiVersion: v1
kind: Secret
metadata:
  name: hf-token
  namespace: llm
type: Opaque
stringData:
  token: "hf_xxxxxxxxxxxxxxxxxxxxxxxx"   # your Hugging Face access token
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-mistral
  namespace: llm
  labels:
    app: vllm-mistral
spec:
  replicas: 1
  selector:
    matchLabels:
      app: vllm-mistral
  template:
    metadata:
      labels:
        app: vllm-mistral
    spec:
      containers:
        - name: vllm
          image: vllm/vllm-openai:latest
          args:
            - "--model"
            - "mistralai/Mistral-7B-Instruct-v0.3"
            - "--max-model-len"
            - "8192"
            - "--gpu-memory-utilization"
            - "0.90"
          ports:
            - containerPort: 8000
          env:
            - name: HUGGING_FACE_HUB_TOKEN
              valueFrom:
                secretKeyRef:
                  name: hf-token
                  key: token
          resources:
            limits:
              nvidia.com/gpu: 1
          volumeMounts:
            - name: cache
              mountPath: /root/.cache/huggingface
          readinessProbe:
            httpGet:
              path: /health
              port: 8000
            initialDelaySeconds: 60      # first start downloads weights
            periodSeconds: 15
            failureThreshold: 40
      volumes:
        - name: cache
          persistentVolumeClaim:
            claimName: model-cache
---
apiVersion: v1
kind: Service
metadata:
  name: vllm-mistral
  namespace: llm
spec:
  selector:
    app: vllm-mistral
  ports:
    - port: 80
      targetPort: 8000

ਕਿਉਂਕਿ vLLM OpenAI-ਅਨੁਕੂਲ ਹੈ, ਐਪਲੀਕੇਸ਼ਨ ਕੋਡ ਨੂੰ ਸਿਰਫ਼ ਇਨ-ਕਲੱਸਟਰ URL ਦੀ ਲੋੜ ਹੈ — ਕੋਈ SDK ਬਦਲਾਅ ਨਹੀਂ:

curl http://vllm-mistral.llm.svc.cluster.local/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [{"role": "user", "content": "Summarise our refund policy."}],
    "temperature": 0.2
  }'

7.4 ਇੱਕ ਪ੍ਰਵੇਸ਼ ਨਾਲ ਇਸਦਾ ਪਰਦਾਫਾਸ਼ ਕਰਨਾ

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: llm-api
  namespace: llm
  annotations:
    nginx.ingress.kubernetes.io/proxy-read-timeout: "300"   # long generations
spec:
  ingressClassName: nginx
  rules:
    - host: llm.internal.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: vllm-mistral
                port:
                  number: 80

7.5 ਸਕੇਲਿੰਗ — ਅਤੇ ਇਹ GPUs ਨਾਲ ਵੱਖਰਾ ਕਿਉਂ ਹੈ

ਤੁਸੀਂ ਆਟੋਸਕੇਲ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਯਾਦ ਰੱਖੋ ਹਰੇਕ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਨੂੰ ਇਸਦੇ ਆਪਣੇ ਪੂਰੇ GPU ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ - ਤੁਸੀਂ ਸਧਾਰਨ ਕੇਸ ਵਿੱਚ ਇੱਕ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਸਾਂਝਾ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਤੁਹਾਡੇ ਕੋਲ ਸਰੀਰਕ ਤੌਰ 'ਤੇ ਮੌਜੂਦ GPUs ਤੋਂ ਇਲਾਵਾ ਕੋਈ ਬਿੰਦੂ ਸਕੇਲਿੰਗ ਨਹੀਂ ਹੈ। CPU ਦੀ ਬਜਾਏ ਕਤਾਰ ਜਾਂ ਬੇਨਤੀ-ਦਰ ਸਿਗਨਲ (ਕੇਡਾ ਇੱਥੇ ਸ਼ਾਨਦਾਰ ਹੈ) 'ਤੇ ਸਕੇਲ ਕਰੋ।

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: vllm-mistral
  namespace: llm
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: vllm-mistral
  minReplicas: 1
  maxReplicas: 4          # never exceed the number of GPUs in the cluster
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
  # For real LLM scaling, prefer KEDA on a queue depth or
  # requests-per-second metric exported by vLLM, not CPU.

8. ਇੱਕ ਵਿਹਾਰਕ ਰੋਲਆਊਟ ਚੈਕਲਿਸਟ

1. ਇੱਕ ਹੋਸਟ ਕੀਤੇ API 'ਤੇ ਪ੍ਰੋਟੋਟਾਈਪ GPU ਖਰੀਦਣ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤੋਂ ਦੇ ਕੇਸ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ।
2. ਇੱਕ ਓਪਨ-ਵੇਟ ਮਾਡਲ ਚੁਣੋ ਜੋ ਕਿ ਤੁਹਾਡੇ ਹਾਰਡਵੇਅਰ ਨੂੰ ਫਿੱਟ ਕਰਦਾ ਹੈ (ਇੱਕ 7–8B ਮਾਡਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਕੁਆਂਟਾਈਜ਼ਡ)।
3. ਓਲਾਮਾ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ ਅੰਦਰੂਨੀ ਪਾਇਲਟ ਲਈ; ਕਰਨ ਲਈ ਗ੍ਰੈਜੂਏਟ vLLM ਜਦੋਂ ਤੁਹਾਨੂੰ ਥ੍ਰੋਪੁੱਟ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
4. RAG ਸ਼ਾਮਲ ਕਰੋ ਭਰਮਾਂ ਨੂੰ ਕੱਟਣ ਅਤੇ ਜਵਾਬਾਂ ਨੂੰ ਮੌਜੂਦਾ ਰੱਖਣ ਲਈ ਆਪਣੇ ਖੁਦ ਦੇ ਦਸਤਾਵੇਜ਼ਾਂ ਉੱਤੇ।
5. ਇੱਕ ਮਨੁੱਖ ਨੂੰ ਲੂਪ ਵਿੱਚ ਰੱਖੋ ਜਿੱਥੇ ਕਿਤੇ ਵੀ ਗਲਤ ਜਵਾਬ ਦੀ ਅਸਲ ਕੀਮਤ ਹੁੰਦੀ ਹੈ।
6. ਅਨੁਮਾਨ ਦੀ ਲਾਗਤ ਅਤੇ ਲੇਟੈਂਸੀ ਨੂੰ ਮਾਪੋ ਪ੍ਰਤੀ ਬੇਨਤੀ - ਇਹ ਤੁਹਾਡੀ ਅਸਲ ਇਕਾਈ ਅਰਥ ਸ਼ਾਸਤਰ ਹੈ।