ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ (AI) ਨੇ ਹਾਲ ਹੀ ਦੇ ਸਾਲਾਂ ਵਿੱਚ ਕਾਫੀ ਪ੍ਰਸਿੱਧੀ ਹਾਸਲ ਕੀਤੀ ਹੈ।
ਜੇ ਤੁਸੀਂ ਇੱਕ ਸੌਫਟਵੇਅਰ ਇੰਜੀਨੀਅਰ, ਕੰਪਿਊਟਰ ਵਿਗਿਆਨੀ, ਜਾਂ ਆਮ ਤੌਰ 'ਤੇ ਡੇਟਾ ਵਿਗਿਆਨ ਦੇ ਉਤਸ਼ਾਹੀ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਸ ਖੇਤਰ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਚਿੱਤਰ ਪ੍ਰੋਸੈਸਿੰਗ, ਪੈਟਰਨ ਪਛਾਣ ਅਤੇ ਵਸਤੂ ਖੋਜ ਦੇ ਅਦਭੁਤ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੁਆਰਾ ਦਿਲਚਸਪ ਹੋ।
AI ਦਾ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਸਬਫੀਲਡ ਜਿਸ ਬਾਰੇ ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੁਣਿਆ ਹੋਵੇਗਾ ਉਹ ਹੈ ਡੀਪ ਲਰਨਿੰਗ। ਇਹ ਖੇਤਰ ਸ਼ਕਤੀਸ਼ਾਲੀ ਐਲਗੋਰਿਦਮ (ਕੰਪਿਊਟਰ ਪ੍ਰੋਗਰਾਮ ਨਿਰਦੇਸ਼ਾਂ) 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ ਜੋ ਮਨੁੱਖੀ ਦਿਮਾਗ ਦੀ ਕਾਰਜਕੁਸ਼ਲਤਾ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ ਨਿਊਰਲ ਨੈਟਵਰਕ.
ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਨਿਊਰਲ ਨੈਟਵਰਕਸ ਦੀ ਧਾਰਨਾ ਅਤੇ ਇਹਨਾਂ ਮਾਡਲਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ, ਕੰਪਾਈਲ ਕਰਨਾ, ਫਿੱਟ ਕਰਨਾ ਅਤੇ ਮੁਲਾਂਕਣ ਕਰਨਾ ਹੈ ਬਾਰੇ ਵਿਚਾਰ ਕਰਾਂਗੇ। ਪਾਈਥਨ.
ਨਿਊਰਲ ਨੈਟਵਰਕ
ਨਿਊਰਲ ਨੈੱਟਵਰਕ, ਜਾਂ NN, ਮਨੁੱਖੀ ਦਿਮਾਗ ਦੀ ਜੈਵਿਕ ਗਤੀਵਿਧੀ ਦੇ ਬਾਅਦ ਤਿਆਰ ਕੀਤੇ ਗਏ ਐਲਗੋਰਿਦਮ ਦੀ ਇੱਕ ਲੜੀ ਹੈ। ਨਿਊਰਲ ਨੈੱਟਵਰਕਾਂ ਵਿੱਚ ਨੋਡ ਹੁੰਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਨਿਊਰੋਨ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।
ਲੰਬਕਾਰੀ ਨੋਡਾਂ ਦੇ ਸੰਗ੍ਰਹਿ ਨੂੰ ਲੇਅਰਾਂ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ। ਮਾਡਲ ਵਿੱਚ ਇੱਕ ਇੰਪੁੱਟ, ਇੱਕ ਆਉਟਪੁੱਟ, ਅਤੇ ਕਈ ਛੁਪੀਆਂ ਪਰਤਾਂ ਸ਼ਾਮਲ ਹੁੰਦੀਆਂ ਹਨ। ਹਰੇਕ ਪਰਤ ਵਿੱਚ ਨੋਡ ਹੁੰਦੇ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਨਿਊਰੋਨ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਜਿੱਥੇ ਗਣਨਾ ਹੁੰਦੀ ਹੈ।
ਹੇਠਲੇ ਚਿੱਤਰ ਵਿੱਚ, ਚੱਕਰ ਨੋਡਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ ਅਤੇ ਨੋਡਾਂ ਦਾ ਲੰਬਕਾਰੀ ਸੰਗ੍ਰਹਿ ਲੇਅਰਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਸ ਮਾਡਲ ਵਿੱਚ ਤਿੰਨ ਪਰਤਾਂ ਹਨ।
ਇੱਕ ਲੇਅਰ ਦੇ ਨੋਡਸ ਨੂੰ ਹੇਠਾਂ ਵੇਖੀਆਂ ਗਈਆਂ ਟਰਾਂਸਮਿਸ਼ਨ ਲਾਈਨਾਂ ਰਾਹੀਂ ਅਗਲੀ ਪਰਤ ਨਾਲ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।
ਸਾਡੇ ਡੇਟਾਸੇਟ ਵਿੱਚ ਲੇਬਲ ਕੀਤੇ ਡੇਟਾ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ। ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਹਰੇਕ ਡੇਟਾ ਇਕਾਈ ਨੂੰ ਇੱਕ ਖਾਸ ਨਾਮ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ।
ਇਸ ਲਈ ਇੱਕ ਜਾਨਵਰ ਵਰਗੀਕਰਣ ਡੇਟਾਸੈਟ ਲਈ ਸਾਡੇ ਕੋਲ ਸਾਡੇ ਡੇਟਾ ਦੇ ਤੌਰ 'ਤੇ ਬਿੱਲੀਆਂ ਅਤੇ ਕੁੱਤਿਆਂ ਦੀਆਂ ਤਸਵੀਰਾਂ ਹੋਣਗੀਆਂ, ਜਿਸ ਵਿੱਚ 'ਕੈਟ' ਅਤੇ 'ਕੁੱਤੇ' ਸਾਡੇ ਲੇਬਲ ਹੋਣਗੇ।
ਇਹ ਨੋਟ ਕਰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਲੇਬਲਾਂ ਨੂੰ ਸਾਡੇ ਮਾਡਲ ਲਈ ਸੰਖਿਆਤਮਕ ਮੁੱਲਾਂ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਉਹਨਾਂ ਨੂੰ ਸਮਝਿਆ ਜਾ ਸਕੇ, ਇਸਲਈ ਸਾਡੇ ਜਾਨਵਰਾਂ ਦੇ ਲੇਬਲ ਬਿੱਲੀ ਲਈ '0' ਅਤੇ ਕੁੱਤੇ ਲਈ '1' ਬਣ ਜਾਂਦੇ ਹਨ। ਡੇਟਾ ਅਤੇ ਲੇਬਲ ਦੋਵੇਂ ਮਾਡਲ ਦੁਆਰਾ ਪਾਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ.
ਲਰਨਿੰਗ
ਡੇਟਾ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਮਾਡਲ ਨੂੰ ਫੀਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਡੇਟਾ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਮਾਡਲ ਦੇ ਹਰੇਕ ਨੋਡ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ। ਨੋਡਸ ਇਹਨਾਂ ਟੁਕੜਿਆਂ 'ਤੇ ਗਣਿਤਿਕ ਕਾਰਵਾਈਆਂ ਕਰਦੇ ਹਨ।
ਤੁਹਾਨੂੰ ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ ਗਣਿਤ ਦੇ ਫੰਕਸ਼ਨਾਂ ਜਾਂ ਗਣਨਾਵਾਂ ਨੂੰ ਜਾਣਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ, ਪਰ ਇਹ ਮਾਡਲ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਇਸ ਬਾਰੇ ਇੱਕ ਆਮ ਵਿਚਾਰ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇੱਕ ਲੇਅਰ ਵਿੱਚ ਗਣਨਾਵਾਂ ਦੀ ਇੱਕ ਲੜੀ ਤੋਂ ਬਾਅਦ, ਡੇਟਾ ਨੂੰ ਅਗਲੀ ਪਰਤ ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਹੋਰ ਵੀ।
ਇੱਕ ਵਾਰ ਪੂਰਾ ਹੋਣ 'ਤੇ, ਸਾਡਾ ਮਾਡਲ ਆਉਟਪੁੱਟ ਲੇਅਰ 'ਤੇ ਡੇਟਾ ਲੇਬਲ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ (ਉਦਾਹਰਣ ਲਈ, ਇੱਕ ਜਾਨਵਰ ਵਰਗੀਕਰਣ ਸਮੱਸਿਆ ਵਿੱਚ ਸਾਨੂੰ ਇੱਕ ਬਿੱਲੀ ਲਈ '0' ਭਵਿੱਖਬਾਣੀ ਮਿਲਦੀ ਹੈ)।
ਮਾਡਲ ਫਿਰ ਅਸਲ ਲੇਬਲ ਮੁੱਲ ਦੇ ਨਾਲ ਇਸ ਅਨੁਮਾਨਿਤ ਮੁੱਲ ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਅੱਗੇ ਵਧਦਾ ਹੈ।
ਜੇਕਰ ਮੁੱਲ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਤਾਂ ਸਾਡਾ ਮਾਡਲ ਅਗਲਾ ਇਨਪੁਟ ਲਵੇਗਾ ਪਰ ਜੇਕਰ ਮੁੱਲ ਵੱਖਰੇ ਹੁੰਦੇ ਹਨ ਤਾਂ ਮਾਡਲ ਦੋਵਾਂ ਮੁੱਲਾਂ ਵਿੱਚ ਅੰਤਰ ਦੀ ਗਣਨਾ ਕਰੇਗਾ, ਜਿਸਨੂੰ ਘਾਟਾ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਅਗਲੀ ਵਾਰ ਮੇਲ ਖਾਂਦੇ ਲੇਬਲ ਬਣਾਉਣ ਲਈ ਨੋਡ ਗਣਨਾਵਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰੇਗਾ।
ਡੀਪ ਲਰਨਿੰਗ ਫਰੇਮਵਰਕ
ਕੋਡ ਵਿੱਚ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਡੂੰਘੇ ਸਿਖਲਾਈ ਫਰੇਮਵਰਕ ਸਾਡੇ ਏਕੀਕ੍ਰਿਤ ਵਿਕਾਸ ਵਾਤਾਵਰਣ (IDE) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ।
ਇਹ ਫਰੇਮਵਰਕ ਪਹਿਲਾਂ ਤੋਂ ਲਿਖੇ ਫੰਕਸ਼ਨਾਂ ਦਾ ਸੰਗ੍ਰਹਿ ਹਨ ਜੋ ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਸਾਡੀ ਮਦਦ ਕਰਨਗੇ। ਅਸੀਂ ਆਪਣਾ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਕੇਰਸ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
ਕੇਰਸ ਇੱਕ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਹੈ ਜੋ ਇੱਕ ਡੂੰਘੀ ਸਿਖਲਾਈ ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਬੈਕਐਂਡ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ ਟੈਨਸਰਫਲੋ ਆਸਾਨੀ ਨਾਲ ਸਧਾਰਨ ਕ੍ਰਮਵਾਰ ਮਾਡਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ NN ਬਣਾਉਣ ਲਈ।
ਕੇਰਸ ਆਪਣੇ ਖੁਦ ਦੇ ਪੂਰਵ-ਮੌਜੂਦਾ ਮਾਡਲਾਂ ਦੇ ਨਾਲ ਵੀ ਆਉਂਦਾ ਹੈ ਜੋ ਵੀ ਵਰਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ, ਅਸੀਂ Keras ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣਾ ਮਾਡਲ ਬਣਾਵਾਂਗੇ।
ਤੁਸੀਂ ਇਸ ਡੀਪ ਲਰਨਿੰਗ ਫਰੇਮਵਰਕ ਬਾਰੇ ਹੋਰ ਸਿੱਖ ਸਕਦੇ ਹੋ ਕੇਰਸ ਵੈਬਸਾਈਟ.
ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣਾ (ਟਿਊਟੋਰਿਅਲ)
ਆਉ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਬਣਾਉਣ ਲਈ ਅੱਗੇ ਵਧੀਏ।
ਸਮੱਸਿਆ ਦਾ ਬਿਆਨ
ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਏਆਈ-ਅਧਾਰਿਤ ਸਮੱਸਿਆਵਾਂ ਦਾ ਹੱਲ ਹੈ। ਇਸ ਟਿਊਟੋਰਿਅਲ ਲਈ ਅਸੀਂ ਪੀਮਾ ਇੰਡੀਅਨਜ਼ ਡਾਇਬੀਟੀਜ਼ ਡੇਟਾ ਨੂੰ ਦੇਖਾਂਗੇ, ਜੋ ਉਪਲਬਧ ਹੈ ਇਥੇ.
UCI ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਨੇ ਇਸ ਡੇਟਾਸੈਟ ਨੂੰ ਕੰਪਾਇਲ ਕੀਤਾ ਹੈ ਅਤੇ ਭਾਰਤੀ ਮਰੀਜ਼ਾਂ ਦਾ ਮੈਡੀਕਲ ਰਿਕਾਰਡ ਰੱਖਦਾ ਹੈ। ਸਾਡੇ ਮਾਡਲ ਨੇ ਇਹ ਅਨੁਮਾਨ ਲਗਾਉਣਾ ਹੈ ਕਿ ਕੀ ਮਰੀਜ਼ ਨੂੰ 5 ਸਾਲਾਂ ਦੇ ਅੰਦਰ ਸ਼ੂਗਰ ਦੀ ਸ਼ੁਰੂਆਤ ਹੋਈ ਹੈ ਜਾਂ ਨਹੀਂ।
ਡਾਟਾਸੈੱਟ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ
ਸਾਡਾ ਡੇਟਾਸੈਟ 'diabetes.csv' ਨਾਮਕ ਇੱਕ ਸਿੰਗਲ CSV ਫਾਈਲ ਹੈ ਜਿਸਨੂੰ Microsoft Excel ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਹੇਰਾਫੇਰੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਸਾਡਾ ਮਾਡਲ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਆਪਣਾ ਡੇਟਾਸੈਟ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਸੀਂ ਇਹ ਕਰ ਸਕਦੇ ਹੋ:
ਪਾਂਡਾ ਇੰਪੋਰਟ ਕਰੋ
ਡੇਟਾ = pd.read_csv('diabetes.csv')
x = data.drop("ਨਤੀਜਾ")
y = ਡੇਟਾ["ਨਤੀਜਾ"]
ਇੱਥੇ ਅਸੀਂ ਵਰਤ ਰਹੇ ਹਾਂ ਪਾਂਡਾ ਲਾਇਬ੍ਰੇਰੀ ਸਾਡੇ CSV ਫਾਈਲ ਡੇਟਾ ਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, read_csv() Pandas ਦਾ ਇੱਕ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਹੈ ਜੋ ਸਾਨੂੰ ਸਾਡੀ ਫਾਈਲ ਵਿੱਚ ਮੁੱਲਾਂ ਨੂੰ 'ਡੇਟਾ' ਨਾਮਕ ਵੇਰੀਏਬਲ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
ਵੇਰੀਏਬਲ x ਵਿੱਚ ਨਤੀਜਾ (ਲੇਬਲ) ਡੇਟਾ ਤੋਂ ਬਿਨਾਂ ਸਾਡਾ ਡੇਟਾਸੈਟ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ data.drop() ਫੰਕਸ਼ਨ ਨਾਲ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ ਜੋ x ਲਈ ਲੇਬਲਾਂ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਜਦੋਂ ਕਿ y ਵਿੱਚ ਸਿਰਫ਼ ਨਤੀਜਾ (ਲੇਬਲ) ਡੇਟਾ ਹੁੰਦਾ ਹੈ।
ਕ੍ਰਮਵਾਰ ਮਾਡਲ ਬਣਾਉਣਾ
ਕਦਮ 1: ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨਾ
ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਸਾਡੇ ਮਾਡਲ ਲਈ ਲੋੜੀਂਦੇ ਕੁਝ ਮਾਪਦੰਡਾਂ ਦੇ ਨਾਲ, ਟੈਂਸਰਫਲੋ ਅਤੇ ਕੇਰਸ ਨੂੰ ਆਯਾਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਕੋਡ ਸਾਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ:
ਟੈਂਸਰਫਲੋ ਨੂੰ tf ਵਜੋਂ ਆਯਾਤ ਕਰੋ
ਟੈਂਸਰਫਲੋ ਆਯਾਤ ਕੇਰਾ ਤੋਂ
tensorflow.keras.models ਤੋਂ ਕ੍ਰਮਵਾਰ ਆਯਾਤ ਕਰੋ
tensorflow.keras.layers ਤੋਂ ਸਰਗਰਮੀ, ਸੰਘਣੀ ਆਯਾਤ ਕਰੋ
tensorflow.keras.optimizers ਤੋਂ ਐਡਮ ਨੂੰ ਆਯਾਤ ਕਰੋ
tensorflow.keras.metrics ਤੋਂ categorical_crossentropy ਆਯਾਤ ਕਰੋ
ਸਾਡੇ ਮਾਡਲ ਲਈ ਅਸੀਂ ਸੰਘਣੀ ਪਰਤਾਂ ਨੂੰ ਆਯਾਤ ਕਰ ਰਹੇ ਹਾਂ। ਇਹ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਜੁੜੀਆਂ ਪਰਤਾਂ ਹਨ; ਭਾਵ, ਇੱਕ ਲੇਅਰ ਵਿੱਚ ਹਰੇਕ ਨੋਡ ਅਗਲੀ ਲੇਅਰ ਵਿੱਚ ਦੂਜੇ ਨੋਡ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਜੁੜਿਆ ਹੁੰਦਾ ਹੈ।
ਅਸੀਂ ਇੱਕ ਆਯਾਤ ਵੀ ਕਰ ਰਹੇ ਹਾਂ ਸਰਗਰਮ ਨੋਡਾਂ ਨੂੰ ਭੇਜੇ ਗਏ ਡੇਟਾ ਨੂੰ ਸਕੇਲਿੰਗ ਕਰਨ ਲਈ ਲੋੜੀਂਦਾ ਫੰਕਸ਼ਨ। ਆਪਟੀਮਾਈਜ਼ਰ ਨੁਕਸਾਨ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਵੀ ਆਯਾਤ ਕੀਤਾ ਗਿਆ ਹੈ।
ਐਡਮ ਇੱਕ ਪ੍ਰਸਿੱਧ ਆਪਟੀਮਾਈਜ਼ਰ ਹੈ ਜੋ ਸਾਡੇ ਮਾਡਲ ਅੱਪਡੇਟ ਨੋਡ ਗਣਨਾਵਾਂ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਬਣਾਉਂਦਾ ਹੈ, ਨਾਲ ਹੀ categorical_crossentropy ਜੋ ਹੈ ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ ਦੀ ਕਿਸਮ (ਅਸਲ ਅਤੇ ਅਨੁਮਾਨਿਤ ਲੇਬਲ ਮੁੱਲਾਂ ਵਿਚਕਾਰ ਅੰਤਰ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ) ਜੋ ਅਸੀਂ ਵਰਤ ਰਹੇ ਹਾਂ।
ਕਦਮ 2: ਸਾਡੇ ਮਾਡਲ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨਾ
ਜੋ ਮਾਡਲ ਮੈਂ ਬਣਾ ਰਿਹਾ ਹਾਂ ਉਸ ਵਿੱਚ ਇੱਕ ਇਨਪੁਟ (16 ਯੂਨਿਟਾਂ ਦੇ ਨਾਲ), ਇੱਕ ਲੁਕਵੀਂ (32 ਯੂਨਿਟਾਂ ਦੇ ਨਾਲ) ਅਤੇ ਇੱਕ ਆਉਟਪੁੱਟ (2 ਯੂਨਿਟਾਂ ਦੇ ਨਾਲ) ਲੇਅਰ ਹੈ। ਇਹ ਨੰਬਰ ਨਿਸ਼ਚਿਤ ਨਹੀਂ ਹਨ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਦਿੱਤੀ ਸਮੱਸਿਆ 'ਤੇ ਨਿਰਭਰ ਕਰਨਗੇ।
ਯੂਨਿਟਾਂ ਅਤੇ ਲੇਅਰਾਂ ਦੀ ਸਹੀ ਸੰਖਿਆ ਨਿਰਧਾਰਤ ਕਰਨਾ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸ ਨੂੰ ਅਭਿਆਸ ਦੁਆਰਾ ਓਵਰਟਾਈਮ ਵਿੱਚ ਸੁਧਾਰ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਐਕਟੀਵੇਸ਼ਨ ਉਸ ਕਿਸਮ ਦੇ ਸਕੇਲਿੰਗ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਨੋਡ ਰਾਹੀਂ ਪਾਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੇ ਡੇਟਾ 'ਤੇ ਪ੍ਰਦਰਸ਼ਨ ਕਰਾਂਗੇ।
Relu ਅਤੇ Softmax ਇਸ ਕੰਮ ਲਈ ਮਸ਼ਹੂਰ ਐਕਟੀਵੇਸ਼ਨ ਫੰਕਸ਼ਨ ਹਨ।
ਮਾਡਲ = ਕ੍ਰਮਵਾਰ ([[
ਸੰਘਣੀ(ਇਕਾਈਆਂ = 16, ਇਨਪੁਟ_ਸ਼ੈਪ = (1,), ਐਕਟੀਵੇਸ਼ਨ = 'ਰੇਲੂ'),
ਸੰਘਣੀ (ਇਕਾਈਆਂ = 32, ਕਿਰਿਆਸ਼ੀਲਤਾ = 'ਰੇਲੂ'),
ਸੰਘਣੀ (ਇਕਾਈਆਂ = 2, ਕਿਰਿਆਸ਼ੀਲਤਾ = 'ਸੋਫਟਮੈਕਸ')
])
ਇਹ ਹੈ ਕਿ ਮਾਡਲ ਦਾ ਸਾਰ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:
ਮਾਡਲ ਦੀ ਸਿਖਲਾਈ
ਸਾਡੇ ਮਾਡਲ ਨੂੰ ਦੋ ਪੜਾਵਾਂ ਵਿੱਚ ਸਿਖਲਾਈ ਦਿੱਤੀ ਜਾਵੇਗੀ, ਪਹਿਲਾ ਮਾਡਲ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨਾ (ਮਾਡਲ ਨੂੰ ਇਕੱਠੇ ਰੱਖਣਾ) ਅਤੇ ਅਗਲਾ ਇੱਕ ਦਿੱਤੇ ਡੇਟਾਸੈਟ 'ਤੇ ਮਾਡਲ ਨੂੰ ਫਿੱਟ ਕਰਨਾ।
ਇਹ model.compile() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ model.fit() ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
model.compile(optimizer = Adam(learning_rate = 0.0001), loss = 'binary_crossentropy', ਮੈਟ੍ਰਿਕਸ = ['ਸਟੀਕਤਾ'])
model.fit(x, y, epochs = 30, batch_size = 10)
'ਸ਼ੁੱਧਤਾ' ਮੈਟ੍ਰਿਕ ਨੂੰ ਨਿਰਧਾਰਿਤ ਕਰਨ ਨਾਲ ਅਸੀਂ ਸਿਖਲਾਈ ਦੌਰਾਨ ਆਪਣੇ ਮਾਡਲ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹਾਂ।
ਕਿਉਂਕਿ ਸਾਡੇ ਲੇਬਲ 1 ਅਤੇ 0 ਦੇ ਰੂਪ ਵਿੱਚ ਹਨ, ਅਸੀਂ ਅਸਲ ਅਤੇ ਅਨੁਮਾਨਿਤ ਲੇਬਲਾਂ ਵਿੱਚ ਅੰਤਰ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਇੱਕ ਬਾਈਨਰੀ ਨੁਕਸਾਨ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ।
ਡੇਟਾਸੈਟ ਨੂੰ 10 (ਬੈਚ_ਸਾਈਜ਼) ਦੇ ਬੈਚਾਂ ਵਿੱਚ ਵੀ ਵੰਡਿਆ ਜਾ ਰਿਹਾ ਹੈ ਅਤੇ ਮਾਡਲ ਨੂੰ 30 ਵਾਰ (ਯੁੱਗਾਂ) ਵਿੱਚੋਂ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। ਦਿੱਤੇ ਗਏ ਡੇਟਾਸੇਟ ਲਈ, x ਡੇਟਾ ਹੋਵੇਗਾ ਅਤੇ y ਡੇਟਾ ਨਾਲ ਸੰਬੰਧਿਤ ਲੇਬਲ ਹੋਵੇਗਾ।
ਪੂਰਵ-ਅਨੁਮਾਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਮਾਡਲ ਦੀ ਜਾਂਚ ਕਰਨਾ
ਸਾਡੇ ਮਾਡਲ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ, ਅਸੀਂ ਪ੍ਰੀਡਿਕਟ() ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਟੈਸਟ ਡੇਟਾ 'ਤੇ ਭਵਿੱਖਬਾਣੀ ਕਰਦੇ ਹਾਂ।
ਭਵਿੱਖਬਾਣੀ = ਮਾਡਲ। ਭਵਿੱਖਬਾਣੀ(x)
ਅਤੇ ਇਹ ਹੀ ਹੈ!
ਤੁਹਾਨੂੰ ਹੁਣ ਦੀ ਚੰਗੀ ਸਮਝ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਡੂੰਘੀ ਸਿਖਲਾਈ ਐਪਲੀਕੇਸ਼ਨ, ਨਿਊਰਲ ਨੈੱਟਵਰਕ, ਉਹ ਆਮ ਤੌਰ 'ਤੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ ਅਤੇ ਪਾਈਥਨ ਕੋਡ ਵਿੱਚ ਇੱਕ ਮਾਡਲ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ, ਸਿਖਲਾਈ ਅਤੇ ਟੈਸਟ ਕਰਨਾ ਹੈ।
ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਟਿਊਟੋਰਿਅਲ ਤੁਹਾਨੂੰ ਤੁਹਾਡੇ ਆਪਣੇ ਡੀਪ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ ਅਤੇ ਲਾਗੂ ਕਰਨ ਲਈ ਕਿੱਕਸਟਾਰਟ ਦੇਵੇਗਾ।
ਸਾਨੂੰ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਦੱਸੋ ਜੇ ਲੇਖ ਮਦਦਗਾਰ ਸੀ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