GPT-4 ਅਤੇ Claude ਵਰਗੇ Autoregressive ਦਿੱਗਜ ਟੋਕਨ-ਦਰ-ਟੋਕਨ ਕੋਡ ਜਾਰੀ ਕਰਦੇ ਹਨ, ਜੋ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਖੱਬੇ ਤੋਂ ਸੱਜੇ ਵਧਦੇ ਹਨ। ਉਹ ਛੋਟੇ ਕੋਡ ਸਨਿਪੇਟਸ (snippets) ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲ ਲੈਂਦੇ ਹਨ, ਪਰ ਜਦੋਂ ਕੋਈ ਡਿਵੈਲਪਰ ਇੱਕ ਵੱਡੇ ਕੋਡਬੇਸ (codebase) ਵਿੱਚ ਡੂੰਘੀ ਦੱਬੀ ਹੋਈ ਲਾਈਨ ਨੂੰ ਐਡਿਟ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਹ ਅੜਖੇ ਆ ਜਾਂਦੇ ਹਨ। ਮਾਡਲ ਨੂੰ ਹਰ ਅਗਲੇ ਟੋਕਨ (downstream token) ਦਾ ਮੁੜ ਮੁਲਾਂਕਣ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਅਤੇ ਪੂਰੀ ਫਾਈਲ ਨੂੰ ਇਕਸਾਰ ਰੱਖਣਾ ਇੱਕ ਭਿਆਨਕ ਕੰਮ ਬਣ ਜਾਂਦਾ ਹੈ।
Diffusion ਮਾਡਲ ਰੈਂਡਮ ਟੋਕਨਾਂ ਦੇ ਇੱਕ ਬੱਦਲ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ ਅਤੇ ਉਦੋਂ ਤੱਕ ਵਾਰ-ਵਾਰ ਡੀਨੋਇਜ਼ (denoise) ਕਰਦੇ ਹਨ ਜਦੋਂ ਤੱਕ ਇੱਕ ਸੁਮੇਲਿਤ ਪ੍ਰੋਗਰਾਮ ਪ੍ਰਗਟ ਨਹੀਂ ਹੋ ਜਾਂਦਾ। ਕਿਉਂਕਿ ਸੁਧਾਰ (refinement) ਇੱਕੋ ਸਮੇਂ ਪੂਰੀ ਲੜੀ ਨੂੰ ਛੂਹਦਾ ਹੈ, ਮਾਡਲ ਪੂਰੇ ਕੋਡ ਦੇ ਅੰਤਲੇ ਹਿੱਸੇ ਦੀ ਮੁੜ-ਗਣਨਾ ਕੀਤੇ ਬਿਨਾਂ ਕੋਡ ਦੇ ਕਿਸੇ ਵੀ ਹਿੱਸੇ ਨੂੰ ਇਨਸਰਟ, ਡਿਲੀਟ ਜਾਂ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦਾ ਹੈ।
ਕਿਉਂ ਮੌਜੂਦਾ ਪੈਰਾਡਾਈਮ (paradigm) ਸੌਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰਿੰਗ ਵਿੱਚ ਸੰਘਰਸ਼ ਕਰਦਾ ਹੈ
Autoregression ਮਾਡਲ ਨੂੰ ਕੋਡ ਨੂੰ ਇੱਕ ਰੇਖਿਕ ਸਟ੍ਰੀਮ (linear stream) ਵਜੋਂ ਮੰਨਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇਹ:
- ਸਿਰਫ਼ ਪਿੱਛੇ ਵੱਲ ਦੇਖਦਾ ਹੈ। ਇਹ ਕਦੇ ਵੀ ਭਵਿੱਖ ਦੇ ਟੋਕਨ ਨਹੀਂ ਦੇਖਦਾ, ਇਸ ਲਈ ਇਹ ਅੰਦਾਜ਼ਾ ਨਹੀਂ ਲਗਾ ਸਕਦਾ ਕਿ ਇੱਕ ਤਬਦੀਲੀ ਬਾਅਦ ਦੀਆਂ ਲਾਈਨਾਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਭਾਵਿਤ ਕਰੇਗੀ।
- ਅਗਲੇ ਟੈਕਸਟ ਦੀ ਮੁੜ-ਗਣਨਾ ਕਰਦਾ ਹੈ। ਇੱਕ ਐਡਿਟ ਨਵੇਂ ਅਨੁਮਾਨਾਂ ਦੀ ਇੱਕ ਲੜੀ ਸ਼ੁਰੂ ਕਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਰੈਫੈਕਟਰੀਂਗ (refactoring) ਜਾਂ ਬੱਗ ਫਿਕਸਿੰਗ (bug fixing) ਲਈ ਲੇਟੈਂਸੀ (latency) ਵਧ ਜਾਂਦੀ ਹੈ।
- ਲੰਬੇ ਰੇਂਜ ਦੀਆਂ ਗਲਤੀਆਂ ਇਕੱਠੀਆਂ ਕਰਦਾ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਗਲਤੀਆਂ ਵਧਦੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਜਿਸ ਨਾਲ ਅੰਤਮ ਫਾਈਲ ਸਿੰਟੈਕਟਿਕਲੀ (syntactically) ਖਰਾਬ ਜਾਂ ਤਰਕਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਅਸੰਗਤ ਰਹਿ ਜਾਂਦੀ ਹੈ।
ਜਦੋਂ ਤੁਹਾਨੂੰ ਇਨਫਿਲ (infill) ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ—ਜਿਵੇਂ ਕਿ ਫਾਈਲ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਫੰਕਸ਼ਨ ਬਾਡੀ ਇਨਸਰਟ ਕਰਨਾ ਜਾਂ API ਸਿਗਨੇਚਰ ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ—ਤਾਂ autoregressive ਮਾਡਲਾਂ ਦੀ ਕ੍ਰਮਵਾਰ ਪ੍ਰਕਿਰਤੀ ਅਜੀਬ ਅਤੇ ਗਲਤੀ-ਪੂਰਨ ਮਹਿਸੂਸ ਹੁੰਦੀ ਹੈ।
ਡਿਫਿਊਜ਼ਨ ਵਿਕਲਪ: ਵਾਰ-ਵਾਰ ਸੁਧਾਰ, ਨਾ ਕਿ ਕਦਮ-ਦਰ-ਕਦਮ ਅਨੁਮਾਨ
ਅਸੀਂ ਕੋਡ ਫਾਈਲ ਨੂੰ ਇੱਕ ਨੋਇਜ਼ੀ ਸਿਗਨਲ (noisy signal) ਵਜੋਂ ਮੰਨਦੇ ਹਾਂ। ਜਨਰੇਸ਼ਨ ਕਈ ਦੌਰ ਵਿੱਚ ਅੱਗੇ ਵਧਦੀ ਹੈ:
- ਸ਼ੁੱਧ ਨੋਇਜ਼ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨਾ। ਅਸੀਂ ਮਾਡਲ ਨੂੰ ਰੈਂਡਮ ਟੋਕਨਾਂ ਦੀ ਇੱਕ ਲੜੀ ਦਿੰਦੇ ਹਾਂ, ਜਿਸ ਨੂੰ ਅਕਸਰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਪਲੇਸਹੋਲਡਰ (placeholder) ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ।
- ਹੌਲੀ-ਹੌਲੀ ਡੀਨੋਇਜ਼ਿੰਗ। ਹਰ ਕਦਮ 'ਤੇ ਮਾਡਲ ਇੱਕ ਥੋੜ੍ਹੀ ਸਾਫ਼ ਵਰਜ਼ਨ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ, ਟੋਕਨਾਂ ਨੂੰ ਸੰਭਾਵੀ ਕੋਡ ਵੱਲ ਵਧਾਉਂਦਾ ਹੈ।
- ਇੱਕ ਮੁਕੰਮਲ ਪ੍ਰੋਗਰਾਮ ਵੱਲ ਵਧਣਾ। ਨਿਸ਼ਚਿਤ ਕਦਮਾਂ ਤੋਂ ਬਾਅਦ ਨੋਇਜ਼ ਖਤਮ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਣਿਆ ਹੋਇਆ ਸਨਿਪੇਟ ਬਚ ਜਾਂਦਾ ਹੈ।
ਕਿਉਂਕਿ ਹਰ ਕਦਮ ਪੂਰੀ ਲੜੀ ਨੂੰ ਦੁਬਾਰਾ ਦੇਖਦਾ ਹੈ, ਮਾਡਲ ਕਿਸੇ ਵੀ ਪੜਾਅ 'ਤੇ ਕਿਸੇ ਵੀ ਟੋਕਨ ਵਿੱਚ ਬਦਲਾਅ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਵਿਸ਼ਾਲ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਇਸਨੂੰ ਅਗਲੇ ਸਾਰੇ ਹਿੱਸੇ ਨੂੰ ਦੁਬਾਰਾ ਬਣਾਏ ਬਿਨਾਂ ਇੱਕ ਗੁੰਮ ਹੋਇਆ ਇੰਪੋਰਟ (import) ਜੋੜਨ, ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਬਦਲਣ, ਜਾਂ ਕਿਸੇ ਬਲਾਕ ਨੂੰ ਦੁਬਾਰਾ ਇੰਡੈਂਟ (re-indent) ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
ਕੋਡ-ਕੇਂਦਰਿਤ ਡਿਫਿਊਜ਼ਨ ਮਾਡਲ ਦੀ ਇੰਜੀਨੀਅਰਿੰਗ
ਡਿਫਿਊਜ਼ਨ ਨੂੰ ਚਿੱਤਰਾਂ (images) ਤੋਂ ਟੈਕਸਟ ਵਿੱਚ ਬਦਲਣਾ ਕੋਈ ਸੌਖਾ ਕੰਮ ਨਹੀਂ ਹੈ। ਤਿੰਨ ਤਕਨੀਕੀ ਤਬਦੀਲੀਆਂ ਮਹੱਤਵਪੂਰਨ ਹਨ।
1. ਡਿਸਕ੍ਰੀਟ ਡਿਫਿਊਜ਼ਨ (Discrete diffusion)
ਚਿੱਤਰ ਪਿਕਸਲ ਫਰੈਕਸ਼ਨਲ ਨੋਇਜ਼ (fractional noise) ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੇ ਹਨ, ਪਰ ਕੋਡ ਟੋਕਨ ਕੈਟੇਗੋਰਿਕਲ ਹੁੰਦਾ ਹੈ—ਇਹ ਜਾਂ ਤਾਂ ਇੱਕ ਖਾਸ ਕੀਵਰਡ, ਆਈਡੈਂਟੀਫਾਇਰ, ਜਾਂ ਪ੍ਰਤੀਕ ਹੁੰਦਾ ਹੈ। ਇਸ ਲਈ ਅਸੀਂ ਇੱਕ ਮਾਰਕੋਵ ਚੇਨ (Markov chain) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ਜੋ ਟੋਕਨਾਂ ਨੂੰ ਵਾਰ-ਵਾਰ ਇੱਕ ਨਿਰਪੱਖ ਪਲੇਸਹੋਲਡਰ (ਅਕਸਰ [MASK]) ਨਾਲ ਬਦਲਦੀ
- ਹਾਈਬ੍ਰਿਡ ਪਾਈਪਲਾਈਨਾਂ (Hybrid pipelines). ਭਵਿੱਖ ਦੇ ਸਿਸਟਮ ਇੱਕ autoregressive ਮਾਡਲ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਪਹਿਲਾ ਡਰਾਫਟ ਤਿਆਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇ ਸਕਦੇ ਹਨ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਪਾਲਿਸ਼ ਕਰਨ ਲਈ ਇੱਕ diffusion ਮਾਡਲ ਨੂੰ ਸੌਂਪ ਸਕਦੇ ਹਨ।
- ਸਟ੍ਰਕਚਰਲ ਮਾਸਕਾਂ (structural masks) ਲਈ ਟੂਲਿੰਗ। ਖੋਜਕਰਤਾ diffusion ਮਾਡਲਾਂ ਨੂੰ ਭਾਸ਼ਾ-ਵਿਸ਼ੇਸ਼ ਪਾਬੰਦੀਆਂ ਦੀ ਪਾਲਣਾ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਨ ਲਈ syntax-aware attention masks ਨੂੰ ਲਗਾਤਾਰ ਸੁਧਾਰ ਰਹੇ ਹਨ।
ਮੁੱਖ ਨੁਕਤੇ
Diffusion ਮਾਡਲ ਕੋਡ ਜਨਰੇਸ਼ਨ ਦੇ ਤਰੀਕੇ ਨੂੰ ਬਦਲ ਦਿੰਦੇ ਹਨ: ਟੋਕਨ-ਦਰ-ਟੋਕਨ ਚੱਲਣ ਦੀ ਬਜਾਏ, ਉਹ iterative denoising ਰਾਹੀਂ ਪੂਰੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਘੜਦੇ ਹਨ। ਇਹ ਪਹੁੰਚ autoregressive ਸਿਸਟਮਾਂ ਦੀ ਮੁੱਖ ਕਮਜ਼ੋਰੀ—ਵੱਡੇ, ਬਦਲਣਯੋਗ codebase ਵਿੱਚ ਵਿਸ਼ਵਵਿਆਪੀ ਇਕਸਾਰਤਾ ਬਣਾਈ ਰੱਖਣ—ਤੇ ਹਮਲਾ ਕਰਦੀ ਹੈ। ਹਾਲਾਂਕਿ ਇਹ ਹੌਲੀ ਅਤੇ ਵਧੇਰੇ ਕੰਪਿਊਟ-ਭਾਰੀ ਹੈ, ਫਿਰ ਵੀ diffusion refactoring, bug fixing, ਅਤੇ ਕਿਸੇ ਵੀ ਅਜਿਹੇ ਸਥਿਤੀ ਲਈ ਇੱਕ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਇੱਕ ਸਾਫ਼, syntax-ਵਿਸ਼ੇਸ਼ ਰੂਪ ਵਿੱਚ ਸਹੀ ਆਉਟਪੁੱਟ, ਸਿਰਫ਼ ਰਫ਼ਟਾਰ ਨਾਲੋਂ ਵਧੇਰੇ ਮਹੱਤਵ ਰੱਖਦੀ ਹੈ। ਅੱਗੇ ਵਧਣ ਲਈ ਸਭ ਤੋਂ ਉਮੀਦ ਭਰਿਆ ਰਸਤਾ ਇੱਕ ਹਾਈਬ੍ਰਿਡ ਵਰਕਫਲੋ ਜਾਪਦਾ ਹੈ ਜੋ autoregression ਦੀ ਤੇਜ਼ ਡਰਾਫਟਿੰਗ ਸ਼ਕਤੀ ਨੂੰ diffusion ਦੀ ਸੰਪੂਰਨ ਪਾਲਿਸ਼ਿੰਗ ਸਮਰੱਥਾ ਨਾਲ ਜੋੜਦਾ ਹੈ।