ਇਹ ਲੇਖ ਪਾਈਥਨ ਗੇਟਵੇ ਬਾਰੇ ਹੈ, ਇੰਟਰਸਿਸਟਮ IRIS ਡੇਟਾ ਪਲੇਟਫਾਰਮ ਲਈ ਇੱਕ ਓਪਨ ਸੋਰਸ ਕਮਿਊਨਿਟੀ ਪ੍ਰੋਜੈਕਟ। ਇਹ ਪ੍ਰੋਜੈਕਟ ਤੁਹਾਨੂੰ ਪਾਈਥਨ (ਬਹੁਤ ਸਾਰੇ ਡੇਟਾ ਵਿਗਿਆਨੀਆਂ ਲਈ ਮੁੱਖ ਵਾਤਾਵਰਣ) ਵਿੱਚ ਬਣਾਏ ਗਏ ਕਿਸੇ ਵੀ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਐਲਗੋਰਿਦਮ ਨੂੰ ਆਰਕੈਸਟਰੇਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਇੰਟਰਸਿਸਟਮ IRIS ਪਲੇਟਫਾਰਮ 'ਤੇ ਤੇਜ਼ੀ ਨਾਲ ਅਨੁਕੂਲ, ਰੋਬੋਟਿਕ ਵਿਸ਼ਲੇਸ਼ਣਾਤਮਕ AI/ML ਹੱਲ ਬਣਾਉਣ ਲਈ ਕਈ ਤਿਆਰ-ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਦਿਖਾਵਾਂਗਾ ਕਿ ਕਿਵੇਂ InterSystems IRIS ਪਾਈਥਨ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਆਰਕੇਸਟ੍ਰੇਟ ਕਰ ਸਕਦਾ ਹੈ, ਕੁਸ਼ਲਤਾ ਨਾਲ ਦੋ-ਪੱਖੀ ਡੇਟਾ ਸੰਚਾਰ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਬੁੱਧੀਮਾਨ ਵਪਾਰਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਣਾ ਸਕਦਾ ਹੈ।

ਯੋਜਨਾ

1. ਜਾਣ ਪਛਾਣ
2. ਸੰਦ।
3. ਇੰਸਟਾਲੇਸ਼ਨ.
4. ਏਪੀਆਈ.
5. ਅੰਤਰ-ਕਾਰਜਸ਼ੀਲਤਾ।
6. ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ।
7. ਸਿੱਟਾ
8. ਲਿੰਕ.
9. MLToolkit.

ਜਾਣ ਪਛਾਣ

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

ਮਸ਼ੀਨ ਲਰਨਿੰਗ (ML) ਨਕਲੀ ਬੁੱਧੀ ਦੇ ਤਰੀਕਿਆਂ ਦੀ ਇੱਕ ਸ਼੍ਰੇਣੀ ਹੈ, ਜਿਸਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਸਮੱਸਿਆ ਦਾ ਸਿੱਧਾ ਹੱਲ ਨਹੀਂ ਹੈ, ਪਰ ਬਹੁਤ ਸਾਰੀਆਂ ਸਮਾਨ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਸਿੱਖਣਾ ਹੈ।

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

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

ਟੂਲ ਵਿਕਸਿਤ ਹੋ ਰਹੇ ਹਨ - ਜਦੋਂ ਕਿ ਸਾਡੇ ਕੋਲ ਪੂਰੀ ਤਰ੍ਹਾਂ GUI-ਕੇਂਦ੍ਰਿਤ AI/ML ਟੂਲ ਨਹੀਂ ਹਨ, ਜੋ ਤਰੱਕੀ ਅਸੀਂ ਸੂਚਨਾ ਪ੍ਰਣਾਲੀਆਂ ਦੀਆਂ ਕਈ ਹੋਰ ਸ਼੍ਰੇਣੀਆਂ, ਜਿਵੇਂ ਕਿ BI (ਕੋਡ ਲਿਖਣ ਤੋਂ ਲੈ ਕੇ ਫਰੇਮਵਰਕ ਅਤੇ GUI-ਕੇਂਦ੍ਰਿਤ ਸੰਰਚਨਾ ਯੋਗ ਹੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਤੱਕ) ਦੇ ਨਾਲ ਵੇਖੀ ਹੈ, ਹੈ। AI/ML ਬਣਾਉਣ ਲਈ ਟੂਲਸ ਵਿੱਚ ਵੀ ਦੇਖਿਆ ਗਿਆ। ਅਸੀਂ ਕੋਡ ਲਿਖਣ ਦੇ ਪੜਾਅ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਪਾਸ ਕਰ ਚੁੱਕੇ ਹਾਂ ਅਤੇ ਅੱਜ ਅਸੀਂ ਮਾਡਲਾਂ ਨੂੰ ਬਣਾਉਣ ਅਤੇ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਫਰੇਮਵਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।

ਹੋਰ ਸੁਧਾਰ, ਜਿਵੇਂ ਕਿ ਪੂਰਵ-ਸਿਖਿਅਤ ਮਾਡਲ ਨੂੰ ਵੰਡਣ ਦੀ ਯੋਗਤਾ ਜਿੱਥੇ ਅੰਤਮ ਉਪਭੋਗਤਾ ਨੂੰ ਸਿਰਫ਼ ਆਪਣੇ ਖਾਸ ਡੇਟਾ 'ਤੇ ਮਾਡਲ ਦੀ ਸਿਖਲਾਈ ਪੂਰੀ ਕਰਨੀ ਪੈਂਦੀ ਹੈ, ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਨਾਲ ਸ਼ੁਰੂਆਤ ਕਰਨਾ ਵੀ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ। ਇਹ ਤਰੱਕੀ ਆਮ ਤੌਰ 'ਤੇ ਪੇਸ਼ੇਵਰਾਂ ਅਤੇ ਕੰਪਨੀਆਂ ਦੋਵਾਂ ਲਈ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਨੂੰ ਬਹੁਤ ਆਸਾਨ ਬਣਾਉਂਦੀ ਹੈ।

ਦੂਜੇ ਪਾਸੇ, ਅਸੀਂ ਜ਼ਿਆਦਾ ਤੋਂ ਜ਼ਿਆਦਾ ਡਾਟਾ ਇਕੱਠਾ ਕਰ ਰਹੇ ਹਾਂ। InterSystems IRIS ਵਰਗੇ ਯੂਨੀਫਾਈਡ ਡੇਟਾ ਪਲੇਟਫਾਰਮ ਦੇ ਨਾਲ, ਇਹ ਸਾਰੀ ਜਾਣਕਾਰੀ ਤੁਰੰਤ ਤਿਆਰ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲਾਂ ਲਈ ਇਨਪੁਟ ਵਜੋਂ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਕਲਾਉਡ 'ਤੇ ਜਾਣ ਦੇ ਨਾਲ, AI/ML ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਲਾਂਚ ਕਰਨਾ ਪਹਿਲਾਂ ਨਾਲੋਂ ਆਸਾਨ ਹੁੰਦਾ ਜਾ ਰਿਹਾ ਹੈ। ਅਸੀਂ ਸਿਰਫ਼ ਲੋੜੀਂਦੇ ਸਾਧਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਕਲਾਉਡ ਪਲੇਟਫਾਰਮਾਂ ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤੇ ਸਮਾਨਤਾ ਲਈ ਧੰਨਵਾਦ, ਅਸੀਂ ਬਿਤਾਏ ਸਮੇਂ ਨੂੰ ਬਚਾ ਸਕਦੇ ਹਾਂ।

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

ML ਟੂਲਕਿੱਟ ਟੂਲਜ਼ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਜਿਸਦਾ ਉਦੇਸ਼ ਸਿਰਫ਼ ਇਹ ਕਰਨਾ ਹੈ: ਮਾਡਲਾਂ ਅਤੇ ਇੱਕ ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਵਾਤਾਵਰਨ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਨਾ ਤਾਂ ਜੋ ਬਿਲਟ ਮਾਡਲਾਂ ਨੂੰ ਤੁਹਾਡੀਆਂ ਵਪਾਰਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕੇ। ਪਾਈਥਨ ਗੇਟਵੇ ML ਟੂਲਕਿੱਟ ਦਾ ਹਿੱਸਾ ਹੈ ਅਤੇ ਪਾਈਥਨ ਭਾਸ਼ਾ ਨਾਲ ਏਕੀਕਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (ਇਸੇ ਤਰ੍ਹਾਂ ਕਿ ਕਿਵੇਂ R ਗੇਟਵੇ, ML ਟੂਲਕਿੱਟ ਦਾ ਹਿੱਸਾ ਹੋਣ ਕਰਕੇ R ਭਾਸ਼ਾ ਨਾਲ ਏਕੀਕਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ)।

ਸੰਦ

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

ਤਕਨਾਲੋਜੀ ਦੇ

