ਕਨਵੋਲਿਊਸ਼ਨਲ ਨੈਟਵਰਕਸ ਨੂੰ ਘਟਾਉਣ ਲਈ ਜੇਡੀ ਤਕਨੀਕ - ਛਾਂਟੀ

ਤੁਹਾਡੇ ਅੱਗੇ ਦੁਬਾਰਾ ਵਸਤੂਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦਾ ਕੰਮ ਹੈ. ਤਰਜੀਹ ਸਵੀਕਾਰਯੋਗ ਸ਼ੁੱਧਤਾ ਦੇ ਨਾਲ ਸੰਚਾਲਨ ਦੀ ਗਤੀ ਹੈ. ਤੁਸੀਂ YOLOv3 ਆਰਕੀਟੈਕਚਰ ਲੈਂਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਹੋਰ ਸਿਖਲਾਈ ਦਿੰਦੇ ਹੋ। ਸ਼ੁੱਧਤਾ(mAp75) 0.95 ਤੋਂ ਵੱਧ ਹੈ। ਪਰ ਰਨ ਰੇਟ ਅਜੇ ਵੀ ਘੱਟ ਹੈ। ਬਕਵਾਸ.

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

ਜਾਣ ਪਛਾਣ

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

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

ਜੀਵ ਵਿਗਿਆਨ ਵਿੱਚ ਇੱਕ ਝਲਕ

ਮੈਨੂੰ ਇਹ ਪਸੰਦ ਹੈ ਜਦੋਂ ਡੀਪ ਲਰਨਿੰਗ ਜੀਵ ਵਿਗਿਆਨ ਤੋਂ ਆਏ ਵਿਚਾਰਾਂ ਨੂੰ ਵੇਖਦੀ ਹੈ। ਉਹ, ਵਿਕਾਸਵਾਦ ਦੀ ਤਰ੍ਹਾਂ, ਭਰੋਸਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਕੀ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ ਕਿ ReLU ਬਹੁਤ ਸਮਾਨ ਹੈ ਦਿਮਾਗ ਵਿੱਚ ਨਿਊਰੋਨ ਐਕਟੀਵੇਸ਼ਨ ਦਾ ਕੰਮ?)

ਮਾਡਲ ਪ੍ਰੂਨਿੰਗ ਪ੍ਰਕਿਰਿਆ ਵੀ ਜੀਵ ਵਿਗਿਆਨ ਦੇ ਨੇੜੇ ਹੈ। ਇੱਥੇ ਨੈਟਵਰਕ ਦੇ ਜਵਾਬ ਦੀ ਤੁਲਨਾ ਦਿਮਾਗ ਦੀ ਪਲਾਸਟਿਕਤਾ ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ. ਪੁਸਤਕ ਵਿਚ ਕੁਝ ਦਿਲਚਸਪ ਉਦਾਹਰਣਾਂ ਹਨ। ਨੌਰਮਨ ਡੌਜ:

1. ਇੱਕ ਔਰਤ ਦਾ ਦਿਮਾਗ ਜੋ ਸਿਰਫ ਇੱਕ ਅੱਧੇ ਨਾਲ ਪੈਦਾ ਹੋਇਆ ਸੀ, ਨੇ ਆਪਣੇ ਆਪ ਨੂੰ ਗੁੰਮ ਹੋਏ ਅੱਧ ਦੇ ਕੰਮ ਕਰਨ ਲਈ ਦੁਬਾਰਾ ਪ੍ਰੋਗਰਾਮ ਕੀਤਾ ਹੈ.
2. ਵਿਅਕਤੀ ਨੇ ਨਜ਼ਰ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਆਪਣੇ ਦਿਮਾਗ ਦੇ ਹਿੱਸੇ ਨੂੰ ਗੋਲੀ ਮਾਰ ਦਿੱਤੀ। ਸਮੇਂ ਦੇ ਨਾਲ, ਦਿਮਾਗ ਦੇ ਹੋਰ ਹਿੱਸਿਆਂ ਨੇ ਇਹਨਾਂ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸੰਭਾਲ ਲਿਆ। (ਅਸੀਂ ਦੁਹਰਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰ ਰਹੇ ਹਾਂ)

