ਮੁਫ਼ਤ ਤਸਵੀਰ ਅੱਪਸਕੇਲਰ

ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

upscaler Real-ESRGAN general-x4v3 — ਇੱਕ 4.6 MB convolutional super-resolution network — ਨੂੰ ਤੁਹਾਡੀ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ Web Worker ਅੰਦਰ onnxruntime-web ਰਾਹੀਂ ਚਲਾਉਂਦਾ ਹੈ। ਮਾਡਲ ਸਾਡੇ ਆਪਣੇ ਸਰਵਰ ਤੋਂ ਇੱਕ ਵਾਰ ਲਿਆਂਦਾ ਜਾਂਦਾ ਹੈ, cache ਹੁੰਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਔਫ਼ਲਾਈਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ; ਤੁਹਾਡੀ ਫ਼ੋਟੋ ਲੋਕਲ ਤੌਰ 'ਤੇ canvas ਵਿੱਚ ਡੀਕੋਡ ਹੁੰਦੀ ਹੈ ਅਤੇ ਕਦੇ ਅੱਪਲੋਡ ਨਹੀਂ ਹੁੰਦੀ। ਪੈਮਾਨਾ ਗੁਣਕ 4× 'ਤੇ ਪੱਕਾ ਹੈ, ਕਿਉਂਕਿ ਇਹ graph ਵਿੱਚ ਦੋ ਥਾਂਵਾਂ 'ਤੇ ਪੱਕਾ ਬਣਿਆ ਹੈ।

1. 1
   ਚਿੱਤਰ ਆਪਸ ਵਿੱਚ ਮਿਲਦੀਆਂ tiles ਵਿੱਚ ਕੱਟਿਆ ਜਾਂਦਾ ਹੈ

   4× ਨਤੀਜਾ ਸੋਲ੍ਹਾਂ ਗੁਣਾ pixels ਹੈ, ਇਸ ਲਈ 4000×3000 ਫ਼ੋਟੋ 192 megapixels ਹੋਵੇਗੀ — ਬ੍ਰਾਊਜ਼ਰ ਟੈਬ ਨੂੰ ਹੌਲੀ ਕਰਨ ਦੀ ਥਾਂ ਸਿੱਧਾ ਬੰਦ ਕਰਨ ਲਈ ਕਾਫ਼ੀ। ਇਸਦੀ ਥਾਂ ਤਸਵੀਰ ਨੂੰ ਅਜਿਹੇ cores ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਜੋ ਇਸਨੂੰ ਬਿਲਕੁਲ ਢੱਕਦੇ ਹਨ, ਅਤੇ ਹਰ core ਹਰ ਪਾਸੇ ਸੰਦਰਭ ਦੇ ਵਾਧੂ ਹਾਸ਼ੀਏ ਨਾਲ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਜੋ convolution stack (ਜਿਸਦਾ receptive field 34 pixels ਹੈ) ਕੋਲ ਕੰਮ ਕਰਨ ਲਈ ਅਸਲ ਗੁਆਂਢੀ pixels ਹੋਣ। ਕਿਨਾਰੇ edge-replicate ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਕਦੇ zero-pad ਨਹੀਂ, ਜੋ ਨਹੀਂ ਤਾਂ ਮਾਡਲ ਨੂੰ ਫ੍ਰੇਮ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਕਾਲਾ ਕਿਨਾਰਾ ਤਿੱਖਾ ਕਰਨ 'ਤੇ ਲਾ ਦੇਵੇਗਾ।
2. 2
   ਹਰ tile planar RGB tensor ਵਜੋਂ ਪੈਕ ਕੀਤੀ ਜਾਂਦੀ ਹੈ

   ਇੱਕ tile [1, 3, H, W] ਆਕਾਰ ਦਾ float32 tensor ਬਣਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਲਾਲ, ਹਰੇ ਅਤੇ ਨੀਲੇ ਚੈਨਲ ਵੱਖਰੀਆਂ planes ਵਜੋਂ ਰੱਖੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਮੁੱਲਾਂ ਨੂੰ ਸਿਰਫ਼ 255 ਨਾਲ ਭਾਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ — ਕਿਸੇ ਵੀ ਕਿਸਮ ਦਾ mean/standard-deviation normalisation ਨਹੀਂ। ਹਰ tile ਬਿਲਕੁਲ ਇੱਕੋ ਵਰਗ ਆਕਾਰ ਤੱਕ pad ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਕਿਉਂਕਿ WebGPU backend ਹਰ ਨਵੇਂ ਇਨਪੁੱਟ ਆਕਾਰ ਲਈ ਆਪਣੇ shaders ਮੁੜ compile ਕਰਦਾ ਹੈ ਅਤੇ ਤਿੰਨ ਵੱਖਰੇ tile ਆਕਾਰਾਂ ਵਾਲੀ ਯੋਜਨਾ ਇਹ ਲਾਗਤ ਤਿੰਨ ਵਾਰ ਭਰੇਗੀ।