• ਪਾਈਥਨ ਇੱਕ ਵਿਆਖਿਆ ਕੀਤੀ, ਉੱਚ-ਪੱਧਰੀ, ਆਮ-ਉਦੇਸ਼ ਵਾਲੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਹੈ। ਭਾਸ਼ਾ ਦਾ ਮੁੱਖ ਫਾਇਦਾ ਇਸਦੀ ਗਣਿਤ, ਐਮਐਲ ਅਤੇ ਏਆਈ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਿਸ਼ਾਲ ਲਾਇਬ੍ਰੇਰੀ ਹੈ। ਆਬਜੈਕਟ-ਸਕ੍ਰਿਪਟ ਦੀ ਤਰ੍ਹਾਂ, ਇਹ ਇਕ ਵਸਤੂ-ਮੁਖੀ ਭਾਸ਼ਾ ਹੈ, ਪਰ ਹਰ ਚੀਜ਼ ਨੂੰ ਸਥਿਰਤਾ ਦੀ ਬਜਾਏ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ। ਨਾਲ ਹੀ ਹਰ ਚੀਜ਼ ਇੱਕ ਵਸਤੂ ਹੈ। ਬਾਅਦ ਦੇ ਲੇਖ ਭਾਸ਼ਾ ਨਾਲ ਇੱਕ ਗੁਜ਼ਰਦੀ ਜਾਣ ਪਛਾਣ ਮੰਨਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ ਸਿੱਖਣਾ ਸ਼ੁਰੂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੈਂ ਇਸ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦਾ ਹਾਂ ਦਸਤਾਵੇਜ਼.
• ਸਾਡੀਆਂ ਅਗਲੀਆਂ ਅਭਿਆਸਾਂ ਲਈ, ਸੈੱਟ ਕਰੋ ਪਾਈਥਨ 3.6.7 64 ਬਿੱਟ.
• IDE: ਮੈਂ ਵਰਤਦਾ ਹਾਂ PyCharm, ਪਰ ਆਮ ਤੌਰ 'ਤੇ ਉਹ ਬਹੁਤ ਸਾਰਾ. ਜੇਕਰ ਤੁਸੀਂ ਅਟੇਲੀਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਪਾਈਥਨ ਡਿਵੈਲਪਰਾਂ ਲਈ ਇੱਕ ਈਲੈਪਸ ਪਲੱਗਇਨ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ VS ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ Python ਲਈ ਇੱਕ ਐਕਸਟੈਂਸ਼ਨ ਹੈ।
• ਨੋਟਬੁੱਕ: ਇੱਕ IDE ਦੀ ਬਜਾਏ, ਤੁਸੀਂ ਔਨਲਾਈਨ ਨੋਟਬੁੱਕਾਂ ਵਿੱਚ ਆਪਣੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਲਿਖ ਅਤੇ ਸਾਂਝਾ ਕਰ ਸਕਦੇ ਹੋ। ਉਨ੍ਹਾਂ ਵਿਚੋਂ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਹੈ ਜੁਪੀਟਰ.

ਲਾਇਬ੍ਰੇਰੀਆਂ

ਇੱਥੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਇੱਕ (ਗੈਰ-ਸੰਪੂਰਨ) ਸੂਚੀ ਹੈ:

• ਕੱਚਾ — ਸਟੀਕ ਗਣਨਾਵਾਂ ਲਈ ਇੱਕ ਬੁਨਿਆਦੀ ਪੈਕੇਜ।
• ਪਾਂਡਾ - ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੇ ਡੇਟਾ ਢਾਂਚੇ ਅਤੇ ਡੇਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ।
• ਮੈਟਪਲੋਟਲਿਬ - ਗ੍ਰਾਫ ਦੀ ਰਚਨਾ.
• ਸਮੁੰਦਰੀ — matplotlib 'ਤੇ ਆਧਾਰਿਤ ਡਾਟਾ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ।
• ਸਕਲਰਨ - ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਵਿਧੀਆਂ।
• XGBoost — ਗਰੇਡੀਐਂਟ ਬੂਸਟਿੰਗ ਵਿਧੀ ਦੇ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਐਲਗੋਰਿਦਮ।
• ਜੈਨਸਿਮ - ਐਨਐਲਪੀ
• ਕੇਰਸ - ਨਿਊਰਲ ਨੈੱਟਵਰਕ.
• ਟੈਨਸਰਫਲੋ — ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ ਲਈ ਇੱਕ ਪਲੇਟਫਾਰਮ।
• ਪਾਈਟੋਰਚ ਪਾਈਥਨ 'ਤੇ ਕੇਂਦਰਿਤ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣ ਦਾ ਪਲੇਟਫਾਰਮ ਹੈ।
• ਨਯੋਕਾ - ਵੱਖ-ਵੱਖ ਮਾਡਲਾਂ ਤੋਂ ਪੀ.ਐੱਮ.ਐੱਮ.ਐੱਲ.

AI/ML ਤਕਨਾਲੋਜੀਆਂ ਕਾਰੋਬਾਰ ਨੂੰ ਵਧੇਰੇ ਕੁਸ਼ਲ ਅਤੇ ਅਨੁਕੂਲ ਬਣਾਉਂਦੀਆਂ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਅੱਜ ਇਹ ਤਕਨਾਲੋਜੀਆਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨਾ ਅਤੇ ਲਾਗੂ ਕਰਨਾ ਆਸਾਨ ਹੋ ਰਿਹਾ ਹੈ। AI/ML ਤਕਨਾਲੋਜੀਆਂ ਬਾਰੇ ਸਿੱਖਣਾ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਇਹ ਤੁਹਾਡੀ ਸੰਸਥਾ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਕਿਵੇਂ ਮਦਦ ਕਰ ਸਕਦੀਆਂ ਹਨ।

ਸੈਟਿੰਗ

ਪਾਈਥਨ ਗੇਟਵੇ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਅਤੇ ਵਰਤਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ:

• ਓ.ਐੱਸ
  • Windows ਨੂੰ
  • ਲੀਨਕਸ
  • ਮੈਕ
• ਡੌਕਰ
  • DockerHub ਤੋਂ ਇੱਕ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰੋ
  • ਆਪਣੀ ਖੁਦ ਦੀ ਦਿੱਖ ਬਣਾਓ

ਇੰਸਟਾਲੇਸ਼ਨ ਵਿਧੀ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ, ਤੁਹਾਨੂੰ ਸਰੋਤ ਕੋਡ ਦੀ ਲੋੜ ਪਵੇਗੀ। ਕੋਡ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਸਿਰਫ ਜਗ੍ਹਾ ਹੈ ਰੀਲੀਜ਼ ਪੰਨਾ. ਇਸ ਵਿੱਚ ਟੈਸਟ ਕੀਤੇ ਸਥਿਰ ਰੀਲੀਜ਼ ਹਨ, ਬੱਸ ਨਵੀਨਤਮ ਲਓ। ਇਸ ਸਮੇਂ ਇਹ 0.8 ਹੈ, ਪਰ ਸਮੇਂ ਦੇ ਨਾਲ ਨਵੇਂ ਹੋਣਗੇ. ਰਿਪੋਜ਼ਟਰੀ ਨੂੰ ਕਲੋਨ/ਡਾਊਨਲੋਡ ਨਾ ਕਰੋ, ਨਵੀਨਤਮ ਰੀਲੀਜ਼ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ।

ਓ.ਐੱਸ

ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ 'ਤੇ ਪਾਈਥਨ ਗੇਟਵੇ ਨੂੰ ਸਥਾਪਿਤ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਪਹਿਲਾਂ (ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਪਰਵਾਹ ਕੀਤੇ ਬਿਨਾਂ) ਤੁਹਾਨੂੰ ਪਾਇਥਨ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਇਸ ਲਈ:

1. ਪਾਈਥਨ 3.6.7 64 ਬਿੱਟ ਇੰਸਟਾਲ ਕਰੋ. ਪਾਇਥਨ ਨੂੰ ਡਿਫੌਲਟ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਥਾਪਿਤ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
2. ਮੋਡੀਊਲ ਨੂੰ ਇੰਸਟਾਲ ਕਰੋ dill: pip install dill.
3. ਆਬਜੈਕਟ ਸਕ੍ਰਿਪਟ ਕੋਡ ਡਾਊਨਲੋਡ ਕਰੋ (ਜਿਵੇਂ ਕਿ do $system.OBJ.ImportDir("C:InterSystemsReposPythoniscpy", "*.cls", "c",,1)) ਉਤਪਾਦਾਂ ਵਾਲੇ ਕਿਸੇ ਵੀ ਖੇਤਰ ਵਿੱਚ। ਜੇਕਰ ਤੁਸੀਂ ਉਤਪਾਦਾਂ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਮੌਜੂਦਾ ਖੇਤਰ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਚਲਾਓ: write ##class(%EnsembleMgr).EnableNamespace($Namespace, 1).
4. ਸਥਾਨ ਕਾਲਆਊਟ DLL/SO/DYLIB ਫੋਲਡਰ ਵਿੱਚ bin ਤੁਹਾਡੀ ਇੰਟਰਸਿਸਟਮ IRIS ਉਦਾਹਰਣ। ਲਾਇਬ੍ਰੇਰੀ ਫਾਈਲ ਵਾਪਸ ਕੀਤੇ ਮਾਰਗ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ write ##class(isc.py.Callout).GetLib().

Windows ਨੂੰ

1. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਹੈ PYTHONHOME ਪਾਇਥਨ 3.6.7 ਵੱਲ ਪੁਆਇੰਟ ਕਰਦਾ ਹੈ।
2. ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਸਿਸਟਮ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ ਹੈ PATH ਇੱਕ ਵੇਰੀਏਬਲ ਰੱਖਦਾ ਹੈ PYTHONHOME (ਜਾਂ ਡਾਇਰੈਕਟਰੀ ਜਿਸ ਵੱਲ ਇਹ ਸੰਕੇਤ ਕਰਦਾ ਹੈ)।

ਲੀਨਕਸ (ਡੇਬੀਅਨ/ਉਬੰਟੂ)