ਇਸੇ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਆਪਣੇ ਮਾਡਲ ਵਿੱਚੋਂ ਕੁਝ ਕਮਜ਼ੋਰ ਸੰਕਲਪਾਂ ਨੂੰ ਕੱਟ ਸਕਦੇ ਹੋ। ਇੱਕ ਆਖਰੀ ਉਪਾਅ ਵਜੋਂ, ਬਾਕੀ ਬਚੇ ਬੰਡਲ ਕੱਟੇ ਹੋਏ ਲੋਕਾਂ ਨੂੰ ਬਦਲਣ ਵਿੱਚ ਮਦਦ ਕਰਨਗੇ।

ਕੀ ਤੁਹਾਨੂੰ ਟ੍ਰਾਂਸਫਰ ਲਰਨਿੰਗ ਪਸੰਦ ਹੈ ਜਾਂ ਕੀ ਤੁਸੀਂ ਸ਼ੁਰੂ ਤੋਂ ਸਿੱਖ ਰਹੇ ਹੋ?

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

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

ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਨੈਟਵਰਕ ਨੂੰ ਘਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ. ਪ੍ਰੇਰਿਤ ਕੀਤਾ। ਹੁਣ ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਸੁੰਨਤ ਦੀ ਛਾਂਟੀ ਕਿਸ ਕਿਸਮ ਦੀ ਹੈ

ਜਨਰਲ ਐਲਗੋਰਿਦਮ

ਅਸੀਂ ਫੈਸਲਾ ਕੀਤਾ ਕਿ ਅਸੀਂ ਬੰਡਲਾਂ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹਾਂ। ਇਹ ਕਾਫ਼ੀ ਸਧਾਰਨ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

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

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

ਇਸ ਲਈ, ਐਲਗੋਰਿਦਮ ਸਪੱਸ਼ਟ ਹੋ ਜਾਂਦਾ ਹੈ. ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਬਾਕੀ ਹੈ ਕਿ ਮਿਟਾਏ ਗਏ ਸੰਕਲਪਾਂ ਨੂੰ ਕਿਵੇਂ ਨਿਰਧਾਰਤ ਕਰਨਾ ਹੈ.

ਮਿਟਾਏ ਗਏ ਪੈਕੇਜਾਂ ਦੀ ਖੋਜ ਕਰੋ

ਸਾਨੂੰ ਕੁਝ ਉਲਝਣਾਂ ਨੂੰ ਹਟਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਅੱਗੇ ਵਧਣਾ ਅਤੇ ਕਿਸੇ ਨੂੰ ਵੀ "ਸ਼ੂਟਿੰਗ" ਕਰਨਾ ਇੱਕ ਬੁਰਾ ਵਿਚਾਰ ਹੈ, ਹਾਲਾਂਕਿ ਇਹ ਕੰਮ ਕਰੇਗਾ। ਪਰ ਕਿਉਂਕਿ ਤੁਹਾਡਾ ਸਿਰ ਹੈ, ਤੁਸੀਂ ਸੋਚ ਸਕਦੇ ਹੋ ਅਤੇ ਹਟਾਉਣ ਲਈ "ਕਮਜ਼ੋਰ" ਸੰਕਲਪਾਂ ਨੂੰ ਚੁਣਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ। ਕਈ ਵਿਕਲਪ ਹਨ:

1. ਸਭ ਤੋਂ ਛੋਟਾ L1-ਮਾਪ ਜਾਂ ਘੱਟ_ਮੈਗਨਿਟਿਊਡ_ਪ੍ਰੂਨਿੰਗ. ਇਹ ਵਿਚਾਰ ਕਿ ਛੋਟੇ ਵਜ਼ਨ ਦੇ ਨਾਲ ਕਨਵੋਲਿਊਸ਼ਨ ਅੰਤਮ ਫੈਸਲੇ ਵਿੱਚ ਬਹੁਤ ਘੱਟ ਯੋਗਦਾਨ ਪਾਉਂਦੇ ਹਨ
2. ਸਭ ਤੋਂ ਛੋਟਾ L1-ਮਾਪ ਮੱਧਮਾਨ ਅਤੇ ਮਿਆਰੀ ਵਿਵਹਾਰ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ। ਅਸੀਂ ਵੰਡ ਦੀ ਪ੍ਰਕਿਰਤੀ ਦੇ ਮੁਲਾਂਕਣ ਦੇ ਨਾਲ ਪੂਰਕ ਕਰਦੇ ਹਾਂ।
3. ਕਨਵੋਲਿਊਸ਼ਨ ਨੂੰ ਮਾਸਕ ਕਰਨਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਛੱਡਣਾ ਜੋ ਅੰਤਮ ਸ਼ੁੱਧਤਾ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਪ੍ਰਭਾਵਿਤ ਕਰਦੇ ਹਨ. ਮਾਮੂਲੀ ਸੰਕਲਪਾਂ ਦਾ ਵਧੇਰੇ ਸਹੀ ਨਿਰਧਾਰਨ, ਪਰ ਬਹੁਤ ਸਮਾਂ ਲੈਣ ਵਾਲਾ ਅਤੇ ਸਰੋਤ-ਬਰਬਾਦ।
4. ਹੋਰ

ਹਰੇਕ ਵਿਕਲਪ ਨੂੰ ਜੀਵਨ ਦਾ ਅਧਿਕਾਰ ਅਤੇ ਇਸਦੇ ਆਪਣੇ ਲਾਗੂ ਕਰਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ. ਇੱਥੇ ਅਸੀਂ ਸਭ ਤੋਂ ਛੋਟੇ L1-ਮਾਪ ਦੇ ਨਾਲ ਵਿਕਲਪ 'ਤੇ ਵਿਚਾਰ ਕਰਦੇ ਹਾਂ

YOLOv3 ਲਈ ਦਸਤੀ ਪ੍ਰਕਿਰਿਆ

ਮੂਲ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਬਾਕੀ ਬਚੇ ਬਲਾਕ ਸ਼ਾਮਲ ਹਨ। ਪਰ ਚਾਹੇ ਉਹ ਡੂੰਘੇ ਨੈੱਟਵਰਕਾਂ ਲਈ ਕਿੰਨੇ ਵੀ ਠੰਢੇ ਹੋਣ, ਉਹ ਸਾਨੂੰ ਕੁਝ ਹੱਦ ਤੱਕ ਰੁਕਾਵਟ ਦੇਣਗੇ। ਮੁਸ਼ਕਲ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਲੇਅਰਾਂ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਸੂਚਕਾਂਕ ਦੇ ਨਾਲ ਮੇਲ-ਮਿਲਾਪ ਨੂੰ ਨਹੀਂ ਮਿਟਾ ਸਕਦੇ:

ਇਸ ਲਈ, ਆਓ ਪਰਤਾਂ ਦੀ ਚੋਣ ਕਰੀਏ ਜਿਨ੍ਹਾਂ ਤੋਂ ਅਸੀਂ ਸੁਲ੍ਹਾ-ਸਫ਼ਾਈ ਨੂੰ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਮਿਟਾ ਸਕਦੇ ਹਾਂ:

ਆਉ ਹੁਣ ਇੱਕ ਕੰਮ ਦਾ ਚੱਕਰ ਬਣਾਉਂਦੇ ਹਾਂ:

1. ਸਰਗਰਮੀਆਂ ਅੱਪਲੋਡ ਕੀਤੀਆਂ ਜਾ ਰਹੀਆਂ ਹਨ
2. ਇਹ ਪਤਾ ਲਗਾਉਣਾ ਕਿ ਕਿੰਨਾ ਕੱਟਣਾ ਹੈ
3. ਇਸ ਨੂੰ ਕੱਟ ਦਿਓ
4. LR=10e-1 ਨਾਲ 4 ਯੁਗ ਸਿੱਖਣਾ
5. ਟੈਸਟਿੰਗ

