ਵਿਸ਼ਾ - ਸੂਚੀ[ਛੁਪਾਓ][ਦਿਖਾਓ]
ਦਿਮਾਗ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਦੇ ਮੁਕਾਬਲੇ ਹੈ. ਇਹ ਉਹ ਸਮਾਨਤਾ ਹੈ ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਅਤੇ ਨਕਲੀ ਨਿਊਰਲ ਨੈਟਵਰਕ ਦੇ ਪਿੱਛੇ ਦੇ ਵਿਚਾਰਾਂ ਨੂੰ ਸਮਝਣ ਲਈ ਵਿਸ਼ੇ ਵਿੱਚ ਕਿਸੇ ਨਵੇਂ ਵਿਅਕਤੀ ਦੀ ਮਦਦ ਕਰਨ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।
ਕਿਉਂਕਿ ਪਰਦੇ ਦੇ ਪਿੱਛੇ ਗਣਿਤਿਕ ਅਤੇ ਅੰਕੜਾ ਗਣਨਾ ਦੀਆਂ ਕਈ ਪਰਤਾਂ ਚੱਲ ਰਹੀਆਂ ਹਨ, ਇਹਨਾਂ ਨੈਟਵਰਕਾਂ ਨੂੰ ਇੱਕ ਗਣਿਤਿਕ ਫੰਕਸ਼ਨ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਇੱਕ ਵਧੇਰੇ ਉੱਨਤ ਵਿਧੀ ਹੈ।
ਇਹ ਉਹਨਾਂ ਲੋਕਾਂ ਲਈ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਨ ਅਤੇ ਇਹ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹਨ ਕਿ ਪਾਈਥਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਕੋਡ ਕਿਵੇਂ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ।
ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਦਿਖਾਵਾਂਗੇ ਕਿ ਕਿਵੇਂ ਸ਼ੁਰੂ ਤੋਂ ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜੁੜੇ ਡੂੰਘੇ ਨਿਊਰਲ ਨੈੱਟਵਰਕ (DNN) ਨੂੰ ਬਣਾਇਆ ਜਾਵੇ। ਪਾਈਥਨ 3.
ਸਾਡੇ ਪਾਈਥਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਕੋਡ ਲਈ ਫਾਈਲ ਸਟ੍ਰਕਚਰ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ
ਇੱਥੇ ਤਿੰਨ ਫਾਈਲਾਂ ਬਣਾਈਆਂ ਜਾਣਗੀਆਂ। ਪਹਿਲੀ ਸਧਾਰਨ nn.py ਫਾਈਲ ਹੈ, ਜਿਸਦੀ ਚਰਚਾ "ਸੈਟ ਅਪ ਹੈਲਪਰ ਫੰਕਸ਼ਨ" ਅਤੇ "ਸਕ੍ਰੈਚ ਤੋਂ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ" ਵਿੱਚ ਕੀਤੀ ਜਾਵੇਗੀ।
ਸਾਡੇ ਕੋਲ ਟੈਸਟ ਡੇਟਾ ਲੋਡ ਕਰਨ ਲਈ mnist loader.py ਨਾਮ ਦੀ ਇੱਕ ਫਾਈਲ ਵੀ ਹੋਵੇਗੀ, ਜਿਵੇਂ ਕਿ "MNIST ਡੇਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ" ਵਿੱਚ ਦੱਸਿਆ ਗਿਆ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਸਾਡੇ ਕੋਲ test.py ਨਾਮ ਦੀ ਇੱਕ ਫਾਈਲ ਹੋਵੇਗੀ ਜੋ ਸਾਡੇ ਨਿਊਰਲ ਨੈਟਵਰਕ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਟਰਮੀਨਲ ਵਿੱਚ ਲਾਂਚ ਕੀਤੀ ਜਾਵੇਗੀ।
ਇਸ ਫ਼ਾਈਲ ਦਾ ਵੇਰਵਾ “ਰਨਿੰਗ ਟੈਸਟਾਂ” ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ।
ਇੰਸਟਾਲੇਸ਼ਨ
ਇਸ ਟਿਊਟੋਰਿਅਲ ਦੀ ਪਾਲਣਾ ਕਰਨ ਲਈ NumPy ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਤੁਸੀਂ ਟਰਮੀਨਲ 'ਤੇ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸ ਨੂੰ ਪੂਰਾ ਕਰ ਸਕਦੇ ਹੋ:
ਮੌਡਿਊਲ ਆਯਾਤ ਕਰਨਾ ਅਤੇ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਸਥਾਪਤ ਕਰਨਾ
ਸਾਨੂੰ ਸਿਰਫ਼ ਦੋ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਲੋੜ ਹੈ ਬੇਤਰਤੀਬ ਅਤੇ NumPy, ਜੋ ਅਸੀਂ ਤੁਰੰਤ ਆਯਾਤ ਕਰਾਂਗੇ। ਸਾਡੇ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਦੇ ਸ਼ੁਰੂਆਤੀ ਵਜ਼ਨ ਲਈ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਬੇਤਰਤੀਬ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਦਲਾਂਗੇ।
ਸਾਡੀਆਂ ਗਣਨਾਵਾਂ ਨੂੰ ਤੇਜ਼ ਕਰਨ ਲਈ, ਅਸੀਂ NumPy ਜਾਂ np ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ (ਸੰਮੇਲਨ ਦੁਆਰਾ, ਇਸਨੂੰ ਅਕਸਰ np ਵਜੋਂ ਆਯਾਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ)। ਸਾਡੇ ਦੋ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਸਾਡੇ ਆਯਾਤ ਤੋਂ ਬਾਅਦ ਬਣਾਏ ਜਾਣਗੇ। ਦੋ ਸਿਗਮੋਇਡ ਫੰਕਸ਼ਨ: ਇੱਕ ਅਤੇ ਸਿਗਮਾਓਡ ਪ੍ਰਾਈਮ।
ਲੌਜਿਸਟਿਕ ਰੀਗਰੈਸ਼ਨ ਸਿਗਮੋਇਡ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਨੂੰ ਵਰਗੀਕ੍ਰਿਤ ਕਰੇਗਾ, ਜਦੋਂ ਕਿ ਬੈਕਪ੍ਰੋਪੈਗੇਸ਼ਨ ਸਿਗਮੋਇਡ ਪ੍ਰਾਈਮ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੈਲਟਾ ਜਾਂ ਗਰੇਡੀਐਂਟ ਦੀ ਗਣਨਾ ਕਰੇਗਾ।
ਨੈੱਟਵਰਕ ਕਲਾਸ ਬਣਾਉਣਾ
ਇੱਕ ਪੂਰੀ ਤਰ੍ਹਾਂ ਲਿੰਕਡ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ ਇਸ ਸੈਕਸ਼ਨ ਦਾ ਇੱਕੋ ਇੱਕ ਫੋਕਸ ਹੈ। ਨੈੱਟਵਰਕ ਕਲਾਸ ਬਾਅਦ ਵਿੱਚ ਆਉਣ ਵਾਲੇ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰੇਗੀ। ਫੰਕਸ਼ਨ Object() { [ਨੇਟਿਵ ਕੋਡ] } ਸ਼ੁਰੂ ਵਿੱਚ ਸਾਡੀ ਨੈੱਟਵਰਕ ਕਲਾਸ ਵਿੱਚ ਬਣਾਇਆ ਜਾਵੇਗਾ।
ਇੱਕ ਆਰਗੂਮੈਂਟ, ਆਕਾਰ, ਫੰਕਸ਼ਨ Object() { [ਨੇਟਿਵ ਕੋਡ] } ਦੁਆਰਾ ਲੋੜੀਂਦਾ ਹੈ। ਆਕਾਰ ਵੇਰੀਏਬਲ ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ ਦਾ ਇੱਕ ਸੰਗ੍ਰਹਿ ਹੈ ਜੋ ਸਾਡੇ ਨਿਊਰਲ ਨੈਟਵਰਕ ਦੀ ਹਰੇਕ ਪਰਤ ਵਿੱਚ ਮੌਜੂਦ ਇਨਪੁਟ ਨੋਡਾਂ ਦੀ ਸੰਖਿਆ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ।
ਅਸੀਂ ਆਪਣੀ __init__ ਵਿਧੀ ਵਿੱਚ ਚਾਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ। ਇੰਪੁੱਟ ਵੇਰੀਏਬਲ, ਆਕਾਰ, ਕ੍ਰਮਵਾਰ ਲੇਅਰ ਸਾਈਜ਼ ਅਤੇ ਲੇਅਰਾਂ ਦੀ ਗਿਣਤੀ, ਨੰਬਰ ਲੇਅਰਾਂ ਦੀ ਸੂਚੀ ਸੈੱਟ ਕਰਨ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ।
ਪਹਿਲਾ ਕਦਮ ਹੈ ਸਾਡੇ ਨੈੱਟਵਰਕ ਦੇ ਸ਼ੁਰੂਆਤੀ ਪੱਖਪਾਤ ਨੂੰ ਬੇਤਰਤੀਬੇ ਤੌਰ 'ਤੇ ਹਰੇਕ ਲੇਅਰ ਨੂੰ ਸੌਂਪਣਾ ਜੋ ਇਨਪੁਟ ਲੇਅਰ ਦਾ ਅਨੁਸਰਣ ਕਰਦੀ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਲੇਅਰਾਂ ਦੇ ਵਿਚਕਾਰ ਹਰੇਕ ਲਿੰਕ ਦਾ ਆਪਣਾ ਵਜ਼ਨ ਬੇਤਰਤੀਬੇ ਤੌਰ 'ਤੇ ਤਿਆਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। Np.Random.Randn() ਸੰਦਰਭ ਲਈ ਆਮ ਵੰਡ ਤੋਂ ਲਿਆ ਗਿਆ ਇੱਕ ਬੇਤਰਤੀਬ ਨਮੂਨਾ ਦਿੰਦਾ ਹੈ।
ਫੀਡ ਫਾਰਵਰਡ ਫੰਕਸ਼ਨ
ਇੱਕ ਨਿਊਰਲ ਨੈਟਵਰਕ ਵਿੱਚ, ਜਾਣਕਾਰੀ ਨੂੰ ਫੀਡਫੋਰਡ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਅੱਗੇ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਆਰਗੂਮੈਂਟ, a, ਮੌਜੂਦਾ ਐਕਟੀਵੇਸ਼ਨ ਵੈਕਟਰ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, ਇਸ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਲੋੜੀਂਦਾ ਹੋਵੇਗਾ।
ਇਹ ਫੰਕਸ਼ਨ ਨੈੱਟਵਰਕ ਵਿੱਚ ਸਾਰੇ ਪੱਖਪਾਤਾਂ ਅਤੇ ਵਜ਼ਨਾਂ ਨੂੰ ਦੁਹਰਾਉਣ ਦੁਆਰਾ ਹਰੇਕ ਲੇਅਰ 'ਤੇ ਸਰਗਰਮੀਆਂ ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ। ਦਿੱਤਾ ਗਿਆ ਜਵਾਬ ਪੂਰਵ ਅਨੁਮਾਨ ਹੈ, ਜੋ ਕਿ ਆਖਰੀ ਪਰਤ ਦੀਆਂ ਸਰਗਰਮੀਆਂ ਹਨ।
ਮਿੰਨੀ-ਬੈਚ ਗਰੇਡੀਐਂਟ ਡੀਸੈਂਟ
ਸਾਡੀ ਨੈੱਟਵਰਕ ਕਲਾਸ ਦਾ ਵਰਕ ਹਾਰਸ ਗਰੇਡੀਐਂਟ ਡੀਸੈਂਟ ਹੈ। ਇਸ ਸੰਸਕਰਣ ਵਿੱਚ, ਅਸੀਂ ਮਿੰਨੀ-ਬੈਚ (ਸਟੋਕੈਸਟਿਕ) ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ, ਗਰੇਡੀਐਂਟ ਡਿਸੇਂਟ ਦੀ ਇੱਕ ਸੋਧੀ ਹੋਈ ਪਰਿਵਰਤਨ।
ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਸਾਡੇ ਮਾਡਲ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਲਈ ਡੇਟਾ ਪੁਆਇੰਟਾਂ ਦਾ ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਬੈਚ ਵਰਤਿਆ ਜਾਵੇਗਾ। ਇਸ ਵਿਧੀ ਨੂੰ ਚਾਰ ਲੋੜੀਂਦੇ ਅਤੇ ਇੱਕ ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟ ਦਿੱਤੇ ਗਏ ਹਨ। ਚਾਰ ਲੋੜੀਂਦੇ ਵੇਰੀਏਬਲ ਹਨ ਸਿਖਲਾਈ ਡੇਟਾ ਸੈੱਟ, ਯੁੱਗਾਂ ਦੀ ਗਿਣਤੀ, ਮਿੰਨੀ-ਬੈਚਾਂ ਦਾ ਆਕਾਰ, ਅਤੇ ਸਿੱਖਣ ਦੀ ਦਰ (ਈਟਾ)।
ਟੈਸਟ ਡਾਟਾ ਬੇਨਤੀ 'ਤੇ ਉਪਲਬਧ ਹਨ. ਜਦੋਂ ਅਸੀਂ ਅੰਤ ਵਿੱਚ ਇਸ ਨੈੱਟਵਰਕ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ ਟੈਸਟ ਡੇਟਾ ਦੀ ਸਪਲਾਈ ਕਰਾਂਗੇ। ਇਸ ਫੰਕਸ਼ਨ ਵਿੱਚ ਨਮੂਨਿਆਂ ਦੀ ਸੰਖਿਆ ਸ਼ੁਰੂ ਵਿੱਚ ਸੂਚੀ ਦੀ ਲੰਬਾਈ 'ਤੇ ਸੈੱਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਸਿਖਲਾਈ ਡੇਟਾ ਨੂੰ ਇੱਕ ਸੂਚੀ ਕਿਸਮ ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।
ਅਸੀਂ ਉਹੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਟੈਸਟ ਕਰਨ ਲਈ ਵੀ ਲਾਗੂ ਕਰਦੇ ਹਾਂ ਜੋ ਡੇਟਾ ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਸਾਨੂੰ ਸੂਚੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕੀਤੇ ਜਾਣ ਦੀ ਬਜਾਏ, ਉਹ ਅਸਲ ਵਿੱਚ ਸੂਚੀਆਂ ਦੇ ਜ਼ਿਪ ਹਨ। ਜਦੋਂ ਅਸੀਂ ਬਾਅਦ ਵਿੱਚ MNIST ਡੇਟਾ ਦੇ ਨਮੂਨੇ ਲੋਡ ਕਰਦੇ ਹਾਂ, ਅਸੀਂ ਇਸ ਬਾਰੇ ਹੋਰ ਜਾਣਾਂਗੇ।
ਜੇਕਰ ਅਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹਾਂ ਕਿ ਅਸੀਂ ਸੂਚੀਆਂ ਦੇ ਤੌਰ 'ਤੇ ਦੋਵੇਂ ਤਰ੍ਹਾਂ ਦੇ ਡੇਟਾ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਕਿਸਮ-ਕਾਸਟਿੰਗ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ।
ਇੱਕ ਵਾਰ ਸਾਡੇ ਕੋਲ ਡੇਟਾ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇੱਕ ਲੂਪ ਵਿੱਚ ਸਿਖਲਾਈ ਦੇ ਦੌਰ ਨੂੰ ਵੇਖਦੇ ਹਾਂ। ਸਿਖਲਾਈ ਦੀ ਮਿਆਦ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਸਿਖਲਾਈ ਦਾ ਸਿਰਫ਼ ਇੱਕ ਦੌਰ ਹੈ। ਅਸੀਂ ਮਿੰਨੀ-ਬੈਚਾਂ ਦੀ ਸੂਚੀ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਬੇਤਰਤੀਬਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਹਰੇਕ ਯੁੱਗ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਪਹਿਲਾਂ ਬਦਲਦੇ ਹਾਂ।
ਅੱਪਡੇਟ ਮਿੰਨੀ ਬੈਚ ਫੰਕਸ਼ਨ, ਜਿਸਦੀ ਹੇਠਾਂ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ, ਹਰੇਕ ਮਿੰਨੀ-ਬੈਚ ਲਈ ਬੁਲਾਇਆ ਜਾਵੇਗਾ। ਜੇਕਰ ਟੈਸਟ ਡੇਟਾ ਉਪਲਬਧ ਹੈ ਤਾਂ ਟੈਸਟ ਦੀ ਸ਼ੁੱਧਤਾ ਵੀ ਵਾਪਸ ਕਰ ਦਿੱਤੀ ਜਾਵੇਗੀ।
ਲਾਗਤ-ਡੈਰੀਵੇਟਿਵ ਸਹਾਇਕ ਫੰਕਸ਼ਨ
ਆਉ ਅਸਲ ਵਿੱਚ ਬੈਕਪ੍ਰੋਪੈਗੇਸ਼ਨ ਕੋਡ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਸਹਾਇਕ ਫੰਕਸ਼ਨ ਵਿਕਸਿਤ ਕਰੀਏ ਜਿਸਨੂੰ ਲਾਗਤ ਡੈਰੀਵੇਟਿਵ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਅਸੀਂ ਆਪਣੀ ਆਉਟਪੁੱਟ ਲੇਅਰ ਵਿੱਚ ਗਲਤੀ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਲਾਗਤ ਡੈਰੀਵੇਟਿਵ ਫੰਕਸ਼ਨ ਇਸਨੂੰ ਦਿਖਾਏਗਾ।
ਇਸ ਨੂੰ ਦੋ ਇਨਪੁਟਸ ਦੀ ਲੋੜ ਹੈ: ਆਉਟਪੁੱਟ ਐਕਟੀਵੇਸ਼ਨ ਐਰੇ ਅਤੇ ਅਨੁਮਾਨਿਤ ਆਉਟਪੁੱਟ ਮੁੱਲਾਂ ਦੇ y-ਕੋਆਰਡੀਨੇਟਸ।
ਬੈਕਪ੍ਰੋਪੈਗੇਸ਼ਨ ਫੰਕਸ਼ਨ
ਸਾਡੇ ਮੌਜੂਦਾ ਐਕਟੀਵੇਸ਼ਨ ਵੈਕਟਰ, ਐਕਟੀਵੇਸ਼ਨ, ਅਤੇ ਨਾਲ ਹੀ ਕੋਈ ਹੋਰ ਐਕਟੀਵੇਸ਼ਨ ਵੈਕਟਰ, ਐਕਟੀਵੇਸ਼ਨ, ਅਤੇ z-ਵੈਕਟਰ, zs, ਸਭ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਕ ਪਰਤ ਜਿਸਨੂੰ ਇਨਪੁਟ ਲੇਅਰ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਪਹਿਲਾਂ ਸਰਗਰਮ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਰੱਖਣ ਤੋਂ ਬਾਅਦ ਹਰੇਕ ਪੱਖਪਾਤ ਅਤੇ ਭਾਰ ਨੂੰ ਲੂਪ ਕਰਾਂਗੇ। ਹਰੇਕ ਲੂਪ ਵਿੱਚ z ਵੈਕਟਰ ਨੂੰ ਵਜ਼ਨ ਅਤੇ ਐਕਟੀਵੇਸ਼ਨ ਦੇ ਬਿੰਦੂ ਉਤਪਾਦ ਵਜੋਂ ਗਿਣਨਾ, ਇਸਨੂੰ zs ਦੀ ਸੂਚੀ ਵਿੱਚ ਜੋੜਨਾ, ਸਰਗਰਮੀ ਦੀ ਮੁੜ ਗਣਨਾ ਕਰਨਾ, ਅਤੇ ਕਿਰਿਆਸ਼ੀਲਤਾ ਦੀ ਸੂਚੀ ਵਿੱਚ ਅੱਪਡੇਟ ਕੀਤੀ ਐਕਟੀਵੇਸ਼ਨ ਨੂੰ ਜੋੜਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਗਣਿਤ. ਡੈਲਟਾ, ਜੋ ਕਿ zs ਵੈਕਟਰਾਂ ਦੇ ਆਖਰੀ ਐਲੀਮੈਂਟ ਦੇ ਸਿਗਮੋਇਡ ਪ੍ਰਾਈਮ ਨਾਲ ਗੁਣਾ ਕੀਤੀ ਪਿਛਲੀ ਲੇਅਰ ਤੋਂ ਗਲਤੀ ਦੇ ਬਰਾਬਰ ਹੈ, ਨੂੰ ਸਾਡੇ ਬੈਕਵਰਡ ਪਾਸ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।
ਨਾਬਲਾ ਬੀ ਦੀ ਆਖਰੀ ਪਰਤ ਡੈਲਟਾ ਲਈ ਸੈੱਟ ਕੀਤੀ ਗਈ ਹੈ, ਅਤੇ ਨਾਬਲਾ ਡਬਲਯੂ ਦੀ ਅੰਤਿਮ ਪਰਤ ਡੈਲਟਾ ਦੇ ਬਿੰਦੂ ਉਤਪਾਦ ਅਤੇ ਕਿਰਿਆਸ਼ੀਲਤਾ ਦੀ ਦੂਜੀ-ਤੋਂ-ਆਖਰੀ ਪਰਤ ਲਈ ਸੈੱਟ ਕੀਤੀ ਗਈ ਹੈ (ਟ੍ਰਾਂਸਪੋਜ਼ ਕੀਤਾ ਗਿਆ ਤਾਂ ਜੋ ਅਸੀਂ ਅਸਲ ਵਿੱਚ ਗਣਿਤ ਕਰ ਸਕੀਏ) .
ਅਸੀਂ ਪਹਿਲਾਂ ਵਾਂਗ ਅੱਗੇ ਵਧਦੇ ਹਾਂ, ਦੂਜੀ ਪਰਤ ਨਾਲ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ ਅਤੇ ਆਖਰੀ ਨਾਲ ਸਮਾਪਤ ਕਰਦੇ ਹਾਂ, ਅਤੇ ਇਹਨਾਂ ਆਖਰੀ ਪਰਤਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਹਰਾਉਂਦੇ ਹਾਂ। ਫਿਰ ਨਾਬਲਾਂ ਨੂੰ ਟੂਪਲ ਵਜੋਂ ਵਾਪਸ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।
ਮਿੰਨੀ-ਬੈਚ ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਸਾਡੀ SGD (ਸਟੋਕੈਸਟਿਕ ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ) ਵਿਧੀ ਪਹਿਲਾਂ ਤੋਂ ਮਿੰਨੀ-ਬੈਚ ਅੱਪਡੇਟਿੰਗ ਨੂੰ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ। ਕਿਉਂਕਿ ਇਹ SGD ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਬੈਕਪ੍ਰੌਪ ਦੀ ਵੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਮੈਂ ਬਹਿਸ ਕੀਤੀ ਕਿ ਇਸ ਫੰਕਸ਼ਨ ਨੂੰ ਕਿੱਥੇ ਰੱਖਣਾ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਮੈਂ ਇਸਨੂੰ ਇੱਥੇ ਪੋਸਟ ਕਰਨ ਦੀ ਚੋਣ ਕੀਤੀ. ਇਹ ਸਾਡੇ ਬੈਕਪ੍ਰੌਪ ਫੰਕਸ਼ਨ ਦੀ ਤਰ੍ਹਾਂ, ਬਾਈਅਸ' ਅਤੇ ਵੇਟਸ' ਨੈਬਲਾਸ ਦੇ 0 ਵੈਕਟਰ ਬਣਾਉਣ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ।
ਇਸ ਦੇ ਦੋ ਇਨਪੁਟਸ ਦੇ ਤੌਰ 'ਤੇ ਮਿੰਨੀ-ਬੈਚ ਅਤੇ ਈਟਾ ਸਿੱਖਣ ਦੀ ਦਰ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਮਿੰਨੀ-ਬੈਚ ਵਿੱਚ, ਅਸੀਂ ਫਿਰ ਹਰੇਕ ਇਨਪੁਟ, x, ਅਤੇ ਆਉਟਪੁੱਟ, y ਲਈ ਹਰੇਕ ਨਾਬਲਾ ਐਰੇ ਦਾ ਡੈਲਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਬੈਕਪ੍ਰੌਪ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਫਿਰ ਨਾਬਲਾ ਸੂਚੀਆਂ ਨੂੰ ਇਹਨਾਂ ਡੈਲਟਾ ਨਾਲ ਅਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਨੈਟਵਰਕ ਦੇ ਵਜ਼ਨ ਅਤੇ ਪੱਖਪਾਤ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਲਈ ਸਿੱਖਣ ਦੀ ਦਰ ਅਤੇ ਨਬਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਹਰੇਕ ਮੁੱਲ ਨੂੰ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਮੁੱਲ ਵਿੱਚ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਸਿੱਖਣ ਦੀ ਦਰ ਤੋਂ ਘੱਟ, ਮਿਨੀਬੈਚ ਆਕਾਰ ਨਾਲ ਗੁਣਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਫਿਰ ਨਾਬਲਾ ਮੁੱਲ ਵਿੱਚ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।
ਫੰਕਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ
ਮੁਲਾਂਕਣ ਫੰਕਸ਼ਨ ਆਖਰੀ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਸਾਨੂੰ ਲਿਖਣ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਫੰਕਸ਼ਨ ਲਈ ਟੈਸਟ ਡੇਟਾ ਹੀ ਇਨਪੁਟ ਹੈ। ਇਸ ਫੰਕਸ਼ਨ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ ਅਨੁਮਾਨਿਤ ਨਤੀਜੇ ਦੇ ਨਾਲ ਨੈੱਟਵਰਕ ਦੇ ਆਉਟਪੁੱਟ ਦੀ ਤੁਲਨਾ ਕਰਦੇ ਹਾਂ, y. ਇੰਪੁੱਟ, x, ਫਾਰਵਰਡ ਨੂੰ ਫੀਡ ਕਰਕੇ, ਨੈਟਵਰਕ ਦੇ ਆਉਟਪੁੱਟ ਨਿਰਧਾਰਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ.
ਪੂਰਾ ਕੋਡ
ਜਦੋਂ ਅਸੀਂ ਸਾਰੇ ਕੋਡ ਨੂੰ ਜੋੜਦੇ ਹਾਂ, ਤਾਂ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।
ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਦੀ ਜਾਂਚ
MNIST ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
The MNIST ਡਾਟਾ .pkl.gz ਫਾਰਮੈਟ ਵਿੱਚ ਹੈ, ਜਿਸ ਨੂੰ ਅਸੀਂ GZIP ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਖੋਲ੍ਹਾਂਗੇ ਅਤੇ ਅਚਾਰ ਨਾਲ ਲੋਡ ਕਰਾਂਗੇ। ਆਉ ਇਸ ਡੇਟਾ ਨੂੰ ਸਾਈਜ਼ ਤਿੰਨ ਦੇ ਟੁਪਲ ਦੇ ਰੂਪ ਵਿੱਚ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਤੇਜ਼ ਤਰੀਕਾ ਲਿਖੀਏ, ਸਿਖਲਾਈ, ਪ੍ਰਮਾਣਿਕਤਾ, ਅਤੇ ਟੈਸਟ ਡੇਟਾ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ।
ਸਾਡੇ ਡੇਟਾ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ 10-ਆਈਟਮ ਐਰੇ ਵਿੱਚ y ਨੂੰ ਏਨਕੋਡ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਲਿਖਾਂਗੇ। ਐਰੇ 0 ਨੂੰ ਛੱਡ ਕੇ ਸਾਰੇ 1s ਹੋਣਗੇ ਜੋ ਚਿੱਤਰ ਦੇ ਸਹੀ ਅੰਕ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ।
ਅਸੀਂ ਆਪਣੇ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨਯੋਗ ਫਾਰਮੈਟ ਵਿੱਚ ਲੋਡ ਕਰਨ ਲਈ ਮੂਲ ਲੋਡ ਡੇਟਾ ਅਤੇ ਇੱਕ ਗਰਮ ਏਨਕੋਡ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਇੱਕ ਹੋਰ ਫੰਕਸ਼ਨ ਲਿਖਿਆ ਜਾਵੇਗਾ ਜੋ ਸਾਡੇ x ਮੁੱਲਾਂ ਨੂੰ ਆਕਾਰ 784 ਦੀ ਸੂਚੀ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗਾ, ਚਿੱਤਰ ਦੇ 784 ਪਿਕਸਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ, ਅਤੇ ਸਾਡੇ y ਮੁੱਲਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਸਿੰਗਲ ਹੌਟ ਏਨਕੋਡ ਵੈਕਟਰ ਰੂਪ ਵਿੱਚ ਬਦਲ ਦੇਵੇਗਾ।
ਫਿਰ ਅਸੀਂ x ਅਤੇ y ਮੁੱਲਾਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਜੋੜਾਂਗੇ ਕਿ ਇੱਕ ਸੂਚਕਾਂਕ ਦੂਜੇ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਇਹ ਸਿਖਲਾਈ, ਪ੍ਰਮਾਣਿਕਤਾ, ਅਤੇ ਟੈਸਟ ਡੇਟਾ ਸੈੱਟਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦਾ ਹੈ। ਅਸੀਂ ਫਿਰ ਬਦਲਿਆ ਡੇਟਾ ਵਾਪਸ ਕਰਦੇ ਹਾਂ।
ਚੱਲ ਰਹੇ ਟੈਸਟ
ਅਸੀਂ "mnist ਲੋਡਰ" ਨਾਮ ਦੀ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਬਣਾਵਾਂਗੇ ਜੋ ਸਾਡੇ ਦੁਆਰਾ ਜਾਂਚ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸਾਡੇ ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤੇ ਗਏ ਨਿਊਰਲ ਨੈਟਵਰਕ (ਸਧਾਰਨ nn) ਅਤੇ MNIST ਡੇਟਾ ਸੈੱਟ ਲੋਡਰ ਦੋਵਾਂ ਨੂੰ ਆਯਾਤ ਕਰੇਗੀ।
ਇਸ ਫਾਈਲ ਵਿੱਚ, ਸਾਨੂੰ ਸਿਰਫ਼ ਡੇਟਾ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, 784 ਦੀ ਇੱਕ ਇਨਪੁਟ ਲੇਅਰ ਸਾਈਜ਼ ਅਤੇ 10 ਦੀ ਇੱਕ ਆਉਟਪੁੱਟ ਲੇਅਰ ਸਾਈਜ਼ ਵਾਲਾ ਇੱਕ ਨੈਟਵਰਕ ਬਣਾਉਣਾ, ਟਰੇਨਿੰਗ ਡੇਟਾ 'ਤੇ ਨੈੱਟਵਰਕ ਦੇ SGD ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣਾ, ਫਿਰ ਟੈਸਟ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਦੀ ਜਾਂਚ ਕਰਨੀ ਹੈ।
ਧਿਆਨ ਵਿੱਚ ਰੱਖੋ ਕਿ ਸਾਡੀਆਂ ਇਨਪੁਟ ਲੇਅਰਾਂ ਦੀ ਸੂਚੀ ਲਈ, ਇਸ ਨਾਲ ਕੋਈ ਫਰਕ ਨਹੀਂ ਪੈਂਦਾ ਕਿ 784 ਅਤੇ 10 ਦੇ ਵਿਚਕਾਰ ਕੋਈ ਵੀ ਸੰਖਿਆ ਕੀ ਹੈ। ਅਸੀਂ ਦੂਜੀਆਂ ਪਰਤਾਂ ਨੂੰ ਆਪਣੀ ਮਰਜ਼ੀ ਨਾਲ ਬਦਲ ਸਕਦੇ ਹਾਂ; ਬਸ ਇੰਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਆਕਾਰ ਸਥਿਰ ਹਨ।
ਤਿੰਨ ਪਰਤਾਂ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹਨ; ਅਸੀਂ ਚਾਰ, ਪੰਜ ਜਾਂ ਸਿਰਫ਼ ਦੋ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਦੇ ਨਾਲ ਪ੍ਰਯੋਗ ਕਰਨ ਵਿੱਚ ਮਜ਼ਾ ਲਓ।
ਸਿੱਟਾ
ਇੱਥੇ, ਪਾਈਥਨ 3 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਅਸੀਂ ਸਕ੍ਰੈਚ ਤੋਂ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਂਦੇ ਹਾਂ। ਉੱਚ-ਪੱਧਰੀ ਗਣਿਤ ਦੇ ਨਾਲ, ਅਸੀਂ ਲਾਗੂ ਕਰਨ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਵੀ ਚਰਚਾ ਕੀਤੀ।
ਅਸੀਂ ਸਹਾਇਕ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਲਾਗੂ ਕਰਕੇ ਸ਼ੁਰੂਆਤ ਕੀਤੀ। ਨਿਊਰੋਨਸ ਦੇ ਕੰਮ ਕਰਨ ਲਈ, ਸਿਗਮੋਇਡ ਅਤੇ ਸਿਗਮੋਇਡ ਪ੍ਰਾਈਮ ਫੰਕਸ਼ਨ ਮਹੱਤਵਪੂਰਨ ਹਨ। ਫਿਰ ਅਸੀਂ ਫੀਡਫੋਰਡ ਫੰਕਸ਼ਨ ਨੂੰ ਅਮਲ ਵਿੱਚ ਲਿਆਉਂਦੇ ਹਾਂ, ਜੋ ਕਿ ਨਿਊਰਲ ਨੈਟਵਰਕ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਫੀਡ ਕਰਨ ਲਈ ਬੁਨਿਆਦੀ ਪ੍ਰਕਿਰਿਆ ਹੈ।
ਅੱਗੇ, ਅਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ ਫੰਕਸ਼ਨ ਬਣਾਇਆ, ਉਹ ਇੰਜਣ ਜੋ ਸਾਡੇ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। "ਸਥਾਨਕ ਮਿਨੀਮਾ" ਦਾ ਪਤਾ ਲਗਾਉਣ ਅਤੇ ਉਹਨਾਂ ਦੇ ਵਜ਼ਨ ਅਤੇ ਪੱਖਪਾਤ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ, ਸਾਡਾ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਗਰੇਡੀਐਂਟ ਡਿਸੇਂਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਅਸੀਂ ਵਰਤ ਕੇ ਬੈਕਪ੍ਰੋਪੈਗੇਸ਼ਨ ਫੰਕਸ਼ਨ ਬਣਾਇਆ ਹੈ ਗਰੇਡੀਐਂਟ ਉਤਰਾਈ.
ਅੱਪਡੇਟ ਪ੍ਰਦਾਨ ਕਰਕੇ ਜਦੋਂ ਆਉਟਪੁੱਟ ਸਹੀ ਲੇਬਲਾਂ ਨਾਲ ਮੇਲ ਨਹੀਂ ਖਾਂਦੇ, ਇਹ ਫੰਕਸ਼ਨ ਨਿਊਰਲ ਨੈਟਵਰਕ ਨੂੰ "ਸਿੱਖਣ" ਲਈ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।
ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਆਪਣਾ ਬਿਲਕੁਲ ਨਵਾਂ ਪਾਈਥਨ ਪਾ ਦਿੱਤਾ ਨਿਊਰਲ ਨੈਟਵਰਕ MNIST ਡਾਟਾ ਸੈੱਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਲਈ। ਸਭ ਕੁਝ ਸੁਚਾਰੂ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਸੀ।
ਹੈਡਿੰਗ ਕੋਡਿੰਗ!
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