1. ਜਾਂਚ ਕਰੋ ਕਿ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਹੈ PATH ਸ਼ਾਮਿਲ ਹੈ /usr/lib и /usr/lib/x86_64-linux-gnu. ਫਾਈਲ ਦੀ ਵਰਤੋਂ ਕਰੋ /etc/environment ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰਨ ਲਈ.
2. ਗਲਤੀਆਂ ਦੇ ਮਾਮਲੇ ਵਿੱਚ undefined symbol: _Py_TrueStruct ਸੈਟਿੰਗ ਸੈੱਟ ਕਰੋ PythonLib. ਵਿੱਚ ਵੀ Readme ਇੱਕ ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ ਭਾਗ ਹੈ.

ਮੈਕ

1. ਵਰਤਮਾਨ ਵਿੱਚ ਸਿਰਫ ਪਾਈਥਨ 3.6.7 ਸਮਰਥਿਤ ਹੈ ਪਾਇਥਨ.ਆਰ.. ਵੇਰੀਏਬਲ ਦੀ ਜਾਂਚ ਕਰੋ PATH.

ਜੇਕਰ ਤੁਸੀਂ ਵਾਤਾਵਰਨ ਵੇਰੀਏਬਲ ਬਦਲਦੇ ਹੋ, ਤਾਂ ਆਪਣੇ ਇੰਟਰਸਿਸਟਮ ਉਤਪਾਦ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ।

ਡੌਕਰ

ਕੰਟੇਨਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਕਈ ਫਾਇਦੇ ਹਨ:

• ਪੋਰਟੇਬਿਲਟੀ
• ਪ੍ਰਭਾਵਕਤਾ
• ਇਨਸੂਲੇਸ਼ਨ
• ਹਲਕੀਤਾ
• ਅਸਥਿਰਤਾ

ਇਸ ਦੀ ਜਾਂਚ ਕਰੋ ਲੇਖਾਂ ਦੀ ਲੜੀ ਇੰਟਰਸਿਸਟਮ ਉਤਪਾਦਾਂ ਦੇ ਨਾਲ ਡੌਕਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਬਾਰੇ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਲਈ।

ਸਾਰੇ ਪਾਈਥਨ ਗੇਟਵੇ ਬਿਲਡ ਇਸ ਸਮੇਂ ਕੰਟੇਨਰ ਅਧਾਰਤ ਹਨ 2019.4.

ਤਿਆਰ ਚਿੱਤਰ

ਰਨ: docker run -d -p 52773:52773 --name irispy intersystemscommunity/irispy-community:latestਇੰਟਰਸਿਸਟਮ IRIS ਕਮਿਊਨਿਟੀ ਐਡੀਸ਼ਨ ਦੇ ਨਾਲ ਪਾਈਥਨ ਗੇਟਵੇ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ। ਇਹ ਸਭ ਹੈ.

ਆਪਣੀ ਖੁਦ ਦੀ ਦਿੱਖ ਬਣਾਓ