ਅਨਲੋਡਿੰਗ ਕਨਵੋਲਿਊਸ਼ਨ ਇਹ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣ ਲਈ ਲਾਭਦਾਇਕ ਹੈ ਕਿ ਅਸੀਂ ਕਿਸੇ ਖਾਸ ਪੜਾਅ 'ਤੇ ਕਿਹੜੇ ਹਿੱਸੇ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹਾਂ। ਅਨਲੋਡਿੰਗ ਉਦਾਹਰਨਾਂ:

ਅਸੀਂ ਦੇਖਦੇ ਹਾਂ ਕਿ ਲਗਭਗ ਹਰ ਥਾਂ 5% ਕਨਵੋਲਿਊਸ਼ਨ ਦਾ ਇੱਕ ਬਹੁਤ ਘੱਟ L1-ਨਰਮ ਹੈ ਅਤੇ ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹਾਂ। ਹਰ ਪੜਾਅ 'ਤੇ, ਇਸ ਅਨਲੋਡਿੰਗ ਨੂੰ ਦੁਹਰਾਇਆ ਗਿਆ ਸੀ ਅਤੇ ਇੱਕ ਮੁਲਾਂਕਣ ਕੀਤਾ ਗਿਆ ਸੀ ਕਿ ਕਿਹੜੀਆਂ ਪਰਤਾਂ ਅਤੇ ਕਿੰਨੀਆਂ ਨੂੰ ਕੱਟਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਸਾਰੀ ਪ੍ਰਕਿਰਿਆ 4 ਪੜਾਵਾਂ ਵਿੱਚ ਪੂਰੀ ਕੀਤੀ ਗਈ ਸੀ (RTX 2060 Super ਲਈ ਇੱਥੇ ਅਤੇ ਹਰ ਥਾਂ ਨੰਬਰ):

ਕਦਮ	mAp75	ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਸੰਖਿਆ, ਮਿਲੀਅਨ	ਨੈੱਟਵਰਕ ਦਾ ਆਕਾਰ, mb	ਸ਼ੁਰੂਆਤੀ ਤੋਂ, %	ਰਨ ਟਾਈਮ, ਐਮ.ਐਸ	ਸੁੰਨਤ ਦੀ ਹਾਲਤ
0	0.9656	60	241	100	180	-
1	0.9622	55	218	91	175	ਸਭ ਦਾ 5%
2	0.9625	50	197	83	168	ਸਭ ਦਾ 5%
3	0.9633	39	155	64	155	15+ ਕਨਵੋਲਿਊਸ਼ਨ ਵਾਲੀਆਂ ਲੇਅਰਾਂ ਲਈ 400%
4	0.9555	31	124	51	146	10+ ਕਨਵੋਲਿਊਸ਼ਨ ਵਾਲੀਆਂ ਲੇਅਰਾਂ ਲਈ 100%

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

ਸਰਲ ਆਰਕੀਟੈਕਚਰ ਲਈ ਆਟੋਮੇਸ਼ਨ

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

ਮੈਂ ਇਸ ਵਿਕਲਪ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਇੱਥੇ.
ਇਹ ਸਧਾਰਨ ਹੈ: ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ, ਇੱਕ ਆਪਟੀਮਾਈਜ਼ਰ ਅਤੇ ਬੈਚ ਜਨਰੇਟਰਾਂ ਦੀ ਲੋੜ ਹੈ:

import pruning
from keras.optimizers import Adam
from keras.utils import Sequence

train_batch_generator = BatchGenerator...
score_batch_generator = BatchGenerator...

opt = Adam(lr=1e-4)
pruner = pruning.Pruner("config.json", "categorical_crossentropy", opt)

pruner.prune(train_batch, valid_batch)

ਜੇ ਜਰੂਰੀ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਸੰਰਚਨਾ ਪੈਰਾਮੀਟਰ ਬਦਲ ਸਕਦੇ ਹੋ:

{
    "input_model_path": "model.h5",
    "output_model_path": "model_pruned.h5",
    "finetuning_epochs": 10, # the number of epochs for train between pruning steps
    "stop_loss": 0.1, # loss for stopping process
    "pruning_percent_step": 0.05, # part of convs for delete on every pruning step
    "pruning_standart_deviation_part": 0.2 # shift for limit pruning part
}

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮਿਆਰੀ ਵਿਵਹਾਰ 'ਤੇ ਆਧਾਰਿਤ ਸੀਮਾ ਲਾਗੂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਟੀਚਾ ਪਹਿਲਾਂ ਹੀ "ਕਾਫ਼ੀ" L1 ਉਪਾਵਾਂ ਦੇ ਨਾਲ ਕਨਵੋਲਿਊਸ਼ਨ ਨੂੰ ਛੱਡ ਕੇ, ਹਟਾਏ ਗਏ ਹਿੱਸੇ ਨੂੰ ਸੀਮਤ ਕਰਨਾ ਹੈ:

ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਤੁਹਾਨੂੰ ਸੱਜੇ ਵਰਗੀ ਵੰਡਾਂ ਤੋਂ ਸਿਰਫ ਕਮਜ਼ੋਰ ਕਨਵੋਲਿਊਸ਼ਨਾਂ ਨੂੰ ਹਟਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੇ ਹਾਂ ਅਤੇ ਖੱਬੇ ਵਰਗ ਦੇ ਸਮਾਨ ਵੰਡਾਂ ਤੋਂ ਹਟਾਉਣ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦੇ:

ਜਦੋਂ ਡਿਸਟ੍ਰੀਬਿਊਸ਼ਨ ਸਾਧਾਰਨ ਤੱਕ ਪਹੁੰਚ ਜਾਂਦੀ ਹੈ, ਤਾਂ pruning_standart_deviation_part coefficient ਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਚੁਣਿਆ ਜਾ ਸਕਦਾ ਹੈ:

ਮੈਂ 2 ਸਿਗਮਾ ਦੀ ਧਾਰਨਾ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ. ਜਾਂ ਤੁਸੀਂ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਅਣਡਿੱਠ ਕਰ ਸਕਦੇ ਹੋ, ਮੁੱਲ < 1.0 ਨੂੰ ਛੱਡ ਕੇ।

ਆਉਟਪੁੱਟ ਪੂਰੇ ਟੈਸਟ ਲਈ ਨੈੱਟਵਰਕ ਆਕਾਰ, ਨੁਕਸਾਨ, ਅਤੇ ਨੈੱਟਵਰਕ ਰਨਟਾਈਮ ਦਾ ਇੱਕ ਗ੍ਰਾਫ ਹੈ, 1.0 ਤੱਕ ਸਧਾਰਣ ਕੀਤਾ ਗਿਆ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਥੇ ਕੁਆਲਿਟੀ ਦੇ ਨੁਕਸਾਨ ਤੋਂ ਬਿਨਾਂ ਨੈੱਟਵਰਕ ਦਾ ਆਕਾਰ ਲਗਭਗ 2 ਗੁਣਾ ਘਟਾ ਦਿੱਤਾ ਗਿਆ ਸੀ (100k ਵਜ਼ਨ ਵਾਲਾ ਛੋਟਾ ਕਨਵੋਲਿਊਸ਼ਨਲ ਨੈੱਟਵਰਕ):

ਚੱਲਣ ਦੀ ਗਤੀ ਸਧਾਰਣ ਉਤਰਾਅ-ਚੜ੍ਹਾਅ ਦੇ ਅਧੀਨ ਹੈ ਅਤੇ ਅਸਲ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਰਹਿੰਦਾ ਹੈ। ਇਸਦੇ ਲਈ ਇੱਕ ਵਿਆਖਿਆ ਹੈ:

1. ਕਨਵੋਲਿਊਸ਼ਨ ਦੀ ਗਿਣਤੀ ਸੁਵਿਧਾਜਨਕ (32, 64, 128) ਤੋਂ ਬਦਲ ਕੇ ਵੀਡੀਓ ਕਾਰਡਾਂ ਲਈ ਸਭ ਤੋਂ ਵੱਧ ਸੁਵਿਧਾਜਨਕ ਨਹੀਂ ਹੈ - 27, 51, ਆਦਿ। ਮੈਂ ਇੱਥੇ ਗਲਤ ਹੋ ਸਕਦਾ ਹਾਂ, ਪਰ ਜ਼ਿਆਦਾਤਰ ਸੰਭਾਵਨਾ ਹੈ ਕਿ ਇਸਦਾ ਪ੍ਰਭਾਵ ਹੈ।
2. ਆਰਕੀਟੈਕਚਰ ਵਿਆਪਕ ਨਹੀਂ ਹੈ, ਪਰ ਇਕਸਾਰ ਹੈ। ਚੌੜਾਈ ਨੂੰ ਘਟਾ ਕੇ, ਅਸੀਂ ਡੂੰਘਾਈ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਦੇ। ਇਸ ਤਰ੍ਹਾਂ, ਅਸੀਂ ਲੋਡ ਨੂੰ ਘਟਾਉਂਦੇ ਹਾਂ, ਪਰ ਗਤੀ ਨੂੰ ਨਹੀਂ ਬਦਲਦੇ.

ਇਸ ਲਈ, ਰਨ ਦੌਰਾਨ CUDA ਲੋਡ ਵਿੱਚ 20-30% ਦੀ ਕਮੀ ਵਿੱਚ ਸੁਧਾਰ ਪ੍ਰਗਟ ਕੀਤਾ ਗਿਆ ਸੀ, ਪਰ ਰਨ ਟਾਈਮ ਵਿੱਚ ਕਮੀ ਵਿੱਚ ਨਹੀਂ।

ਨਤੀਜੇ

ਆਓ ਵਿਚਾਰ ਕਰੀਏ. ਅਸੀਂ ਛਾਂਗਣ ਲਈ 2 ਵਿਕਲਪਾਂ 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ - YOLOv3 ਲਈ (ਜਦੋਂ ਤੁਹਾਨੂੰ ਆਪਣੇ ਹੱਥਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਪੈਂਦਾ ਹੈ) ਅਤੇ ਸਰਲ ਆਰਕੀਟੈਕਚਰ ਵਾਲੇ ਨੈਟਵਰਕ ਲਈ। ਇਹ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿ ਦੋਵਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਸ਼ੁੱਧਤਾ ਦੇ ਨੁਕਸਾਨ ਤੋਂ ਬਿਨਾਂ ਨੈੱਟਵਰਕ ਦੇ ਆਕਾਰ ਨੂੰ ਘਟਾਉਣਾ ਅਤੇ ਗਤੀ ਵਧਾਉਣਾ ਸੰਭਵ ਹੈ. ਨਤੀਜੇ:

• ਆਕਾਰ ਨੂੰ ਘਟਾਉਣਾ
• ਪ੍ਰਵੇਗ ਰਨ
• CUDA ਲੋਡ ਨੂੰ ਘਟਾਉਣਾ
• ਨਤੀਜੇ ਵਜੋਂ, ਵਾਤਾਵਰਣ ਮਿੱਤਰਤਾ (ਅਸੀਂ ਕੰਪਿਊਟਿੰਗ ਸਰੋਤਾਂ ਦੀ ਭਵਿੱਖੀ ਵਰਤੋਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਂਦੇ ਹਾਂ। ਕਿਤੇ ਕੋਈ ਖੁਸ਼ ਹੈ ਗ੍ਰੇਟਾ ਥਨਬਰਗ)

ਅੰਤਿਕਾ

• ਛਾਂਗਣ ਦੇ ਪੜਾਅ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਕੁਆਂਟਾਇਜ਼ੇਸ਼ਨ ਜੋੜ ਸਕਦੇ ਹੋ (ਉਦਾਹਰਣ ਲਈ, TensorRT ਨਾਲ)
• ਟੈਨਸਰਫਲੋ ਲਈ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ low_magnitude_pruning. ਕੰਮ ਕਰਦਾ ਹੈ।
• ਰਿਪੋਜ਼ਟਰੀ ਮੈਂ ਵਿਕਾਸ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਅਤੇ ਮਦਦ ਕਰਕੇ ਖੁਸ਼ ਹੋਵਾਂਗਾ

ਸਰੋਤ: www.habr.com