3. 3
   Inference ਜਿੱਥੇ ਹੋਵੇ ਉੱਥੇ WebGPU 'ਤੇ, ਨਹੀਂ ਤਾਂ CPU 'ਤੇ ਚੱਲਦਾ ਹੈ

   Session ਪਹਿਲਾਂ WebGPU ਨਾਲ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਵੀ ਅਸਫਲਤਾ 'ਤੇ single-threaded WebAssembly 'ਤੇ ਜਾਂਦਾ ਹੈ — graphics drivers ਅਕਸਰ ਸਪੋਰਟ ਦਾ ਦਾਅਵਾ ਕਰਦੇ ਹਨ ਅਤੇ ਫਿਰ graph ਬਣਾਉਣ ਦੇ ਅੱਧ ਵਿੱਚ ਫੇਲ੍ਹ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹੌਲੀ ਟੁੱਟੇ ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ। ਕਿਉਂਕਿ ਬਦਲ ਯਥਾਰਥਵਾਦੀ ਆਕਾਰ ਹੱਦ ਅਤੇ ਚੱਲਣ ਦਾ ਸਮਾਂ ਵੱਡੇ ਗੁਣਕ ਨਾਲ ਬਦਲਦਾ ਹੈ, ਟੂਲ ਪਹਿਲੀ tile ਚੱਲਣ ਤੋਂ ਪਹਿਲਾਂ ਅਸਲ ਵਿੱਚ ਮਿਲੇ provider ਦੇ ਮੁਕਾਬਲੇ ਕੰਮ ਨੂੰ ਮੁੜ ਜਾਂਚਦਾ ਹੈ, ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਵਰਤਿਆ।
4. 4
   Tiles cross-fade ਹੋ ਕੇ ਮੁੜ ਜੁੜਦੀਆਂ ਅਤੇ clamp ਹੁੰਦੀਆਂ ਹਨ

   tiles ਨੂੰ ਸਿੱਧਾ ਜੋੜਨ ਨਾਲ ਦਿਸਦਾ ਗਰਿੱਡ ਰਹਿ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ ਹਰ tile ਦਾ ਯੋਗਦਾਨ ਸਾਂਝੀ ਪੱਟੀ 'ਤੇ ਲੀਨੀਅਰ ਢਲਾਨ ਨਾਲ ਭਾਰਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਦੋਵੇਂ ਢਲਾਨਾਂ ਬਿਲਕੁਲ ਪੂਰਕ ਹਨ, ਇਸ ਲਈ ਹਰ ਆਉਟਪੁੱਟ pixel 'ਤੇ ਭਾਰਾਂ ਦਾ ਜੋੜ ਬਿਲਕੁਲ 1 ਹੁੰਦਾ ਹੈ ਅਤੇ ਜੋੜ ਦੇ ਨਾਲ ਕੋਈ ਚਮਕੀਲੀ ਜਾਂ ਗੂੜ੍ਹੀ ਲਕੀਰ ਨਹੀਂ ਦਿਸਦੀ। ਮਾਡਲ ਦਾ ਕੱਚਾ ਆਉਟਪੁੱਟ graph ਅੰਦਰ clip ਨਹੀਂ ਹੁੰਦਾ — ਮਾਪੇ ਮੁੱਲ ਲਗਭਗ −0.18 ਤੋਂ +1.19 ਤੱਕ ਹੁੰਦੇ ਹਨ — ਇਸ ਲਈ 8-bit cast ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਨਮੂਨਾ 0–255 ਸੀਮਾ ਵਿੱਚ clamp ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜੋ ਉੱਚ-ਕੰਟ੍ਰਾਸਟ ਕਿਨਾਰਿਆਂ 'ਤੇ ਧੱਬੇ ਰੋਕਦਾ ਹੈ। Alpha ਵੱਖਰਾ ਅਤੇ bilinearly resample ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ network ਵਿੱਚ ਖੁਦ ਕੋਈ alpha ਰਸਤਾ ਨਹੀਂ।
5. 5
   ਨਤੀਜਾ worker ਵਿੱਚ ਐਨਕੋਡ ਹੁੰਦਾ ਹੈ

   ਜੋੜੇ pixels ਇੱਕ OffscreenCanvas 'ਤੇ ਬਣਾ ਕੇ ਤੁਰੰਤ PNG ਵਿੱਚ ਐਨਕੋਡ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਇਸ ਲਈ ਡਾਊਨਲੋਡ ਦਬਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਕੋਈ asynchronous ਵਿੱਥ ਨਹੀਂ ਹੁੰਦੀ। JPG 'ਤੇ ਜਾਣ ਨਾਲ ਮਾਡਲ ਦੁਬਾਰਾ ਚਲਾਉਣ ਦੀ ਥਾਂ worker ਕੋਲ ਅਜੇ ਰੱਖੇ canvas ਤੋਂ ਮੁੜ-ਐਨਕੋਡ ਹੁੰਦਾ ਹੈ। ਇੱਕ ਛੋਟਾ ਵਿਚਕਾਰਲਾ ਕ੍ਰੌਪ ਵੀ 100% 'ਤੇ ਬ੍ਰਾਊਜ਼ਰ ਦੁਆਰਾ resample ਕੀਤੇ ਉਸੇ ਹਿੱਸੇ ਦੇ ਨਾਲ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਇੱਕੋ-ਇੱਕ ਤੁਲਨਾ ਹੈ ਜਿਸ ਵਿੱਚ 4× ਫ਼ਰਕ ਅਸਲ ਵਿੱਚ ਦਿਸਦਾ ਹੈ।

ਸੰਬੰਧਿਤ ਟੂਲ