ਇੱਕ ਡੌਕਰ ਚਿੱਤਰ ਬਣਾਉਣ ਲਈ, ਰਿਪੋਜ਼ਟਰੀ ਦੇ ਰੂਟ ਵਿੱਚ ਚਲਾਓ: docker build --force-rm --tag intersystemscommunity/irispy:latest ..
ਮੂਲ ਰੂਪ ਵਿੱਚ, ਚਿੱਤਰ ਨੂੰ ਚਿੱਤਰ ਦੇ ਅਧਾਰ ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ store/intersystems/iris-community:2019.4.0.383.0, ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਇੱਕ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰਕੇ ਇਸਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ IMAGE.
InterSystems IRIS ਤੋਂ ਬਣਾਉਣ ਲਈ, ਚਲਾਓ: `docker build --build-arg IMAGE=store/intersystems/iris:2019.4.0.383.0 --force-rm --tag intersystemscommunity/irispy:latest "।

ਇਸ ਤੋਂ ਬਾਅਦ ਤੁਸੀਂ ਡੌਕਰ ਚਿੱਤਰ ਚਲਾ ਸਕਦੇ ਹੋ:

docker run -d 
  -p 52773:52773 
  -v /<HOST-DIR-WITH-iris.key>/:/mount 
  --name irispy 
  intersystemscommunity/irispy:latest 
  --key /mount/iris.key

ਜੇਕਰ ਤੁਸੀਂ InterSystems IRIS ਕਮਿਊਨਿਟੀ ਐਡੀਸ਼ਨ 'ਤੇ ਅਧਾਰਿਤ ਇੱਕ ਚਿੱਤਰ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਕੁੰਜੀ ਨੂੰ ਛੱਡ ਸਕਦੇ ਹੋ।

Comments

• ਟੈਸਟ ਪ੍ਰਕਿਰਿਆ isc.py.test.Process ਇੱਕ ਅਸਥਾਈ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਕਈ ਚਿੱਤਰਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਇਸ ਮਾਰਗ ਨੂੰ ਮਾਊਂਟ ਕੀਤੀ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਬਦਲਣਾ ਚਾਹ ਸਕਦੇ ਹੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸੈਟਿੰਗ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰੋ WorkingDir ਮਾਊਂਟ ਕੀਤੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ।
• ਟਰਮੀਨਲ ਰਨ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ: docker exec -it irispy sh.
• ਲੌਗਇਨ ਦੁਆਰਾ ਸਿਸਟਮ ਪ੍ਰਬੰਧਨ ਪੋਰਟਲ ਤੱਕ ਪਹੁੰਚ SuperUser/SYS.
• ਕੰਟੇਨਰ ਨੂੰ ਰੋਕਣ ਲਈ, ਚਲਾਓ: docker stop irispy && docker rm --force irispy.

ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ

ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਪਾਈਥਨ ਗੇਟਵੇ ਨੂੰ ਸਥਾਪਿਤ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਇਹ ਜਾਂਚ ਕਰਨ ਯੋਗ ਹੈ ਕਿ ਇਹ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ। ਇਸ ਕੋਡ ਨੂੰ ਇੰਟਰਸਿਸਟਮ IRIS ਟਰਮੀਨਲ ਵਿੱਚ ਚਲਾਓ:

set sc = ##class(isc.py.Callout).Setup() 
set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).
write var

ਨਤੀਜਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ: HELLO - ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਮੁੱਲ x. ਜੇਕਰ ਵਾਪਸੀ ਸਥਿਤੀ sc ਇੱਕ ਗਲਤੀ ਹੈ ਜਾਂ var ਖਾਲੀ, ਚੈੱਕ ਰੀਡਮੀ - ਸਮੱਸਿਆ ਨਿਪਟਾਰਾ ਸੈਕਸ਼ਨ.

API

ਪਾਈਥਨ ਗੇਟਵੇ ਸਥਾਪਿਤ ਹੈ ਅਤੇ ਤੁਸੀਂ ਪੁਸ਼ਟੀ ਕੀਤੀ ਹੈ ਕਿ ਇਹ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਹ ਇਸਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਸਮਾਂ ਹੈ!
ਪਾਈਥਨ ਦਾ ਮੁੱਖ ਇੰਟਰਫੇਸ ਹੈ isc.py.Main. ਇਹ ਵਿਧੀਆਂ ਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਸਮੂਹਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ (ਸਾਰੇ ਵਾਪਸੀ %Status):

• ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ
• ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ
• ਔਕਸਲੀਰੀ

ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ

ਇਹ ਵਿਧੀਆਂ ਤੁਹਾਨੂੰ ਮਨਮਾਨੇ ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ।

SimpleString

SimpleString - ਇਹ ਮੁੱਖ ਤਰੀਕਾ ਹੈ. ਇਹ 4 ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟਾਂ ਲੈਂਦਾ ਹੈ:

• code - ਚਲਾਉਣ ਲਈ ਕੋਡ ਦੀ ਲਾਈਨ। ਲਾਈਨ ਫੀਡ ਅੱਖਰ: $c(10).
• returnVariable — ਵਾਪਸ ਜਾਣ ਵਾਲੇ ਵੇਰੀਏਬਲ ਦਾ ਨਾਂ।
• serialization - ਸੀਰੀਅਲਾਈਜ਼ ਕਿਵੇਂ ਕਰੀਏ returnVariable. 0 — ਸਤਰ (ਮੂਲ), 1 — ਮੁੜ.
• result — ByRef ਵੇਰੀਏਬਲ ਦਾ ਹਵਾਲਾ ਜਿਸ ਵਿੱਚ ਮੁੱਲ ਲਿਖਿਆ ਗਿਆ ਹੈ returnVariable.

ਉੱਪਰ ਅਸੀਂ ਕੀਤਾ:

set sc = ##class(isc.py.Main).SimpleString("x='HELLO'", "x", , .var).

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ x ਮਤਲਬ Hello ਅਤੇ ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ x ਇੱਕ ObjectScript ਵੇਰੀਏਬਲ ਲਈ var.

ਐਗਜ਼ੀਕਿਊਟ ਕੋਡ

ExecuteCode ਇੱਕ ਸੁਰੱਖਿਅਤ ਅਤੇ ਘੱਟ ਪ੍ਰਤਿਬੰਧਿਤ ਵਿਕਲਪ ਹੈ SimpleString.
InterSystems IRIS ਪਲੇਟਫਾਰਮ ਵਿੱਚ ਲਾਈਨਾਂ 3 ਅੱਖਰਾਂ ਤੱਕ ਸੀਮਿਤ ਹਨ, ਅਤੇ ਜੇਕਰ ਤੁਸੀਂ ਕੋਡ ਦੇ ਇੱਕ ਲੰਬੇ ਹਿੱਸੇ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਥਰਿੱਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਦੋ ਦਲੀਲਾਂ ਸਵੀਕਾਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ:

• code - ਚੱਲਣ ਲਈ ਪਾਈਥਨ ਕੋਡ ਦੀ ਇੱਕ ਲਾਈਨ ਜਾਂ ਸਟ੍ਰੀਮ।
• variable — (ਵਿਕਲਪਿਕ) ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਨਤੀਜਾ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ code ਇਹ ਪਾਈਥਨ ਵੇਰੀਏਬਲ।

ਵਰਤਣ ਲਈ ਉਦਾਹਰਨ:

set sc = ##class(isc.py.Main).ExecuteCode("2*3", "y").

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਅਸੀਂ 2 ਨੂੰ 3 ਨਾਲ ਗੁਣਾ ਕਰਦੇ ਹਾਂ ਅਤੇ ਨਤੀਜੇ ਨੂੰ ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਵਿੱਚ ਲਿਖਦੇ ਹਾਂ y.

ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ

ਪਾਈਥਨ ਨੂੰ ਅਤੇ ਇਸ ਤੋਂ ਡਾਟਾ ਪਾਸ ਕਰੋ।

ਪਾਈਥਨ -> ਇੰਟਰਸਿਸਟਮ ਆਈਆਰਆਈਐਸ

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

• String ਸਧਾਰਨ ਡਾਟਾ ਕਿਸਮਾਂ ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ।
• Repr ਸਧਾਰਨ ਵਸਤੂਆਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਡੀਬੱਗਿੰਗ ਲਈ।
• JSON ਇੰਟਰਸਿਸਟਮ IRIS ਸਾਈਡ 'ਤੇ ਆਸਾਨ ਡਾਟਾ ਹੇਰਾਫੇਰੀ ਲਈ।
• Pickle ਵਸਤੂਆਂ ਨੂੰ ਬਚਾਉਣ ਲਈ.

ਇਹ ਵਿਧੀਆਂ ਤੁਹਾਨੂੰ ਪਾਈਥਨ ਤੋਂ ਇੱਕ ਸਤਰ ਜਾਂ ਸਟ੍ਰੀਮ ਦੇ ਰੂਪ ਵਿੱਚ ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ।

• GetVariable(variable, serialization, .stream, useString) - ਪ੍ਰਾਪਤ ਕਰੋ serialization ਵੇਰੀਏਬਲ variable в stream. ਜੇ useString 1 ਹੈ ਅਤੇ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ 'ਤੇ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ, ਫਿਰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਨਾ ਕਿ ਇੱਕ ਸਟ੍ਰੀਮ।
• GetVariableJson(variable, .stream, useString) - ਇੱਕ ਵੇਰੀਏਬਲ ਦਾ JSON ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰੋ।
• GetVariablePickle(variable, .stream, useString, useDill) - ਇੱਕ ਵੇਰੀਏਬਲ ਦਾ ਅਚਾਰ (ਜਾਂ ਡਿਲ) ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰੋ।

ਆਉ ਆਪਣੇ ਵੇਰੀਏਬਲ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ y.

set sc = ##class(isc.py.Main).GetVariable("y", , .val, 1)
write val
>6

ਇੰਟਰਸਿਸਟਮ IRIS -> ਪਾਈਥਨ

InterSystems IRIS ਤੋਂ ਪਾਈਥਨ ਵਿੱਚ ਡਾਟਾ ਲੋਡ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।

• ExecuteQuery(query, variable, type, namespace) - ਇੱਕ ਡੇਟਾਸੈਟ ਬਣਾਉਂਦਾ ਹੈ (ਪਾਂਡਾ dataframe ਜ list) sql ਪੁੱਛਗਿੱਛ ਤੋਂ ਅਤੇ ਇਸਨੂੰ ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਤੇ ਸੈਟ ਕਰਦਾ ਹੈ variable. ਪਲਾਸਟਿਕ ਬੈਗ isc.py ਖੇਤਰ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ namespace - ਬੇਨਤੀ ਨੂੰ ਉੱਥੇ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ।
• ExecuteGlobal(global, variable, type, start, end, mask, labels, namespace) - ਗਲੋਬਲ ਡਾਟਾ ਲੋਡ ਕਰਦਾ ਹੈ global ਸਬਸਕ੍ਰਿਪਟ ਤੋਂ start ਨੂੰ end ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲ ਵਜੋਂ type: list, ਜਾਂ ਪਾਂਡਾ dataframe. ਵਿਕਲਪਿਕ ਆਰਗੂਮੈਂਟਾਂ ਦਾ ਵਰਣਨ mask ਅਤੇ labels ਕਲਾਸ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਰਿਪੋਜ਼ਟਰੀ ਵਿੱਚ ਉਪਲਬਧ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਦਸਤਾਵੇਜ਼.
• ExecuteClass(class, variable, type, start, end, properties, namespace) - ਕਲਾਸ ਡਾਟਾ ਲੋਡ ਕਰਦਾ ਹੈ class ਆਈਡੀ ਤੋਂ start ਨੂੰ end ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਕਿਸਮ ਦੇ ਵੇਰੀਏਬਲ ਵਜੋਂ type: list, ਜਾਂ ਪਾਂਡਾ dataframe. properties — ਕਲਾਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ (ਕਾਮਾ ਦੁਆਰਾ ਵੱਖ ਕੀਤੀ ਗਈ) ਜਿਸਨੂੰ ਡਾਟਾ ਸੈੱਟ ਵਿੱਚ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਮਾਸਕ ਸਮਰਥਿਤ ਹਨ * и ?. ਡਿਫੌਲਟ - * (ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ)। ਜਾਇਦਾਦ %%CLASSNAME ਅਣਡਿੱਠ ਕੀਤਾ.
• ExecuteTable(table, variable, type, start, end, properties, namespace) - ਟੇਬਲ ਡੇਟਾ ਲੋਡ ਕਰਦਾ ਹੈ table ਆਈਡੀ ਤੋਂ start ਨੂੰ end ਪਾਈਥਨ ਵਿੱਚ.

ExecuteQuery — ਯੂਨੀਵਰਸਲ (ਕੋਈ ਵੀ ਸਹੀ SQL ਪੁੱਛਗਿੱਛ ਪਾਈਥਨ ਨੂੰ ਦਿੱਤੀ ਜਾਵੇਗੀ)। ਹਾਲਾਂਕਿ, ExecuteGlobal ਅਤੇ ਇਸ ਦੇ ਰੈਪਰ ExecuteClass и ExecuteTable ਕਈ ਪਾਬੰਦੀਆਂ ਦੇ ਨਾਲ ਕੰਮ ਕਰੋ। ਉਹ ਬਹੁਤ ਤੇਜ਼ ਹਨ (ODBC ਡਰਾਈਵਰ ਨਾਲੋਂ 3-5 ਗੁਣਾ ਤੇਜ਼ ਅਤੇ 20 ਗੁਣਾ ਤੇਜ਼ ExecuteQuery). 'ਤੇ ਹੋਰ ਜਾਣਕਾਰੀ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਦਸਤਾਵੇਜ਼.
ਇਹ ਸਾਰੀਆਂ ਵਿਧੀਆਂ ਕਿਸੇ ਵੀ ਖੇਤਰ ਤੋਂ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਦਾ ਸਮਰਥਨ ਕਰਦੀਆਂ ਹਨ। ਪਲਾਸਟਿਕ ਬੈਗ isc.py ਟੀਚੇ ਵਾਲੇ ਖੇਤਰ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ExecuteQuery

ExecuteQuery(request, variable, type, namespace) - ਕਿਸੇ ਵੀ ਸਹੀ SQL ਪੁੱਛਗਿੱਛ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪਾਈਥਨ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨਾ। ਇਹ ਸਭ ਤੋਂ ਹੌਲੀ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਵਿਧੀ ਹੈ। ਇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜੇਕਰ ExecuteGlobal ਅਤੇ ਇਸ ਦੇ ਰੈਪਰ ਉਪਲਬਧ ਨਹੀਂ ਹਨ।

ਆਰਗੂਮੈਂਟਸ:

• query - sql ਪੁੱਛਗਿੱਛ.
• variable — ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਲਿਖਿਆ ਗਿਆ ਹੈ।
• type - list ਜਾਂ ਪਾਂਡਾ dataframe.
• namespace - ਉਹ ਖੇਤਰ ਜਿਸ ਵਿੱਚ ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ।

ਐਗਜ਼ੀਕਿਊਟ ਗਲੋਬਲ

ExecuteGlobal(global, variable, type, start, end, mask, labelels, namespace) - ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਗਲੋਬਲ ਪਾਸ ਕਰਨਾ.

ਆਰਗੂਮੈਂਟਸ:

• global - ਬਿਨਾਂ ਗਲੋਬਲ ਨਾਮ ^
• variable — ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਲਿਖਿਆ ਗਿਆ ਹੈ।
• type - list ਜਾਂ ਪਾਂਡਾ dataframe.
• start - ਗਲੋਬਲ ਦੀ ਪਹਿਲੀ ਸਬਸਕ੍ਰਿਪਟ। ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ %Integer.
• end - ਗਲੋਬਲ ਦੀ ਆਖਰੀ ਸਬਸਕ੍ਰਿਪਟ। ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ %Integer.
• mask - ਗਲੋਬਲ ਵੈਲਯੂ ਮਾਸਕ. ਮਾਸਕ ਗਲੋਬਲ ਵਿੱਚ ਫੀਲਡਾਂ ਦੀ ਸੰਖਿਆ ਤੋਂ ਛੋਟਾ ਹੋ ਸਕਦਾ ਹੈ (ਜਿਸ ਸਥਿਤੀ ਵਿੱਚ ਅੰਤ ਵਿੱਚ ਫੀਲਡਾਂ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਜਾਵੇਗਾ)। ਮਾਸਕ ਨੂੰ ਕਿਵੇਂ ਫਾਰਮੈਟ ਕਰਨਾ ਹੈ:
  • + ਮੁੱਲ ਪਾਸ ਕਰੋ ਜਿਵੇਂ ਹੈ।
  • - ਮੁੱਲ ਛੱਡੋ।
  • b - ਬੂਲੀਅਨ ਕਿਸਮ (0 - False, ਬਾਕੀ ਸਭ - True).
  • d — ਮਿਤੀ ($horolog ਤੋਂ, 1970 ਤੋਂ ਵਿੰਡੋਜ਼ ਉੱਤੇ, 1900 ਤੋਂ ਲੀਨਕਸ ਉੱਤੇ)।
  • t — ਸਮਾਂ ($horolog, ਅੱਧੀ ਰਾਤ ਤੋਂ ਬਾਅਦ ਸਕਿੰਟ)।
  • m — ਟਾਈਮਸਟੈਂਪ (ਫਾਰਮੈਟ ਸਤਰ YEAR-MONTH-DAY HOUR:MINUTE:SECOND)।
• labels — % ਕਾਲਮ ਨਾਵਾਂ ਦੀ ਸੂਚੀ। ਪਹਿਲਾ ਤੱਤ ਸਬਸਕ੍ਰਿਪਟ ਦਾ ਨਾਮ ਹੈ।
• namespace - ਉਹ ਖੇਤਰ ਜਿਸ ਵਿੱਚ ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ।

ਐਗਜ਼ੀਕਿਊਟ ਕਲਾਸ

ਉੱਤੇ ਸਮੇਟਣਾ ExecuteGlobal. ਕਲਾਸ ਪਰਿਭਾਸ਼ਾ ਦੇ ਆਧਾਰ 'ਤੇ, ਇੱਕ ਕਾਲ ਤਿਆਰ ਕਰਦਾ ਹੈ ExecuteGlobal ਅਤੇ ਉਸਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ।

ExecuteClass(class, variable, type, start, end, properties, namespace) - ਪਾਈਥਨ ਵਿੱਚ ਕਲਾਸ ਡੇਟਾ ਪਾਸ ਕਰਨਾ।

ਆਰਗੂਮੈਂਟਸ:

• class - ਕਲਾਸ ਦਾ ਨਾਮ
• variable — ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਦਾ ਨਾਮ ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਲਿਖਿਆ ਗਿਆ ਹੈ।
• type - list ਜਾਂ ਪਾਂਡਾ dataframe.
• start - ਸ਼ੁਰੂਆਤੀ ਆਈ.ਡੀ.
• end - ਅੰਤਿਮ ਆਈ.ਡੀ
• properties — ਕਲਾਸ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਇੱਕ ਸੂਚੀ (ਕਾਮਾ ਦੁਆਰਾ ਵੱਖ ਕੀਤੀ ਗਈ) ਜਿਸਨੂੰ ਡਾਟਾ ਸੈੱਟ ਵਿੱਚ ਲੋਡ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਮਾਸਕ ਸਮਰਥਿਤ ਹਨ * и ?. ਡਿਫੌਲਟ - * (ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ)। ਜਾਇਦਾਦ %%CLASSNAME ਅਣਡਿੱਠ ਕੀਤਾ.
• namespace - ਉਹ ਖੇਤਰ ਜਿਸ ਵਿੱਚ ਬੇਨਤੀ ਨੂੰ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇਗਾ।

ਕਿਸਮ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਛੱਡ ਕੇ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪਾਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ %Date, %Time, %Boolean и %TimeStamp - ਉਹਨਾਂ ਨੂੰ ਅਨੁਸਾਰੀ ਪਾਈਥਨ ਕਲਾਸਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।

ਐਗਜ਼ੀਕਿਊਟ ਟੇਬਲ

ਉੱਤੇ ਸਮੇਟਣਾ ExecuteClass. ਟੇਬਲ ਦੇ ਨਾਮ ਦਾ ਕਲਾਸ ਦੇ ਨਾਮ ਅਤੇ ਕਾਲਾਂ ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ ExecuteClass. ਦਸਤਖਤ:

ExecuteTable(table, variable, type, start, end, properties, namespace) - ਪਾਈਥਨ ਨੂੰ ਟੇਬਲ ਡੇਟਾ ਪਾਸ ਕਰਨਾ.

ਆਰਗੂਮੈਂਟਸ:

• table - ਟੇਬਲ ਦਾ ਨਾਮ.
  ਬਾਕੀ ਸਾਰੀਆਂ ਦਲੀਲਾਂ ਜਿਵੇਂ ਕਿ ਹਨ ਪਾਸ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ExecuteClass.

ਨੋਟ

• ExecuteGlobal, ExecuteClass и ExecuteTable ਬਰਾਬਰ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰੋ.
• ExecuteGlobal ਨਾਲੋਂ 20 ਗੁਣਾ ਤੇਜ਼ ExecuteQuery ਵੱਡੇ ਡਾਟਾ ਸੈੱਟਾਂ 'ਤੇ (ਟ੍ਰਾਂਸਫਰ ਸਮਾਂ > 0.01 ਸਕਿੰਟ)।
• ExecuteGlobal, ExecuteClass и ExecuteTable ਇਸ ਢਾਂਚੇ ਨਾਲ ਗਲੋਬਲ 'ਤੇ ਕੰਮ ਕਰੋ: ^global(key) = $lb(prop1, prop2, ..., propN) ਜਿੱਥੇ key - ਇੱਕ ਪੂਰਨ ਅੰਕ।
• ਕਰਨ ਲਈ ExecuteGlobal, ExecuteClass и ExecuteTable ਮੁੱਲਾਂ ਦੀ ਸਮਰਥਿਤ ਰੇਂਜ %Date ਸੀਮਾ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ mktime ਅਤੇ OS 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ (ਵਿੰਡੋਜ਼ ਨੂੰ: 1970-01-01, ਲੀਨਕਸ 1900-01-01, ਮੈਕ). ਵਰਤੋ %TimeStampਇਸ ਰੇਂਜ ਤੋਂ ਬਾਹਰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਲਈ ਜਾਂ ਪਾਂਡਾ ਡੇਟਾਫ੍ਰੇਮ ਦੀ ਵਰਤੋਂ ਕਰੋ ਕਿਉਂਕਿ ਇਹ ਸਿਰਫ਼-ਸੂਚੀ ਸੀਮਾ ਹੈ।
• ਕਰਨ ਲਈ ExecuteGlobal, ExecuteClass и ExecuteTable ਡੇਟਾ ਸਰੋਤ (ਗਲੋਬਲ, ਕਲਾਸ ਜਾਂ ਟੇਬਲ) ਅਤੇ ਵੇਰੀਏਬਲ ਨੂੰ ਛੱਡ ਕੇ ਸਾਰੇ ਆਰਗੂਮੈਂਟ ਵਿਕਲਪਿਕ ਹਨ।

ਮਿਸਾਲ

ਟੈਸਟ ਕਲਾਸ isc.py.test.Person ਸਾਰੇ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਵਿਕਲਪਾਂ ਨੂੰ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨ ਵਾਲੀ ਵਿਧੀ ਸ਼ਾਮਲ ਕਰਦੀ ਹੈ:

set global = "isc.py.test.PersonD"
set class = "isc.py.test.Person"
set table = "isc_py_test.Person"
set query = "SELECT * FROM isc_py_test.Person"

// Общие аргументы
set variable = "df"
set type = "dataframe"
set start = 1
set end = $g(^isc.py.test.PersonD, start)

// Способ 0: ExecuteGlobal без аргументов
set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 0, type)

// Способ 1: ExecuteGlobal с аргументами    
// При передаче глобала названия полей задаются вручную
// globalKey - название сабсткрипта 
set labels = $lb("globalKey", "Name", "DOB", "TS", "RandomTime", "AgeYears", "AgeDecimal", "AgeDouble", "Bool")

// mask содержит на 1 элемент меньше чем labels потому что "globalKey" - название сабскипта
// Пропускаем %%CLASSNAME
set mask = "-+dmt+++b"

set sc = ##class(isc.py.Main).ExecuteGlobal(global, variable _ 1, type, start, end, mask, labels)

// Способ 2: ExecuteClass
set sc = ##class(isc.py.Main).ExecuteClass(class, variable _ 2, type, start, end)

// Способ 3: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteTable(table, variable _ 3, type, start, end)

// Способ 4: ExecuteTable
set sc = ##class(isc.py.Main).ExecuteQuery(query, variable _ 4, type)

ਵਿਧੀ ਨੂੰ ਕਾਲ ਕਰੋ do ##class(isc.py.test.Person).Test() ਇਹ ਦੇਖਣ ਲਈ ਕਿ ਸਾਰੀਆਂ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਵਿਧੀਆਂ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

ਸਹਾਇਕ ਢੰਗ

• GetVariableInfo(variable, serialization, .defined, .type, .length) - ਵੇਰੀਏਬਲ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰੋ: ਕੀ ਇਹ ਪਰਿਭਾਸ਼ਿਤ ਹੈ, ਇਸਦੀ ਸ਼੍ਰੇਣੀ ਅਤੇ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਲੰਬਾਈ।
• GetVariableDefined(variable, .defined) — ਕੀ ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਿਤ ਹੈ।
• GetVariableType(variable, .type) - ਵੇਰੀਏਬਲ ਦੀ ਕਲਾਸ ਪ੍ਰਾਪਤ ਕਰੋ।
• GetStatus() - ਪਾਈਥਨ ਸਾਈਡ 'ਤੇ ਆਖਰੀ ਅਪਵਾਦ ਪ੍ਰਾਪਤ ਕਰੋ ਅਤੇ ਹਟਾਓ।
• GetModuleInfo(module, .imported, .alias) - ਮੋਡੀਊਲ ਵੇਰੀਏਬਲ ਅਤੇ ਆਯਾਤ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰੋ.
• GetFunctionInfo(function, .defined, .type, .docs, .signature, .arguments) - ਫੰਕਸ਼ਨ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰੋ।

ਅੰਤਰ-ਕਾਰਜਸ਼ੀਲਤਾ

ਤੁਸੀਂ ਟਰਮੀਨਲ ਤੋਂ ਪਾਈਥਨ ਗੇਟਵੇ ਨੂੰ ਕਾਲ ਕਰਨਾ ਸਿੱਖ ਲਿਆ ਹੈ, ਆਓ ਹੁਣ ਇਸਨੂੰ ਉਤਪਾਦਨ ਵਿੱਚ ਵਰਤਣਾ ਸ਼ੁਰੂ ਕਰੀਏ। ਇਸ ਮੋਡ ਵਿੱਚ ਪਾਈਥਨ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦਾ ਆਧਾਰ ਹੈ isc.py.ens.Operation. ਇਹ ਸਾਨੂੰ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ:

• Python ਵਿੱਚ ਕੋਡ ਚਲਾਓ
• ਪਾਈਥਨ ਸੰਦਰਭ ਨੂੰ ਸੰਭਾਲੋ/ਬਹਾਲ ਕਰੋ
• ਪਾਈਥਨ ਤੋਂ ਡਾਟਾ ਲੋਡ ਕਰੋ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰੋ

ਅਸਲ ਵਿੱਚ, ਇੱਕ ਪਾਈਥਨ ਓਪਰੇਸ਼ਨ ਇੱਕ ਰੈਪਰ ਓਵਰ ਹੈ isc.py.Main. ਓਪਰੇਸ਼ਨ isc.py.ens.Operation InterSystems IRIS ਉਤਪਾਦਾਂ ਤੋਂ ਪਾਈਥਨ ਪ੍ਰਕਿਰਿਆ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਪੰਜ ਸਵਾਲ ਸਮਰਥਿਤ ਹਨ:

• isc.py.msg.ExecutionRequest ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਲਈ। ਵਾਪਸੀ isc.py.msg.ExecutionResponse ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨਤੀਜੇ ਅਤੇ ਬੇਨਤੀ ਕੀਤੇ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲਾਂ ਦੇ ਨਾਲ।
• isc.py.msg.StreamExecutionRequest ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਲਈ। ਵਾਪਸੀ isc.py.msg.StreamExecutionResponse ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦਾ ਨਤੀਜਾ ਅਤੇ ਬੇਨਤੀ ਕੀਤੇ ਵੇਰੀਏਬਲ ਦੇ ਮੁੱਲ। ਐਨਾਲਾਗ isc.py.msg.ExecutionRequest, ਪਰ ਸਤਰ ਦੀ ਬਜਾਏ ਸਟ੍ਰੀਮਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਵਾਪਸ ਕਰਦਾ ਹੈ।
• isc.py.msg.QueryRequest ਇੱਕ SQL ਪੁੱਛਗਿੱਛ ਨੂੰ ਚਲਾਉਣ ਦੇ ਨਤੀਜੇ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ. ਵਾਪਸੀ Ens.Response.
• isc.py.msg.GlobalRequest/isc.py.msg.ClassRequest/isc.py.msg.TableRequest ਗਲੋਬਲ/ਕਲਾਸ/ਟੇਬਲ ਡਾਟਾ ਪਾਸ ਕਰਨ ਲਈ। ਵਾਪਸੀ Ens.Response.
• isc.py.msg.SaveRequest ਪਾਈਥਨ ਸੰਦਰਭ ਨੂੰ ਬਚਾਉਣ ਲਈ. ਵਾਪਸੀ Ens.StringResponse ਸੰਦਰਭ ID ਦੇ ਨਾਲ।

• isc.py.msg.RestoreRequest ਪਾਈਥਨ ਸੰਦਰਭ ਨੂੰ ਬਹਾਲ ਕਰਨ ਲਈ.

  ਇਸ ਦੇ ਇਲਾਵਾ, isc.py.ens.Operation ਦੋ ਸੈਟਿੰਗਾਂ ਹਨ:

  • Initializer — ਇੱਕ ਕਲਾਸ ਚੁਣਨਾ ਜੋ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ isc.py.init.Abstract. ਇਸਦੀ ਵਰਤੋਂ ਫੰਕਸ਼ਨਾਂ, ਮੋਡੀਊਲ, ਕਲਾਸਾਂ ਆਦਿ ਨੂੰ ਲੋਡ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਜਦੋਂ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਤਾਂ ਇਹ ਇੱਕ ਵਾਰ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।
  • PythonLib - (ਸਿਰਫ਼ ਲੀਨਕਸ) ਜੇਕਰ ਤੁਸੀਂ ਲੋਡ ਕਰਨ ਵੇਲੇ ਗਲਤੀਆਂ ਦੇਖਦੇ ਹੋ, ਤਾਂ ਇਸਦਾ ਮੁੱਲ ਸੈੱਟ ਕਰੋ libpython3.6m.so ਜਾਂ ਇੱਥੋਂ ਤੱਕ ਕਿ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਪੂਰੇ ਮਾਰਗ ਵਿੱਚ।

ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਸਿਰਜਣਾ

ਇੱਥੇ ਦੋ ਸ਼੍ਰੇਣੀਆਂ ਉਪਲਬਧ ਹਨ ਜੋ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਵਿਕਾਸ ਦੀ ਸਹੂਲਤ ਦਿੰਦੀਆਂ ਹਨ:

• isc.py.ens.ProcessUtils ਤੁਹਾਨੂੰ ਵੇਰੀਏਬਲ ਬਦਲ ਦੇ ਨਾਲ ਗਤੀਵਿਧੀਆਂ ਤੋਂ ਐਨੋਟੇਸ਼ਨ ਐਕਸਟਰੈਕਟ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।
• isc.py.util.BPEmulator ਪਾਈਥਨ ਨਾਲ ਵਪਾਰਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਮੌਜੂਦਾ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਇੱਕ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆ (ਪਾਈਥਨ ਪਾਰਟਸ) ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ।

ਵੇਰੀਏਬਲ ਬਦਲ

ਸਾਰੀਆਂ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲੀਆਂ ਹਨ isc.py.ens.ProcessUtilsਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ GetAnnotation(name) ਇਸਦੇ ਨਾਮ ਦੁਆਰਾ ਗਤੀਵਿਧੀ ਐਨੋਟੇਸ਼ਨ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ। ਗਤੀਵਿਧੀ ਐਨੋਟੇਸ਼ਨ ਵਿੱਚ ਵੇਰੀਏਬਲ ਸ਼ਾਮਲ ਹੋ ਸਕਦੇ ਹਨ ਜੋ ਪਾਈਥਨ ਨੂੰ ਪਾਸ ਕੀਤੇ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਇੰਟਰਸਿਸਟਮ IRIS ਸਾਈਡ 'ਤੇ ਗਣਨਾ ਕੀਤੇ ਜਾਣਗੇ। ਇੱਥੇ ਵੇਰੀਏਬਲ ਪ੍ਰਤੀਸਥਾਪਨ ਲਈ ਸੰਟੈਕਸ ਹੈ:

• ${class:method:arg1:...:argN} - ਵਿਧੀ ਕਾਲ
• #{expr} - ਆਬਜੈਕਟ ਸਕ੍ਰਿਪਟ ਭਾਸ਼ਾ ਵਿੱਚ ਕੋਡ ਚਲਾਓ।

ਇੱਕ ਉਦਾਹਰਣ ਟੈਸਟ ਵਪਾਰ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਉਪਲਬਧ ਹੈ isc.py.test.Process, ਉਦਾਹਰਨ ਲਈ, ਗਤੀਵਿਧੀ ਵਿੱਚ Correlation Matrix: Graph: f.savefig(r'#{process.WorkDirectory}SHOWCASE${%PopulateUtils:Integer:1:100}.png'). ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ:

• #{process.WorkDirectory} ਆਬਜੈਕਟ ਦੀ ਵਰਕਡਾਇਰੈਕਟਰੀ ਵਿਸ਼ੇਸ਼ਤਾ ਵਾਪਸ ਕਰਦਾ ਹੈ process, ਜੋ ਕਿ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈ isc.py.test.Process ਉਹ. ਮੌਜੂਦਾ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆ.
• ${%PopulateUtils:Integer:1:100} ਇੱਕ ਢੰਗ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ Integer ਕਲਾਸ %PopulateUtils, ਪਾਸਿੰਗ ਆਰਗੂਮੈਂਟਸ 1 и 100, ਰੇਂਜ ਵਿੱਚ ਇੱਕ ਬੇਤਰਤੀਬ ਪੂਰਨ ਅੰਕ ਵਾਪਸ ਕਰ ਰਿਹਾ ਹੈ 1...100.

ਟੈਸਟ ਵਪਾਰ ਪ੍ਰਕਿਰਿਆ

ਪਾਇਥਨ ਗੇਟਵੇ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਟੈਸਟ ਉਤਪਾਦ ਅਤੇ ਟੈਸਟ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਉਪਲਬਧ ਹਨ। ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ:

1. OS ਟਰਮੀਨਲ ਵਿੱਚ, ਚਲਾਓ: pip install pandas matplotlib seaborn.
2. InterSystems IRIS ਟਰਮੀਨਲ ਵਿੱਚ, ਚਲਾਓ: do ##class(isc.py.test.CannibalizationData).Import() ਟੈਸਟ ਡਾਟਾ ਭਰਨ ਲਈ.
3. ਉਤਪਾਦ ਲਾਂਚ ਕਰੋ isc.py.test.Production.
4. ਬੇਨਤੀ ਦੀ ਕਿਸਮ ਭੇਜੋ Ens.Request в isc.py.test.Process.

ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਸਭ ਇਕੱਠੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਖੋਲ੍ਹੋ isc.py.test.Process ਬੀਪੀਐਲ ਸੰਪਾਦਕ ਵਿੱਚ:

ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ

ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਚੁਣੌਤੀ ਪਾਈਥਨ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਹੈ:

ਪੁੱਛਗਿੱਛ ਵਰਤੀ ਗਈ isc.py.msg.ExecutionRequest, ਇੱਥੇ ਇਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ:

• Code - ਪਾਈਥਨ ਕੋਡ।
• SeparateLines — ਕੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਕੋਡ ਨੂੰ ਲਾਈਨਾਂ ਵਿੱਚ ਵੰਡਣਾ ਹੈ। $c(10) (n) ਦੀ ਵਰਤੋਂ ਤਾਰਾਂ ਨੂੰ ਵੱਖ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਪੂਰੇ ਸੁਨੇਹੇ ਨੂੰ ਇੱਕ ਵਾਰ ਵਿੱਚ ਪ੍ਰੋਸੈਸ ਕਰਨ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਇਹ ਫੰਕਸ਼ਨ ਸਿਰਫ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਹੈ def ਅਤੇ ਸਮਾਨ ਮਲਟੀਲਾਈਨ ਸਮੀਕਰਨ। ਡਿਫਾਲਟ 0.
• Variables — ਵੇਰੀਏਬਲਾਂ ਦੀ ਇੱਕ ਕੌਮੇ ਨਾਲ ਵੱਖ ਕੀਤੀ ਸੂਚੀ ਜੋ ਜਵਾਬ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੀ ਜਾਵੇਗੀ।
• Serialization - ਵੇਰੀਏਬਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸੀਰੀਅਲਾਈਜ਼ ਕਰਨਾ ਹੈ ਜੋ ਅਸੀਂ ਵਾਪਸ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ। ਵਿਕਲਪ: Str, Repr, JSON, Pickle и Dill, ਡਿਫਾਲਟ Str.

ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ ਜਾਇਦਾਦ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਾਂ Code, ਇਸ ਲਈ ਹੋਰ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਮੂਲ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ। ਅਸੀਂ ਇਸਨੂੰ ਕਾਲ ਕਰਕੇ ਸੈੱਟ ਕੀਤਾ process.GetAnnotation("Import pandas"), ਜੋ ਰਨਟਾਈਮ 'ਤੇ ਵੇਰੀਏਬਲ ਪ੍ਰਤੀਸਥਾਪਨ ਕੀਤੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਐਨੋਟੇਸ਼ਨ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਭ ਦੇ ਬਾਅਦ, ਕੋਡ import pandas as pd ਪਾਈਥਨ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾਵੇਗਾ। GetAnnotation ਮਲਟੀ-ਲਾਈਨ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟਾਂ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ, ਪਰ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਇਸ ਢੰਗ 'ਤੇ ਕੋਈ ਪਾਬੰਦੀਆਂ ਨਹੀਂ ਹਨ। ਤੁਸੀਂ ਜਾਇਦਾਦ ਨੂੰ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ Code ਤੁਹਾਡੇ ਲਈ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਸੁਵਿਧਾਜਨਕ।

ਵੇਰੀਏਬਲ ਪ੍ਰਾਪਤ ਕਰਨਾ

ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਕ ਹੋਰ ਦਿਲਚਸਪ ਚੁਣੌਤੀ isc.py.msg.ExecutionRequest - Correlation Matrix: Tabular:

ਇਹ ਪਾਈਥਨ ਸਾਈਡ 'ਤੇ ਸਬੰਧ ਮੈਟ੍ਰਿਕਸ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ ਅਤੇ ਵੇਰੀਏਬਲ ਨੂੰ ਕੱਢਦਾ ਹੈ corrmat ਬੇਨਤੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੈੱਟ ਕਰਕੇ JSON ਫਾਰਮੈਟ ਵਿੱਚ InterSystems IRIS 'ਤੇ ਵਾਪਸ ਜਾਓ:

• Variables: "corrmat"
• Serialization: "JSON"

ਅਸੀਂ ਵਿਜ਼ੂਅਲ ਟਰੇਸ ਵਿੱਚ ਨਤੀਜੇ ਦੇਖ ਸਕਦੇ ਹਾਂ:

ਅਤੇ ਜੇਕਰ ਸਾਨੂੰ BP ਵਿੱਚ ਇਸ ਮੁੱਲ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ: callresponse.Variables.GetAt("corrmat").

ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ

ਅੱਗੇ, ਆਓ ਇੰਟਰਸਿਸਟਮ ਆਈਆਰਆਈਐਸ ਤੋਂ ਪਾਈਥਨ ਵਿੱਚ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਬਾਰੇ ਗੱਲ ਕਰੀਏ; ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਲਈ ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ isc.py.msg.DataRequestਜੋ ਹੇਠ ਲਿਖੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ:

• Variable — ਇੱਕ ਪਾਈਥਨ ਵੇਰੀਏਬਲ ਜਿਸ ਵਿੱਚ ਡੇਟਾ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ।
• Type - ਵੇਰੀਏਬਲ ਕਿਸਮ: dataframe (ਪਾਂਡਾ ਡੇਟਾਫ੍ਰੇਮ) ਜਾਂ list.
• Namespace — ਉਹ ਖੇਤਰ ਜਿਸ ਤੋਂ ਅਸੀਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਪਲਾਸਟਿਕ ਬੈਗ isc.py ਇਸ ਖੇਤਰ ਵਿੱਚ ਉਪਲਬਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਹ ਉਤਪਾਦ ਸਹਾਇਤਾ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਖੇਤਰ ਹੋ ਸਕਦਾ ਹੈ।

ਇਸ ਇੰਟਰਫੇਸ ਦੇ ਅਧਾਰ ਤੇ, ਬੇਨਤੀਆਂ ਦੀਆਂ 4 ਸ਼੍ਰੇਣੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ:

• isc.py.msg.QueryRequest - ਜਾਇਦਾਦ ਸੈੱਟ ਕਰੋ Query ਇੱਕ SQL ਪੁੱਛਗਿੱਛ ਭੇਜਣ ਲਈ.
• isc.py.msg.ClassRequest - ਜਾਇਦਾਦ ਸੈੱਟ ਕਰੋ Class ਕਲਾਸ ਡਾਟਾ ਪਾਸ ਕਰਨ ਲਈ.
• isc.py.msg.TableRequest - ਸੰਪਤੀ ਨੂੰ ਸੈੱਟ ਕਰੋ Table ਟੇਬਲ ਡਾਟਾ ਤਬਦੀਲ ਕਰਨ ਲਈ.
• isc.py.msg.GlobalRequest - ਸੰਪਤੀ ਨੂੰ ਸੈੱਟ ਕਰੋ Global ਗਲੋਬਲ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਲਈ.

ਟੈਸਟ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, ਗਤੀਵਿਧੀ ਨੂੰ ਦੇਖੋ RAWਕਿੱਥੇ isc.py.msg.QueryRequest ਕਾਰਵਾਈ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ.

ਪਾਈਥਨ ਸੰਦਰਭ ਨੂੰ ਸੰਭਾਲਣਾ/ਬਹਾਲ ਕਰਨਾ

ਅੰਤ ਵਿੱਚ, ਅਸੀਂ ਇੰਟਰਸਿਸਟਮ ਆਈਆਰਆਈਐਸ ਵਿੱਚ ਪਾਈਥਨ ਸੰਦਰਭ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਜਿਹਾ ਕਰਨ ਲਈ ਅਸੀਂ ਭੇਜਾਂਗੇ isc.py.msg.SaveRequest ਦਲੀਲਾਂ ਦੇ ਨਾਲ:

• Mask - ਸਿਰਫ਼ ਮਾਸਕ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਵੇਰੀਏਬਲ ਹੀ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਸਹਿਯੋਗੀ * и ?. ਉਦਾਹਰਨ: "Data*, Figure?"... ਡਿਫਾਲਟ *.
• MaxLength — ਸਟੋਰ ਕੀਤੇ ਵੇਰੀਏਬਲ ਦੀ ਅਧਿਕਤਮ ਲੰਬਾਈ। ਜੇਕਰ ਇੱਕ ਵੇਰੀਏਬਲ ਦਾ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਲੰਬਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਵੇਗਾ। ਕਿਸੇ ਵੀ ਲੰਬਾਈ ਦੇ ਵੇਰੀਏਬਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ 0 'ਤੇ ਸੈੱਟ ਕਰੋ। ਡਿਫਾਲਟ $$$MaxStringLength.
• Name - ਸੰਦਰਭ ਨਾਮ (ਵਿਕਲਪਿਕ)
• Description - ਸੰਦਰਭ ਦਾ ਵਰਣਨ (ਵਿਕਲਪਿਕ)।

ਵਾਪਸੀ Ens.StringResponse с Id ਸੁਰੱਖਿਅਤ ਸੰਦਰਭ. ਟੈਸਟ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, ਗਤੀਵਿਧੀ ਨੂੰ ਦੇਖੋ Save Context.

ਸੰਬੰਧਿਤ ਬੇਨਤੀ isc.py.msg.RestoreRequest InterSystems IRIS ਤੋਂ Python ਵਿੱਚ ਪ੍ਰਸੰਗ ਲੋਡ ਕਰਦਾ ਹੈ:

• ContextId - ਸੰਦਰਭ ਪਛਾਣਕਰਤਾ।
• Clear - ਰੀਸਟੋਰ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਸੰਗ ਨੂੰ ਸਾਫ਼ ਕਰੋ।

ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ

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

ਇਹ ਐਕਸਟੈਂਸ਼ਨ ਇਹ ਮੰਨਦੀ ਹੈ ਕਿ ਐਨੋਟੇਸ਼ਨਾਂ ਵਿੱਚ ਪਾਈਥਨ ਕੋਡ ਹੁੰਦਾ ਹੈ ਅਤੇ ਪਿਛਲੇ ਸਿਰਲੇਖਾਂ ਵਜੋਂ ਸਰਗਰਮੀ ਨਾਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਹੁਣ ਜੁਪੀਟਰ ਨੋਟਬੁੱਕ ਵਿੱਚ ਪਾਈਥਨਗੇਟਵੇ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨਾ ਸੰਭਵ ਹੈ। ਇੱਥੇ ਕੀ ਸੰਭਵ ਹੈ:

• ਨਵੀਂ ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਬਣਾਓ
• ਕਾਰੋਬਾਰੀ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਮਿਟਾਓ
• ਨਵੀਆਂ ਗਤੀਵਿਧੀਆਂ ਬਣਾਓ
• ਗਤੀਵਿਧੀਆਂ ਨੂੰ ਬਦਲੋ
• ਗਤੀਵਿਧੀਆਂ ਨੂੰ ਮਿਟਾਓ

ਇੱਥੇ ਡੈਮੋ ਵੀਡੀਓ. ਅਤੇ ਕੁਝ ਸਕ੍ਰੀਨਸ਼ੌਟਸ:

ਪ੍ਰਕਿਰਿਆ ਐਕਸਪਲੋਰਰ

ਪ੍ਰਕਿਰਿਆ ਸੰਪਾਦਕ

ਸੈਟਿੰਗ

1. ਤੁਹਾਨੂੰ InterSystems IRIS 2019.2+ ਦੀ ਲੋੜ ਹੋਵੇਗੀ।
2. PythonGateway v0.8+ ਇੰਸਟਾਲ ਕਰੋ (ਸਿਰਫ਼ ਲੋੜੀਂਦਾ ਹੈ isc.py.util.Jupyter, isc.py.util.JupyterCheckpoints и isc.py.ens.ProcessUtils).
3. ਰਿਪੋਜ਼ਟਰੀ ਤੋਂ ਆਬਜੈਕਟ ਸਕ੍ਰਿਪਟ ਕੋਡ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ।
4. ਚਲਾਓ do ##class(isc.py.util.Jupyter).Install() ਅਤੇ ਪ੍ਰੋਂਪਟ ਦੀ ਪਾਲਣਾ ਕਰੋ।

ਦਸਤਾਵੇਜ਼.

ਸਿੱਟਾ

MLToolkit ਸਾਧਨਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ ਜਿਸਦਾ ਟੀਚਾ ਮਾਡਲਾਂ ਅਤੇ ਇੱਕ ਲੈਣ-ਦੇਣ ਦੇ ਵਾਤਾਵਰਣ ਨੂੰ ਜੋੜਨਾ ਹੈ ਤਾਂ ਜੋ ਬਿਲਟ ਕੀਤੇ ਮਾਡਲਾਂ ਨੂੰ ਤੁਹਾਡੀਆਂ ਵਪਾਰਕ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਵਰਤਿਆ ਜਾ ਸਕੇ। Python Gateway MLToolkit ਦਾ ਹਿੱਸਾ ਹੈ ਅਤੇ ਪਾਈਥਨ ਭਾਸ਼ਾ ਨਾਲ ਏਕੀਕਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਪਾਈਥਨ (ਬਹੁਤ ਸਾਰੇ ਡੇਟਾ ਵਿਗਿਆਨੀਆਂ ਲਈ ਮੁੱਖ ਵਾਤਾਵਰਣ) ਵਿੱਚ ਬਣਾਏ ਗਏ ਕਿਸੇ ਵੀ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਐਲਗੋਰਿਦਮ ਨੂੰ ਆਰਕੈਸਟਰੇਟ ਕਰ ਸਕਦੇ ਹੋ, ਤੇਜ਼ੀ ਨਾਲ ਅਨੁਕੂਲਿਤ, ਰੋਬੋਟਿਕ ਵਿਸ਼ਲੇਸ਼ਣਾਤਮਕ AI / ਬਣਾਉਣ ਲਈ ਬਹੁਤ ਸਾਰੀਆਂ ਤਿਆਰ-ਕੀਤੀ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇੰਟਰਸਿਸਟਮ ਪਲੇਟਫਾਰਮ IRIS 'ਤੇ ML ਹੱਲ।

ਹਵਾਲੇ

• ਪਿਛਲਾ ਲੇਖ
• ਪਾਈਥਨ ਗੇਟਵੇ
• ਪਾਈਥਨ ਗੇਟਵੇ ਨਮੂਨੇ
• ਕਨਵਰਜੈਂਟ-ਵਿਸ਼ਲੇਸ਼ਣ
• ਪਾਈਥਨ 3.6.7 64 ਬਿੱਟ
• ਪਾਈਥਨ ਦਸਤਾਵੇਜ਼ ਅਤੇ ਕੋਰਸ

MLToolkit

MLToolkit ਉਪਭੋਗਤਾ ਸਮੂਹ ਇੱਕ ਨਿੱਜੀ GitHub ਰਿਪੋਜ਼ਟਰੀ ਹੈ ਜੋ InterSystems ਕਾਰਪੋਰੇਟ GitHub ਸੰਗਠਨ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਹ ਉਹਨਾਂ ਬਾਹਰੀ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਹੈ ਜੋ ਪਾਇਥਨ ਗੇਟਵੇ ਸਮੇਤ MLToolkit ਭਾਗਾਂ ਨੂੰ ਸਥਾਪਿਤ, ਸਿੱਖਣ, ਜਾਂ ਪਹਿਲਾਂ ਹੀ ਵਰਤ ਰਹੇ ਹਨ। ਗਰੁੱਪ ਕੋਲ ਮਾਰਕੀਟਿੰਗ, ਨਿਰਮਾਣ, ਦਵਾਈ ਅਤੇ ਹੋਰ ਬਹੁਤ ਸਾਰੇ ਉਦਯੋਗਾਂ ਦੇ ਖੇਤਰਾਂ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਲਾਗੂ ਕੀਤੇ ਕੇਸ (ਸਰੋਤ ਕੋਡ ਅਤੇ ਟੈਸਟ ਡੇਟਾ ਦੇ ਨਾਲ) ਹਨ। ML Toolkit ਉਪਭੋਗਤਾ ਸਮੂਹ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਲਈ, ਕਿਰਪਾ ਕਰਕੇ ਹੇਠਾਂ ਦਿੱਤੇ ਪਤੇ 'ਤੇ ਇੱਕ ਛੋਟੀ ਈਮੇਲ ਭੇਜੋ: [ਈਮੇਲ ਸੁਰੱਖਿਅਤ] ਅਤੇ ਆਪਣੇ ਪੱਤਰ ਵਿੱਚ ਹੇਠ ਲਿਖੀ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਕਰੋ:

• GitHub ਉਪਭੋਗਤਾ ਨਾਮ
• ਸੰਗਠਨ (ਤੁਸੀਂ ਕੰਮ ਕਰਦੇ ਹੋ ਜਾਂ ਅਧਿਐਨ ਕਰਦੇ ਹੋ)
• ਸਥਿਤੀ (ਤੁਹਾਡੀ ਸੰਸਥਾ ਵਿੱਚ ਤੁਹਾਡੀ ਅਸਲ ਸਥਿਤੀ, ਜਾਂ ਤਾਂ "ਵਿਦਿਆਰਥੀ" ਜਾਂ "ਸੁਤੰਤਰ")।
• ਦੇਸ਼ '

ਉਹਨਾਂ ਲਈ ਜਿਨ੍ਹਾਂ ਨੇ ਲੇਖ ਨੂੰ ਪੜ੍ਹਿਆ ਹੈ ਅਤੇ ਨਕਲੀ ਬੁੱਧੀ ਅਤੇ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਇੰਜਣਾਂ ਨੂੰ ਵਿਕਸਤ ਕਰਨ ਜਾਂ ਹੋਸਟ ਕਰਨ ਲਈ ਇੱਕ ਪਲੇਟਫਾਰਮ ਵਜੋਂ InterSystems IRIS ਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਵਿੱਚ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਨ, ਅਸੀਂ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਸੰਭਾਵੀ ਸਥਿਤੀਆਂ ਬਾਰੇ ਚਰਚਾ ਕਰਨ ਲਈ ਸੱਦਾ ਦਿੰਦੇ ਹਾਂ ਜੋ ਤੁਹਾਡੇ ਉੱਦਮ ਲਈ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹਨ। ਸਾਨੂੰ ਤੁਹਾਡੀ ਕੰਪਨੀ ਦੀਆਂ ਲੋੜਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਅਤੇ ਸਾਂਝੇ ਤੌਰ 'ਤੇ ਇੱਕ ਕਾਰਜ ਯੋਜਨਾ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਖੁਸ਼ੀ ਹੋਵੇਗੀ; ਸਾਡੀ AI/ML ਮਾਹਰ ਟੀਮ ਦਾ ਈਮੇਲ ਪਤਾ ਸੰਪਰਕ ਕਰੋ - [ਈਮੇਲ ਸੁਰੱਖਿਅਤ].

ਸਰੋਤ: www.habr.com