ਲਾਭ:
- ਪ੍ਰਤੀਕਾਤਮਕ ਅਤੇ ਸੰਖਿਆਤਮਕ ਕੈਲਕੂਲਸ ਵਿੱਚ ਫਰਕ ਕਰਨ ਅਤੇ ਹਰੇਕ ਸਮੱਸਿਆ ਲਈ ਸਹੀ ਟੂਲ (SymPy ਜਾਂ NumPy/SciPy) ਦੀ ਚੋਣ ਕਰਨ ਦੀ ਸਮਰੱਥਾ
- ਨਕਲੀ ਬੁੱਧੀ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਸੰਖਿਆਤਮਕ ਕੋਡ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਸਮਝਣ ਦੀ ਸਮਰੱਥਾ, ਇਸਨੂੰ ਆਪਣੇ ਆਪ ਚਲਾਓ, ਅਤੇ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਇਨਪੁਟ ਨਾਲ ਇੱਕ ਆਮ ਸਮਝ ਟੈਸਟ ਕਰਕੇ ਇਸਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
- ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ ਸ਼ੁੱਧਤਾ ਦੀਆਂ ਸੀਮਾਵਾਂ ਨੂੰ ਸਮਝੋ, ਸਹੀ ਸਮਾਨਤਾ ਦੀ ਬਜਾਏ ਸਹਿਣਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਸੰਖਿਆਤਮਕ ਤਰੀਕਿਆਂ 'ਤੇ ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ ਦੇ ਪ੍ਰਭਾਵ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰੋ।
ਸਿੰਬੋਲਿਕ ਕੈਲਕੂਲਸ ਕਿਸੇ ਅਟੁੱਟ ਜਾਂ ਸਮੀਕਰਨ ਦਾ ਸਹੀ ਫਾਰਮੂਲਾ ਦਿੰਦਾ ਹੈ; ਪਰ ਗਣਿਤ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਵਿਹਾਰਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਇੱਕ ਬੰਦ ਫਾਰਮੂਲੇ ਦੁਆਰਾ ਹੱਲ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਖੇਡ ਵਿੱਚ ਆਉਂਦੀ ਹੈ: ਇੱਕ ਸਟੀਕ ਫਾਰਮੂਲੇ ਦੀ ਬਜਾਏ, ਲੋੜੀਂਦੇ ਸ਼ੁੱਧਤਾ ਨਾਲ ਇੱਕ ਅਨੁਮਾਨਿਤ ਸੰਖਿਆਤਮਕ ਨਤੀਜਾ ਪੈਦਾ ਕਰਨਾ। 0.001 ਸ਼ੁੱਧਤਾ ਲਈ ਇੱਕ ਅਟੁੱਟ ਦੇ ਮੁੱਲ ਨੂੰ ਲੱਭਣਾ, ਦਸ਼ਮਲਵ ਅਨੁਮਾਨ ਲਈ ਇੱਕ ਸਮੀਕਰਨ ਦੇ ਮੂਲ ਦੀ ਗਣਨਾ ਕਰਨਾ, ਇੱਕ ਡੇਟਾ ਸੈੱਟ ਤੋਂ ਅੰਕੜੇ ਕੱਢਣਾ — ਇਹ ਸਭ ਸੰਖਿਆਤਮਕ ਗਣਨਾਵਾਂ ਹਨ। ਪਾਈਥਨ ਵਿੱਚ, ਇਸਦੇ ਲਈ ਟੂਲ NumPy (ਅੰਕ ਸੰਬੰਧੀ ਐਰੇ ਅਤੇ ਗਣਿਤ) ਅਤੇ SciPy (ਵਿਗਿਆਨਕ ਕੰਪਿਊਟਿੰਗ) ਲਾਇਬ੍ਰੇਰੀਆਂ ਹਨ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਸਹਾਇਕ ਵਜੋਂ AI ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਿੱਖੋਗੇ ਜੋ ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਲਈ ਪਾਈਥਨ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ ਅਤੇ ਕੋਡ ਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।
ਇੱਕ ਨਾਜ਼ੁਕ ਪਰਿਭਾਸ਼ਾ: ਇੱਕ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਨੰਬਰ ਇੱਕ ਫਾਰਮੈਟ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਕੰਪਿਊਟਰ ਸੀਮਤ ਸ਼ੁੱਧਤਾ ਨਾਲ ਦਸ਼ਮਲਵ ਸੰਖਿਆਵਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ ਕੰਪਿਊਟਰ ਅੰਕਗਣਿਤ ਵਿੱਚ, 0.1 + 0.2 0.30000000000000004 ਹੋ ਸਕਦਾ ਹੈ, ਬਿਲਕੁਲ 0.3 ਨਹੀਂ। ਇਹ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੈ, ਇਹ ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਦੀ ਪ੍ਰਕਿਰਤੀ ਹੈ - ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਜਾਣੂ ਨਹੀਂ ਹੋ ਤਾਂ ਇਹ ਗਲਤ ਨਤੀਜੇ ਵੱਲ ਲੈ ਜਾਵੇਗਾ। ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਵਿੱਚ, ਕੋਈ "ਸਹੀ ਸਮਾਨਤਾ" ਦੀ ਬਜਾਏ "ਕਾਫ਼ੀ ਨੇੜੇ" ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।
ਪ੍ਰਤੀਕ ਜਾਂ ਸੰਖਿਆਤਮਕ? ਸਹੀ ਸੰਦ ਦੀ ਚੋਣ
ਸਥਿਤੀ
ਪ੍ਰਤੀਕ (SymPy)
ਸੰਖਿਆਤਮਕ (NumPy/SciPy)
ਇੱਕ ਬੰਦ ਫਾਰਮੂਲਾ ਹੈ
ਤਰਜੀਹੀ
ਜ਼ਰੂਰੀ ਨਹੀਂ
ਕੋਈ ਫਾਰਮੂਲਾ/ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਨਹੀਂ
ਹੱਲ ਨਹੀਂ ਕਰ ਸਕਦੇ
ਤਰਜੀਹੀ
ਪੂਰੀ ਸ਼ੁੱਧਤਾ ਦੀ ਲੋੜ ਹੈ
ਹਾਂ
ਲਗਭਗ.
ਵੱਡਾ ਡਾਟਾ / ਮਲਟੀ-ਪ੍ਰੋਸੈਸਿੰਗ
ਹੌਲੀ
ਬਹੁਤ ਤੇਜ਼
ਦਸ਼ਮਲਵ ਨਾਲ ਨਤੀਜਾ ਕਾਫੀ ਹੈ
-
ਅਨੁਕੂਲ
ਇੱਕ ਚੰਗਾ ਪ੍ਰੈਕਟੀਸ਼ਨਰ ਦੋਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ: ਜੇ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਪ੍ਰਤੀਕ ਰੂਪ ਵਿੱਚ ਹੱਲ ਕਰੋ, ਜੇ ਨਹੀਂ ਤਾਂ ਸੰਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਜਾਓ, ਅਤੇ ਜਦੋਂ ਵੀ ਸੰਭਵ ਹੋਵੇ ਇੱਕ ਦੂਜੇ ਨਾਲ ਕ੍ਰਾਸ-ਚੈੱਕ ਕਰੋ।
ਕਦਮ ਦਰ ਕਦਮ: AI ਨਾਲ ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰੋ
1. ਸਮੱਸਿਆ ਅਤੇ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਦੀ ਪਛਾਣ ਕਰੋ। "ਕਿੰਨੇ ਦਸ਼ਮਲਵ ਸਥਾਨ?" ਅਤੇ "ਕਿਹੜੀ ਸੀਮਾ ਵਿੱਚ?" ਆਪਣੇ ਸਵਾਲਾਂ ਨੂੰ ਸਪੱਸ਼ਟ ਕਰੋ।
2. AI ਨੂੰ ਕੋਡ ਲਿਖੋ, ਆਉਟਪੁੱਟ ਨਹੀਂ। ਯੂਨਿਟ 4 ਤੋਂ ਯਾਦ ਰੱਖੋ: ਏਆਈ ਨੂੰ ਕੋਡ ਆਉਟਪੁੱਟ ਦੀ ਭਵਿੱਖਬਾਣੀ ਨਾ ਕਰੋ। ਤੁਸੀਂ ਕੋਡ ਚਲਾਓ।
3. ਕੋਡ ਨੂੰ ਪੜ੍ਹੋ ਅਤੇ ਸਮਝੋ। ਤਿਆਰ ਕੋਡ ਲਾਈਨ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਸਮਝੋ। ਸਹੀ ਲਾਇਬ੍ਰੇਰੀ, ਸਹੀ ਫੰਕਸ਼ਨ, ਸਹੀ ਪੈਰਾਮੀਟਰ? ਉਹ ਕੋਡ ਨਾ ਚਲਾਓ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਸਮਝਦੇ।
4. ਕਿਸੇ ਜਾਣੀ-ਪਛਾਣੀ ਸਥਿਤੀ ਨਾਲ ਟੈਸਟ ਕਰੋ। ਇੱਕ ਸਧਾਰਨ ਇਨਪੁਟ ਨਾਲ ਕੋਡ ਨੂੰ ਅਜ਼ਮਾਓ ਜਿਸਦਾ ਜਵਾਬ ਤੁਸੀਂ ਪਹਿਲਾਂ ਹੀ ਜਾਣਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, sin(0)=0, ਜਿਵੇਂ ਕਿ ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ ਅਖੰਡ ਦਾ ਮੁੱਲ। ਜੇਕਰ ਕੋਡ ਇਸ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇਸ 'ਤੇ ਜ਼ਿਆਦਾ ਭਰੋਸਾ ਕਰੋਗੇ।
5. ਚਿੰਨ੍ਹਾਤਮਕ ਤੌਰ 'ਤੇ ਜਾਂ ਹੱਥੀਂ ਜਾਂਚ ਕਰੋ। ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ, ਤਾਂ SymPy ਜਾਂ ਮੈਨੁਅਲ ਪਹੁੰਚ ਨਾਲ ਉਸੇ ਨਤੀਜੇ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
6. ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਟਰੈਪ ਤੋਂ ਸਾਵਧਾਨ ਰਹੋ। == ਨਾਲ ਸਖ਼ਤ ਸਮਾਨਤਾ ਦੀ ਬਜਾਏ, abs(a - b) < 1e-9 ਵਰਗੀਆਂ ਸਹਿਣਸ਼ੀਲਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਸੰਕੇਤ: ਹਮੇਸ਼ਾਂ ਇੱਕ ਸੰਖਿਆਤਮਕ ਕੋਡ ਦੀ ਜਾਂਚ ਕਰੋ "ਉਸ ਜਵਾਬ ਦੇ ਨਾਲ ਜੋ ਤੁਸੀਂ ਜਾਣਦੇ ਹੋ"। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਰੂਟ ਖੋਜਕਰਤਾ ਲਿਖਿਆ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ ਰੂਟ (x=±2) ਵਾਲੇ ਸਮੀਕਰਨ 'ਤੇ ਲਾਗੂ ਕਰੋ, ਜਿਵੇਂ ਕਿ x²−4=0। ਜੇਕਰ ਕੋਡ ਨੂੰ ਇਹ ਸਹੀ ਲੱਗਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਹਨਾਂ ਸਮੀਕਰਨਾਂ 'ਤੇ ਭਰੋਸੇਯੋਗ ਹੋਣ ਦੀ ਜ਼ਿਆਦਾ ਸੰਭਾਵਨਾ ਬਣ ਜਾਂਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਬਾਰੇ ਤੁਸੀਂ ਨਹੀਂ ਜਾਣਦੇ ਹੋ। ਇਹ "ਸੈਨੀਟੀ ਚੈਕ" ਸਭ ਤੋਂ ਸਸਤਾ ਤਸਦੀਕ ਹੈ।
ਸੰਖਿਆਤਮਕ ਕੈਲਕੂਲਸ ਦਾ ਨੁਕਸਾਨ: ਕਨਵਰਜੈਂਸ ਅਤੇ ਗਲਤੀ ਇਕੱਠਾ ਕਰਨਾ।
ਜ਼ਿਆਦਾਤਰ ਸੰਖਿਆਤਮਕ ਵਿਧੀਆਂ ਦੁਹਰਾਓ ਨਾਲ ਕੰਮ ਕਰਦੀਆਂ ਹਨ: ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ ਤੋਂ ਸ਼ੁਰੂ ਕਰਕੇ ਅਤੇ ਹੌਲੀ ਹੌਲੀ ਅਸਲ ਜਵਾਬ ਤੱਕ ਪਹੁੰਚਣਾ। ਨੇੜੇ ਆਉਣ ਦੀ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਨਵਰਜੈਂਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਪਰ ਹਰ ਦੁਹਰਾਓ ਵਿਧੀ ਹਮੇਸ਼ਾ ਇਕਸਾਰ ਨਹੀਂ ਹੁੰਦੀ; ਕੁਝ ਵੱਖ ਹੋ ਜਾਂਦੇ ਹਨ (ਨਤੀਜੇ ਤੋਂ ਦੂਰ ਚਲੇ ਜਾਂਦੇ ਹਨ) ਜਾਂ ਇੱਕ ਗਲਤ ਮੁੱਲ ਵਿੱਚ ਬਦਲ ਜਾਂਦੇ ਹਨ। ਜੇਕਰ ਇੱਕ AI-ਤਿਆਰ ਕੋਡ ਇਹ ਜਾਂਚ ਨਹੀਂ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਿਧੀ ਕਨਵਰਜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਇਹ ਚੁੱਪਚਾਪ ਤੁਹਾਨੂੰ ਇੱਕ ਗਲਤ ਨੰਬਰ ਦੇ ਸਕਦਾ ਹੈ। ਇਸ ਲਈ ਸਿਰਫ ਕਿਉਂਕਿ ਇੱਕ ਸੰਖਿਆਤਮਕ ਨਤੀਜਾ "ਇੱਕ ਸੰਖਿਆ ਪੈਦਾ ਕਰਦਾ ਹੈ" ਇਸਨੂੰ ਸੱਚ ਨਹੀਂ ਬਣਾਉਂਦਾ; ਇਹ ਪੁਸ਼ਟੀ ਕਰਨਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਉਹ ਸੰਖਿਆ ਅਸਲ ਵਿੱਚ ਮੰਗੇ ਗਏ ਹੱਲ ਵਿੱਚ ਕਨਵਰਜ ਕਰਦੀ ਹੈ।
ਇੱਕ ਦੂਸਰੀ ਸੂਖਮਤਾ ਹੈ ਗਲਤੀ ਇਕੱਠਾ ਕਰਨਾ। ਗਣਨਾਵਾਂ ਦੀ ਇੱਕ ਲੰਬੀ ਲੜੀ ਵਿੱਚ, ਹਰ ਪੜਾਅ 'ਤੇ ਛੋਟੀਆਂ ਫਲੋਟਿੰਗ-ਪੁਆਇੰਟ ਰਾਊਂਡਿੰਗ ਗਲਤੀਆਂ ਇਕੱਠੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਵੱਡੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ; ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਤੁਸੀਂ ਦੋ ਬਹੁਤ ਹੀ ਨਜ਼ਦੀਕੀ ਵੱਡੀਆਂ ਸੰਖਿਆਵਾਂ ਦੇ ਅੰਤਰ ਨੂੰ ਲੈਂਦੇ ਹੋ (ਇਸ ਨੂੰ ਵਿਨਾਸ਼ਕਾਰੀ ਰੱਦ ਕਰਨਾ ਕਿਹਾ ਜਾਂਦਾ ਹੈ), ਨਤੀਜੇ ਦੇ ਮਹੱਤਵਪੂਰਨ ਅੰਕ ਗੁਆ ਸਕਦੇ ਹਨ। ਨਕਲੀ ਬੁੱਧੀ ਹਮੇਸ਼ਾ ਅਜਿਹੀਆਂ ਸੰਖਿਆਤਮਕ ਸਥਿਰਤਾ ਸਮੱਸਿਆਵਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਨਾਜ਼ੁਕ ਗਣਨਾਵਾਂ ਵਿੱਚ, ਨਤੀਜੇ ਦੀ ਮੁੜ ਗਣਨਾ ਅਤੇ ਤੁਲਨਾ ਇੱਕ ਵੱਖਰੇ ਢੰਗ ਨਾਲ ਜਾਂ ਉੱਚ ਸਟੀਕਸ਼ਨ ਨਾਲ ਲੁਕੀ ਹੋਈ ਗਲਤੀ ਨੂੰ ਪ੍ਰਗਟ ਕਰਦੀ ਹੈ।
ਧਿਆਨ ਦਿਓ: ਇੱਕ ਸੰਖਿਆਤਮਕ ਵਿਧੀ ਦੇ "ਨਤੀਜਾ ਦੇਣਾ" ਅਤੇ "ਸਹੀ ਨਤੀਜੇ ਨੂੰ ਕਨਵਰਟ ਕਰਨਾ" ਦੋ ਵੱਖ-ਵੱਖ ਚੀਜ਼ਾਂ ਹਨ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੋਡ ਵਿੱਚ ਇੱਕ ਕਨਵਰਜੈਂਸ ਜਾਂਚ ਸ਼ਾਮਲ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਦੋ ਲਗਾਤਾਰ ਪੜਾਵਾਂ ਵਿੱਚ ਅੰਤਰ ਕਾਫ਼ੀ ਛੋਟਾ ਹੋ ਜਾਂਦਾ ਹੈ); ਜੇ ਇਸ ਵਿੱਚ ਇਹ ਸ਼ਾਮਲ ਨਹੀਂ ਹੈ, ਤਾਂ ਨਕਲੀ ਬੁੱਧੀ ਨੂੰ ਇਸ ਨਿਯੰਤਰਣ ਨੂੰ ਜੋੜੋ।
ਤਿੰਨ ਛੋਟੇ ਕੇਸ
ਕੇਸ 1 - ਗਲਤ ਫੰਕਸ਼ਨ ਚੋਣ। ਇੱਕ ਵਿਦਿਆਰਥੀ ਨੇ ਇੱਕ ਫੰਕਸ਼ਨ ਦਾ ਰੂਟ ਲੱਭਣ ਲਈ AI ਤੋਂ ਕੋਡ ਮੰਗਿਆ। AI ਨੇ scipy.optimize.fsolve ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਪਰ ਇੱਕ ਗਲਤ ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ ਚੁਣਿਆ ਅਤੇ ਗਲਤ ਰੂਟ ਵਿੱਚ ਬਦਲ ਗਿਆ। ਵਿਦਿਆਰਥੀ ਨੇ ਪਹਿਲਾਂ ਫੰਕਸ਼ਨ ਨੂੰ ਗ੍ਰਾਫਿੰਗ ਕਰਕੇ (ਵੇਖੋ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਯੂਨਿਟ) ਦੀ ਜਾਂਚ ਕੀਤੀ, ਸਹੀ ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ ਲਗਾਇਆ, ਅਤੇ ਅਸਲ ਜੜ੍ਹ ਲੱਭੀ। ਪਾਠ: ਸੰਖਿਆਤਮਕ ਮੂਲ ਖੋਜਕਰਤਾ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਲਈ ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੇ ਹਨ।
ਕੇਸ 2 - ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਟਰੈਪ। ਇੱਕ ਇੰਜਨੀਅਰ ਨੇ ਇੱਕ ਏਆਈ ਕੋਡ ਚਲਾਇਆ ਜਿਸ ਵਿੱਚ ਲਿਖਿਆ ਸੀ if 0.1 + 0.2 == 0.3: ਅਤੇ ਮਹਿਸੂਸ ਕੀਤਾ ਕਿ ਸਥਿਤੀ ਕਦੇ ਵੀ ਸੱਚ ਨਹੀਂ ਸੀ। ਏਆਈ ਨੇ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਸ਼ੁੱਧਤਾ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਕੀਤਾ ਸੀ। ਕੋਡ ਨੂੰ abs((0.1+0.2) - 0.3) < 1e-9 ਨਾਲ ਠੀਕ ਕੀਤਾ ਗਿਆ ਸੀ। 1e-9 ਦਾ ਮਤਲਬ ਹੈ "ਦਸ ਤੋਂ ਮਾਇਨਸ ਨੌ", ਇੱਕ ਬਹੁਤ ਹੀ ਛੋਟੀ ਸਹਿਣਸ਼ੀਲਤਾ।
ਕੇਸ 3 - ਆਮ ਸਮਝ ਟੈਸਟਿੰਗ ਨੇ ਬੱਗ ਨੂੰ ਫੜ ਲਿਆ। ਇੱਕ ਅਧਿਆਪਕ ਨੇ scipy.integrate.quad ਤੋਂ ਕੋਡ ਪ੍ਰਾਪਤ ਕੀਤਾ ਜੋ ਸੰਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਇੱਕ ਨਿਸ਼ਚਿਤ ਇੰਟੈਗਰਲ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ। ਉਸਨੇ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਇੰਟੀਗ੍ਰੇਲ ਜਿਵੇਂ ਕਿ ∫₀¹ x dx = 0.5 ਨਾਲ ਟੈਸਟ ਕੀਤਾ; ਕੋਡ ਨੇ 0.5 ਦਿੱਤਾ ਹੈ। ਫਿਰ ਉਸਨੇ ਅਸਲ ਇੰਟੈਗਰਲ ਦੀ ਗਣਨਾ ਕੀਤੀ ਅਤੇ SymPy ਨਾਲ ਨਤੀਜੇ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ. ਉਸ ਨੇ ਭਰੋਸਾ ਕੀਤਾ ਜਦੋਂ ਦੋ ਸੁਤੰਤਰ ਢੰਗਾਂ ਨੇ ਇੱਕੋ ਨਤੀਜਾ ਦਿੱਤਾ. ਕੁੱਲ ਸਮਾਂ: 6 ਮਿੰਟ।
ਚਾਰ ਕਾਪੀ ਕਰਨ ਯੋਗ ਟੈਂਪਲੇਟ
1) ਇੱਕ ਸੰਖਿਆਤਮਕ ਖਾਤਾ ਕੋਡ ਦੀ ਬੇਨਤੀ ਕਰਨਾ:
ਪਾਈਥਨ ਕੋਡ ਲਿਖੋ ਜੋ ਹੇਠਾਂ ਦਿੱਤੀ ਸਮੱਸਿਆ ਨੂੰ ਸੰਖਿਆਤਮਕ ਤੌਰ 'ਤੇ ਹੱਲ ਕਰਦਾ ਹੈ: [ਸਮੱਸਿਆ]। NumPy/SciPy ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸੰਵੇਦਨਸ਼ੀਲਤਾ: [ਉਦਾ. 6 ਦਸ਼ਮਲਵ]। ਮੈਂ ਕੋਡ ਚਲਾਵਾਂਗਾ; ਆਉਟਪੁੱਟ ਦੀ ਭਵਿੱਖਬਾਣੀ. ਇੱਕ ਟਿੱਪਣੀ ਲਾਈਨ ਵਿੱਚ ਸੰਖੇਪ ਵਿੱਚ ਦੱਸੋ ਕਿ ਤੁਸੀਂ ਕਿਹੜਾ ਫੰਕਸ਼ਨ ਚੁਣਿਆ ਹੈ ਅਤੇ ਕਿਉਂ।
2) ਇੱਕ ਆਮ ਸਮਝ ਟੈਸਟ ਜੋੜਨਾ:
ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਦੀ ਸ਼ੁੱਧਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸ ਵਿੱਚ ਇੱਕ ਆਮ ਸਮਝ ਦੀ ਜਾਂਚ ਸ਼ਾਮਲ ਕਰੋ: ਇਸਨੂੰ ਇੱਕ ਸਧਾਰਨ ਇਨਪੁਟ ਨਾਲ ਅਜ਼ਮਾਓ ਜਿੱਥੇ ਜਵਾਬ ਪਹਿਲਾਂ ਹੀ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ (ਜਿਵੇਂ ਕਿ x²-4=0 ਲਈ ਰੂਟ ±2) ਅਤੇ ਜਾਂਚ ਕਰੋ ਕਿ ਇਹ ਸੰਭਾਵਿਤ ਨਤੀਜਾ ਦਿੰਦਾ ਹੈ। ਕੋਡ: [ਇੱਥੇ]
3) ਪ੍ਰਤੀਕ-ਸੰਖਿਆਤਮਕ ਕਰਾਸ-ਚੈੱਕ:
ਕੋਡ ਲਿਖੋ ਜੋ SymPy (ਸਿੰਬੋਲਿਕ) ਅਤੇ SciPy (ਸੰਖਿਆਤਮਕ): [ਸਮੱਸਿਆ] ਦੇ ਨਾਲ ਹੇਠਾਂ ਦਿੱਤੇ ਅਟੁੱਟ/ਸਮੀਕਰਨ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ। ਦੋ ਨਤੀਜਿਆਂ ਨੂੰ ਛਾਪੋ ਤਾਂ ਜੋ ਮੈਂ ਉਹਨਾਂ ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਾਂ। ਇੱਕ ਲਾਈਨ ਜੋੜੋ ਜੋ abs() ਨਾਲ ਅੰਤਰਾਂ ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ।
4) ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਸੁਰੱਖਿਆ:
ਇਸ ਕੋਡ ਵਿੱਚ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਨੰਬਰ ਦੀ ਤੁਲਨਾ ਦੀ ਸਮੀਖਿਆ ਕਰੋ। ਜੇਕਰ ਸਖ਼ਤ '==' ਸਮਾਨਤਾਵਾਂ ਹਨ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਇੱਕ ਢੁਕਵੀਂ ਸਹਿਣਸ਼ੀਲਤਾ (abs(a-b) < 1e-9) ਨਾਲ ਬਦਲੋ ਅਤੇ ਇਸਦਾ ਕਾਰਨ ਦੱਸੋ। ਕੋਡ: [ਇੱਥੇ]
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਕਮਜ਼ੋਰ: "ਇਸ ਸਮੀਕਰਨ ਦਾ ਮੂਲ ਲੱਭੋ: x³ − 2x − 5 = 0। ਜਵਾਬ ਲਿਖੋ।"
ਨਤੀਜਾ: AI ਦਸ਼ਮਲਵ ਸੰਖਿਆ ਨੂੰ ਫਿੱਟ ਕਰਦਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ "2.0946...")। ਇਹ ਸੱਚ ਹੋ ਸਕਦਾ ਹੈ ਜਾਂ ਨਹੀਂ; ਇਹ ਤਸਦੀਕ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ ਕਿਉਂਕਿ ਇਹ ਚਲਾਇਆ ਨਹੀਂ ਗਿਆ ਹੈ।
ਸ਼ਕਤੀਸ਼ਾਲੀ: "ਇੱਕ ਕੋਡ ਲਿਖੋ ਜੋ SciPy ਦੇ ਨਾਲ ਸਮੀਕਰਨ x³ − 2x − 5 = 0 ਦਾ ਅਸਲ ਮੂਲ ਲੱਭਦਾ ਹੈ। ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ ਲਈ, ਪਹਿਲਾਂ ਅੰਤਰਾਲ ਦਿਓ ਜਿੱਥੇ ਫੰਕਸ਼ਨ ਚਿੰਨ੍ਹ ਬਦਲਦਾ ਹੈ। ਇੱਕ ਲਾਈਨ ਜੋੜੋ ਜੋ ਰੂਟ ਨੂੰ ਬਦਲਦੀ ਹੈ ਅਤੇ ਜਾਂਚ ਕਰਦੀ ਹੈ ਕਿ ਨਤੀਜਾ ~0 ਹੈ। ਮੈਂ ਆਉਟਪੁੱਟ ਦੇਖਾਂਗਾ।"
ਨਤੀਜਾ: ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਕੋਡ, ਸਹੀ ਸ਼ੁਰੂਆਤੀ ਅਨੁਮਾਨ, ਬਿਲਟ-ਇਨ ਹੈਸ਼। ਰੂਟ ਦੀ ਵੈਧਤਾ ਸਾਬਤ ਹੁੰਦੀ ਹੈ.
ਆਮ ਗਲਤੀਆਂ
- ਕੋਡ ਚਲਾਏ ਬਿਨਾਂ ਨਤੀਜੇ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ। ਸੰਖਿਆਤਮਕ ਆਉਟਪੁੱਟ ਜਿਸਦੀ AI "ਅਨੁਮਾਨਤ ਕਰਦਾ ਹੈ" ਪ੍ਰਮਾਣਿਕਤਾ ਨਹੀਂ ਹੈ।
- `==` ਨਾਲ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਸਮਾਨਤਾ ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ। ਇਹ ਲਗਭਗ ਹਮੇਸ਼ਾ ਗਲਤ ਹੈ; ਸਹਿਣਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕਰੋ।
- ਮਾੜੀ ਸ਼ੁਰੂਆਤੀ ਭਵਿੱਖਬਾਣੀ। ਸੰਖਿਆਤਮਕ ਰੂਟ/ਓਪਟੀਮਾਈਜੇਸ਼ਨ ਵਿਧੀਆਂ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਲਈ ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੀਆਂ ਹਨ; ਇਹ ਗਲਤ ਰੂਟ ਵਿੱਚ ਬਦਲ ਸਕਦਾ ਹੈ।
- ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਦਾ ਪ੍ਰਗਟਾਵਾ ਨਹੀਂ ਕਰ ਰਿਹਾ। "ਕਿੰਨੇ ਕਦਮ?" ਜੇ ਨਹੀਂ ਪੁੱਛਿਆ ਗਿਆ, ਤਾਂ ਨਤੀਜਾ ਲੋੜ ਮੁਤਾਬਕ ਨਹੀਂ ਹੋ ਸਕਦਾ।
- ਆਮ ਸਮਝ ਦਾ ਟੈਸਟ ਨਹੀਂ ਲੈਣਾ। ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ ਇਨਪੁਟ ਨਾਲ ਇਸਦੀ ਜਾਂਚ ਕੀਤੇ ਬਿਨਾਂ ਕਿਸੇ ਅਸਲ ਸਮੱਸਿਆ 'ਤੇ ਕੋਡ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਜੋਖਮ ਭਰਿਆ ਹੁੰਦਾ ਹੈ।
- ਕੋਡ ਨੂੰ ਸਮਝੇ ਬਿਨਾਂ ਚਲਾ ਰਿਹਾ ਹੈ। ਉਹ ਕੋਡ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਸਮਝਦੇ ਹੋ ਸ਼ਾਇਦ ਗਲਤ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੋਵੇ; ਹਰ ਲਾਈਨ ਨੂੰ ਸਮਝੋ.
ਸਾਵਧਾਨ: ਸੰਖਿਆਤਮਕ ਨਤੀਜੇ ਹਮੇਸ਼ਾ ਅਨੁਮਾਨਿਤ ਹੁੰਦੇ ਹਨ। "ਨਤੀਜਾ ਬਿਲਕੁਲ ਇਹੋ ਹੈ" ਕਹਿਣ ਦੀ ਬਜਾਏ, "ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ" ਕਹੋ। ਕਿਸੇ ਇੰਜੀਨੀਅਰਿੰਗ ਜਾਂ ਵਿਗਿਆਨਕ ਰਿਪੋਰਟ ਵਿੱਚ, ਵਰਤੀ ਗਈ ਵਿਧੀ ਅਤੇ ਸ਼ੁੱਧਤਾ ਨੂੰ ਦਰਸਾਉਣਾ ਸ਼ੁੱਧਤਾ ਦਾ ਹਿੱਸਾ ਹੈ। ਅੰਦਾਜ਼ਨ ਨਤੀਜੇ ਨੂੰ ਨਿਸ਼ਚਿਤ ਵਜੋਂ ਪੇਸ਼ ਕਰਨਾ ਗੁੰਮਰਾਹਕੁੰਨ ਹੈ।
ਸੰਖੇਪ ਵਿੱਚ
ਸੰਖਿਆਤਮਕ ਕੈਲਕੂਲਸ ਉਹਨਾਂ ਸਮੱਸਿਆਵਾਂ ਲਈ ਅਨੁਮਾਨਿਤ ਪਰ ਵਿਹਾਰਕ ਨਤੀਜੇ ਦਿੰਦਾ ਹੈ ਜੋ ਬੰਦ ਫਾਰਮੂਲੇ ਦੁਆਰਾ ਹੱਲ ਨਹੀਂ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ; ਪਾਈਥਨ ਵਿੱਚ, ਇਸਦੇ ਟੂਲ NumPy ਅਤੇ SciPy ਹਨ। AI ਇਹਨਾਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਤੇਜ਼ੀ ਨਾਲ ਕੋਡ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ, ਇਸਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਸਮਝਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਜਾਣੇ-ਪਛਾਣੇ ਇਨਪੁਟ ਨਾਲ ਇਸਦੀ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ। ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਸ਼ੁੱਧਤਾ ਨਾਲ ਸਾਵਧਾਨ ਰਹੋ: ਸਹੀ ਸਮਾਨਤਾ ਦੀ ਬਜਾਏ ਸਹਿਣਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜੇ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਪ੍ਰਤੀਕਾਤਮਕ ਅਤੇ ਸੰਖਿਆਤਮਕ ਤਰੀਕਿਆਂ ਦੀ ਕਰਾਸ-ਚੈੱਕ ਕਰੋ। ਆਮ ਸੂਝ ਦੀ ਜਾਂਚ ਅਤੇ ਬਦਲ ਸਭ ਤੋਂ ਸਸਤੇ ਅਤੇ ਸਭ ਤੋਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਤਸਦੀਕ ਹਨ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਇੱਕ ਸਮੱਸਿਆ ਚੁਣੋ ਜਿਸਨੂੰ ਇੱਕ ਬੰਦ ਫਾਰਮੂਲੇ ਨਾਲ ਹੱਲ ਕਰਨਾ ਔਖਾ ਹੈ (ਉਦਾਹਰਨ ਲਈ, ਮੂਲ x³ − 2x − 5 = 0, ਜਾਂ ਇੱਕ ਗੈਰ-ਐਲੀਮੈਂਟਰੀ ਇੰਟੀਗਰਲ ਦਾ ਨਿਸ਼ਚਿਤ ਮੁੱਲ)। AI ਨੂੰ ਸੰਖਿਆਤਮਕ ਕੋਡ ਅਤੇ, ਜੇ ਸੰਭਵ ਹੋਵੇ, ਟੈਂਪਲੇਟ 1 ਅਤੇ 3 ਦੇ ਨਾਲ ਪ੍ਰਤੀਕ-ਸੰਖਿਆਤਮਕ ਕਰਾਸ-ਚੈੱਕ ਕੋਡ ਦੋਨੋ ਪ੍ਰਿੰਟ ਕਰੋ। ਕੋਡ ਨੂੰ ਇੱਕ ਅਸਲੀ ਪਾਈਥਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਚਲਾਓ। ਪਹਿਲਾਂ ਕਿਸੇ ਜਾਣੇ-ਪਛਾਣੇ ਇੰਪੁੱਟ ਨਾਲ ਇੱਕ ਆਮ ਸਮਝ ਟੈਸਟ ਕਰੋ, ਫਿਰ ਅਸਲ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰੋ। ਜੇਕਰ ਕੋਈ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਤੁਲਨਾ ਹੈ ਤਾਂ ਸਹਿਣਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ। ਇਸਦੀ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਦੇ ਨਾਲ ਨਤੀਜਾ ਨੋਟ ਕਰੋ।
ਚੈੱਕਲਿਸਟ
- [ ] ਮੈਂ ਸਮੱਸਿਆ ਅਤੇ ਲੋੜੀਂਦੀ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਦੀ ਪਛਾਣ ਕੀਤੀ ਹੈ।
- [ ] ਮੈਂ ਏਆਈ ਲਾਈਨ ਦੁਆਰਾ ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਲਾਈਨ ਦੁਆਰਾ ਪੜ੍ਹਿਆ ਅਤੇ ਸਮਝਿਆ।
- [ ] ਮੈਂ ਇੱਕ ਅਸਲੀ ਪਾਈਥਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੋਡ ਚਲਾਇਆ.
- [ ] ਮੈਂ ਇੱਕ ਜਾਣੇ-ਪਛਾਣੇ ਇੰਪੁੱਟ ਦੇ ਨਾਲ ਇੱਕ ਆਮ ਸਮਝ ਟੈਸਟ ਕੀਤਾ।
- ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਮੈਂ ਇੱਕ ਪ੍ਰਤੀਕਾਤਮਕ/ਮੈਨੂਅਲ ਕਰਾਸ-ਚੈੱਕ ਜੋੜਿਆ ਹੈ।
- ਮੈਂ ਫਲੋਟਿੰਗ ਪੁਆਇੰਟ ਤੁਲਨਾਵਾਂ ਵਿੱਚ ਸਹਿਣਸ਼ੀਲਤਾ ਦੀ ਵਰਤੋਂ ਕੀਤੀ।