ਦ੍ਰਿਸ਼ ਦਾ ਇੱਕ ਪਹਿਲੂ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਮਾਡਲ ਬਣਾਉਣਾ ਹੈ। ਇਹ ਅਸਲ ਸੰਸਾਰ ਵਿੱਚ ਵਰਤੋਂ ਯੋਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਖਪਤਕਾਰਾਂ ਅਤੇ ਵਿਕਾਸਕਾਰਾਂ ਲਈ ਉਪਲਬਧ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਸਰਲ ਅਤੇ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਤਰੀਕਾ ਹੈ ਉਹਨਾਂ ਨੂੰ ਇੱਕ REST API ਵਿੱਚ ਨੱਥੀ ਕਰਨਾ।
FastAPI ਨਾਮ ਦੀ ਇੱਕ ਪ੍ਰਸਿੱਧ ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਨਾਲ, ਇਹ ਬਿਲਕੁਲ ਉਹੀ ਹੈ ਜੋ ਅਸੀਂ ਅੱਜ ਪੂਰਾ ਕਰਾਂਗੇ।
ਪਰ, ਕੀ ਹੈ FastAPI?
FastAPI ਪਾਈਥਨ ਵੈੱਬ ਫਰੇਮਵਰਕ ਨੂੰ ਸਮਕਾਲੀ ਪਾਈਥਨ ਸਮਰੱਥਾਵਾਂ ਦਾ ਲਾਭ ਲੈਣ ਲਈ ਜ਼ਮੀਨ ਤੋਂ ਬਣਾਇਆ ਗਿਆ ਸੀ।
ਗਾਹਕਾਂ ਨਾਲ ਅਸਿੰਕ੍ਰੋਨਸ, ਸਮਕਾਲੀ ਸੰਚਾਰ ਲਈ, ਇਹ ASGI ਸਟੈਂਡਰਡ ਦੀ ਪਾਲਣਾ ਕਰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਇਹ WSGI ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਵੀ ਹੈ।
ਐਂਡਪੁਆਇੰਟ ਅਤੇ ਰੂਟ ਦੋਵੇਂ ਅਸਿੰਕ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਨਿਯੁਕਤ ਕਰ ਸਕਦੇ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, FastAPI ਟਾਈਪ-ਇਸ਼ਾਰਾ, ਸਾਫ਼, ਸਮਕਾਲੀ ਪਾਈਥਨ ਕੋਡ ਵਿੱਚ ਵੈੱਬ ਐਪਸ ਦੀ ਉਤਪਾਦਕ ਰਚਨਾ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।
FastAPI ਦਾ ਮੁੱਖ ਵਰਤੋਂ ਕੇਸ ਹੈ, ਜਿਵੇਂ ਕਿ ਨਾਮ ਤੋਂ ਪਤਾ ਲੱਗਦਾ ਹੈ, API ਅੰਤਮ ਬਿੰਦੂ ਬਣਾਉਣਾ।
OpenAPI ਸਟੈਂਡਰਡ ਦੀ ਵਰਤੋਂ ਕਰਨਾ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਇੰਟਰਐਕਟਿਵ ਸਵੈਗਰ UI ਸ਼ਾਮਲ ਹੈ, ਜਾਂ JSON ਦੇ ਤੌਰ 'ਤੇ ਪਾਈਥਨ ਡਿਕਸ਼ਨਰੀ ਡੇਟਾ ਪ੍ਰਦਾਨ ਕਰਨਾ ਦੋਵੇਂ ਇਸ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਸਧਾਰਨ ਤਰੀਕੇ ਹਨ। ਹਾਲਾਂਕਿ, FastAPI ਸਿਰਫ API ਲਈ ਨਹੀਂ ਹੈ।
ਇਹ Jinja2 ਟੈਂਪਲੇਟ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਮਿਆਰੀ ਵੈਬ ਪੇਜਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਨ ਲਈ ਅਤੇ ਵੈਬ ਸਾਕੇਟਸ ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੇ ਐਪਸ ਦੀ ਸੇਵਾ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਇਸ ਤੋਂ ਇਲਾਵਾ ਹੋਰ ਸਭ ਕੁਝ ਇੱਕ ਵੈੱਬ ਫਰੇਮਵਰਕ ਕਰ ਸਕਦਾ ਹੈ।
ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਿੱਧਾ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਮਾਡਲ ਵਿਕਸਿਤ ਕਰਾਂਗੇ ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ FastAPI ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਆਓ ਸ਼ੁਰੂ ਕਰੀਏ।
FastAPI ਦੀ ਸਥਾਪਨਾ ਅਤੇ ਪਹਿਲੇ API ਦੀ ਰਚਨਾ
ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ASGI ਸਰਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਪਹਿਲਾਂ ਲੋੜੀਂਦਾ ਹੈ; ਜਾਂ ਤਾਂ Uvuicorn ਜਾਂ Hypercorn ਕੰਮ ਕਰੇਗਾ। ਇਹ ਟਰਮੀਨਲ ਵਿੱਚ ਹੇਠ ਦਿੱਤੀ ਕਮਾਂਡ ਦਾਖਲ ਕਰਕੇ ਕੰਮ ਕਰਦਾ ਹੈ:
ਹੁਣ ਜਦੋਂ API ਬਣਾਇਆ ਗਿਆ ਹੈ, ਤੁਸੀਂ ਆਪਣੇ ਪਸੰਦੀਦਾ ਕੋਡ ਸੰਪਾਦਕ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸ ਨੂੰ ਬ੍ਰਾਊਜ਼ ਕਰ ਸਕਦੇ ਹੋ। ਸ਼ੁਰੂਆਤ ਕਰਨ ਲਈ ml_model.py ਨਾਮ ਦੀ ਇੱਕ ਪਾਈਥਨ ਸਕ੍ਰਿਪਟ ਬਣਾਓ। ਤੁਹਾਡਾ ਇੱਕ ਵੱਖਰਾ ਨਾਮ ਦੇਣ ਲਈ ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ, ਪਰ ਇਸ ਪੋਸਟ ਦੀ ਖ਼ਾਤਰ, ਮੈਂ ਇਸ ਫਾਈਲ ਨੂੰ ml_model.py ਦੇ ਰੂਪ ਵਿੱਚ ਹਵਾਲਾ ਦੇਵਾਂਗਾ।
ਦੋ ਅੰਤਮ ਬਿੰਦੂਆਂ ਦੇ ਨਾਲ ਇੱਕ ਸਿੱਧਾ API ਬਣਾਉਣ ਲਈ, ਤੁਹਾਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕਾਰਜ ਪੂਰੇ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ:
- FastAPI ਅਤੇ Uvicorn ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਆਯਾਤ ਕਰੋ।
- ਇੱਕ FastAPI ਕਲਾਸ ਉਦਾਹਰਨ ਸੈਟ ਅਪ ਕਰੋ।
- ਪਹਿਲੇ ਰੂਟ ਦੀ ਘੋਸ਼ਣਾ ਕਰੋ, ਜੋ, ਸੂਚਕਾਂਕ ਪੰਨੇ 'ਤੇ, ਇੱਕ ਸਿੱਧਾ JSON ਵਸਤੂ ਪੈਦਾ ਕਰਦਾ ਹੈ।
- ਦੂਜੇ ਰੂਟ ਦੀ ਘੋਸ਼ਣਾ ਕਰੋ, ਜੋ ਇੱਕ ਕਸਟਮਾਈਜ਼ਡ ਸੰਦੇਸ਼ ਦੇ ਨਾਲ ਇੱਕ ਸਿੱਧਾ JSON ਵਸਤੂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਨਾਮ ਪੈਰਾਮੀਟਰ ਸਿੱਧੇ URL ਤੋਂ ਲਿਆ ਗਿਆ ਹੈ (ਉਦਾਹਰਨ ਲਈ, https://127.0.0.1:8000/Jay)।
- API ਨੂੰ ਚਲਾਉਣ ਲਈ Uvicorn ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਇਹਨਾਂ ਪੰਜ ਪੜਾਵਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਕੋਡ ਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਬਿੱਟ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ. ਇੱਕ ਸਧਾਰਨ API ਬਣਾਉਣਾ
ਸਭ ਹੋ ਗਿਆ! ਚਲੋ ਸਾਡੇ API ਨੂੰ ਤੁਰੰਤ ਲਾਂਚ ਕਰੀਏ। ਇਸ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ml model.py ਫਾਈਲ ਦੇ ਅੱਗੇ ਇੱਕ ਟਰਮੀਨਲ ਵਿੰਡੋ ਖੋਲ੍ਹੋ। ਅੱਗੇ, ਹੇਠ ਦਿੱਤੇ ਦਰਜ ਕਰੋ:
ਐਂਟਰ ਕੁੰਜੀ. ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇਸ ਦਾਅਵੇ ਨੂੰ ਖਤਮ ਕਰੀਏ। ਪਹਿਲੀ ਐਪ ਐਕਸਟੈਂਸ਼ਨ ਦੇ ਬਿਨਾਂ, ਇਕੱਲੇ ਪਾਈਥਨ ਫਾਈਲ ਨਾਮ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ। ਦੂਜੀ ਐਪ ਦਾ ਉਹੀ ਨਾਮ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਜੋ ਤੁਹਾਡੀ FastAPI ਉਦਾਹਰਨ ਹੈ।
-ਰੀਲੋਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ API ਨੂੰ ਦੱਸਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਜਦੋਂ ਤੁਸੀਂ ਸਕ੍ਰੈਚ ਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਬਜਾਏ ਫਾਈਲ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹੋ ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ ਰੀਲੋਡ ਹੋ ਜਾਵੇ।
ਹੁਣ ਇੱਕ ਬ੍ਰਾਊਜ਼ਰ ਲਾਂਚ ਕਰੋ ਅਤੇ https://127.0.0.1:8000 'ਤੇ ਨੈਵੀਗੇਟ ਕਰੋ; ਨਤੀਜਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ:
ਹੁਣ ਤੁਸੀਂ ਸਮਝ ਗਏ ਹੋ ਕਿ FastAPI ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਸਧਾਰਨ API ਕਿਵੇਂ ਬਣਾਇਆ ਜਾਵੇ।
ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਬਣਾਉਣਾ ਅਤੇ ਸਿਖਲਾਈ ਦੇਣਾ
ਕੋਈ ਵੀ ਡਾਟਾ ਇਕੱਠਾ ਜਾਂ ਵਿਸ਼ਲੇਸ਼ਣ ਕੀਤੇ ਬਿਨਾਂ, ਅਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਸਧਾਰਨ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਵਾਂਗੇ। ਇਹ ਮਾਡਲਾਂ ਦੀ ਤੈਨਾਤੀ ਨਾਲ ਸਬੰਧਤ ਨਹੀਂ ਹਨ ਅਤੇ ਵਿਸ਼ੇ ਲਈ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹਨ।
ਆਈਰਿਸ ਡੇਟਾਸੈਟ 'ਤੇ ਅਧਾਰਤ ਇੱਕ ਮਾਡਲ ਉਸੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਥਾਪਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਨਿਊਰਲ ਨੈਟਵਰਕ ਇੰਸਟਾਲੇਸ਼ਨ ਢੰਗ.
ਅਤੇ ਅਸੀਂ ਇਹੀ ਕਰਾਂਗੇ: ਡਾਊਨਲੋਡ ਕਰੋ ਆਈਰਿਸ ਡੇਟਾਸੈਟ ਅਤੇ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦਿਓ। ਇਹ ਸਧਾਰਨ ਨਹੀਂ ਹੋਵੇਗਾ। ਸ਼ੁਰੂ ਕਰਨ ਲਈ, jaysmlmodel.py ਨਾਮ ਦੀ ਇੱਕ ਫਾਈਲ ਬਣਾਓ।
ਇਸ ਵਿੱਚ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਕੰਮ ਕਰੋਗੇ:
- ਆਯਾਤ — ਤੁਹਾਨੂੰ ਪਾਂਡਾ, ਸਕਿਟ-ਰੈਂਡਮਫੋਰਕਾਸਟ ਕਲਾਸੀਫਾਇਰ, ਲਰਨਜ਼ ਪਾਈਡੈਂਟਿਕ ਦੇ ਬੇਸ ਮਾਡਲ (ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਪੜਾਅ ਵਿੱਚ ਪਤਾ ਲਗਾਓਗੇ ਕਿ ਕਿਉਂ) ਅਤੇ ਮਾਡਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਲੋਡ ਕਰਨ ਲਈ ਜੌਬਲਿਬ ਦੀ ਲੋੜ ਪਵੇਗੀ।
- ਇੱਕ IrisSpecies ਕਲਾਸ ਘੋਸ਼ਿਤ ਕਰੋ ਜੋ ਬੇਸ ਮਾਡਲ ਤੋਂ ਵਿਰਾਸਤ ਵਿੱਚ ਮਿਲਦੀ ਹੈ। ਇਸ ਕਲਾਸ ਵਿੱਚ ਸਿਰਫ਼ ਇੱਕ ਫੁੱਲ ਸਪੀਸੀਜ਼ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਲੋੜੀਂਦੇ ਖੇਤਰ ਸ਼ਾਮਲ ਹਨ (ਅਗਲੇ ਭਾਗ ਵਿੱਚ ਇਸ ਬਾਰੇ ਹੋਰ)
- ਇੱਕ ਕਲਾਸ ਬਣਾਓ। IrisModel ਇੱਕ ਮਾਡਲ ਸਿਖਲਾਈ ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਟੂਲ ਹੈ।
- IrisModel ਦੇ ਅੰਦਰ _train ਮਾਡਲ ਨਾਮਕ ਵਿਧੀ ਦਾ ਐਲਾਨ ਕਰੋ। ਇਹ ਰੈਂਡਮ ਫੋਰੈਸਟ ਤਕਨੀਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਡਲਾਂ ਨੂੰ ਸਿਖਲਾਈ ਦੇਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲ ਵਿਧੀ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.
- IrisModel ਦੇ ਅੰਦਰ ਇੱਕ ਅਨੁਮਾਨਿਤ ਸਪੀਸੀਜ਼ ਫੰਕਸ਼ਨ ਦਾ ਐਲਾਨ ਕਰੋ। ਇਸਦੀ ਵਰਤੋਂ 4 ਇਨਪੁਟ ਕਾਰਕਾਂ (ਫੁੱਲਾਂ ਦੇ ਮਾਪ) ਦੇ ਅਧਾਰ ਤੇ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਪੂਰਵ ਅਨੁਮਾਨ (ਫੁੱਲਾਂ ਦੀਆਂ ਕਿਸਮਾਂ) ਅਤੇ ਭਵਿੱਖਬਾਣੀ ਸੰਭਾਵਨਾ ਦੋਵੇਂ ਐਲਗੋਰਿਦਮ ਦੁਆਰਾ ਵਾਪਸ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
- IrisModel ਵਿੱਚ ਕੰਸਟਰਕਟਰ ਨੂੰ ਬਦਲੋ ਤਾਂ ਜੋ ਇਹ Iris ਡੇਟਾਸੈਟ ਨੂੰ ਲੋਡ ਕਰੇ ਅਤੇ ਮਾਡਲ ਨੂੰ ਸਿਖਲਾਈ ਦੇਵੇ ਜੇਕਰ ਇਹ ਫੋਲਡਰ ਵਿੱਚੋਂ ਗੁੰਮ ਹੈ। ਇਹ ਨਵੇਂ ਮਾਡਲਾਂ ਨੂੰ ਵਾਰ-ਵਾਰ ਸਿਖਲਾਈ ਦੇਣ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ. ਜੌਬਲਿਬ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਮਾਡਲ ਲੋਡਿੰਗ ਅਤੇ ਸੇਵਿੰਗ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇੱਥੇ ਪੂਰਾ ਕੋਡ ਹੈ:
ਮੈਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਉਪਰੋਕਤ ਸੂਚੀ ਅਤੇ ਟਿੱਪਣੀਆਂ ਨੇ ਇਸਨੂੰ ਸਮਝਣਾ ਆਸਾਨ ਬਣਾ ਦਿੱਤਾ ਹੈ ਭਾਵੇਂ ਇਹ ਬਣਾਉਣ ਲਈ ਕੋਡ ਦੀ ਇੱਕ ਵੱਡੀ ਮਾਤਰਾ ਸੀ. ਹੁਣ ਜਦੋਂ ਇਹ ਮਾਡਲ ਵਿਕਸਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਆਓ ਇਸਦੀ ਪੂਰਵ ਅਨੁਮਾਨ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਏ REST API.
ਇੱਕ ਪੂਰਾ REST API ਬਣਾਉਣਾ
ml_model.py ਫਾਈਲ 'ਤੇ ਵਾਪਸ ਜਾਓ ਅਤੇ ਸਾਰਾ ਡਾਟਾ ਸਾਫ਼ ਕਰੋ। ਬਾਇਲਰਪਲੇਟ ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਉਹੀ ਹੋਵੇਗਾ ਜੋ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਸੀ, ਪਰ ਸਾਨੂੰ ਇੱਕ ਖਾਲੀ ਫਾਈਲ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
ਤੁਸੀਂ ਇਸ ਵਾਰ ਸਿਰਫ਼ ਇੱਕ ਅੰਤ ਬਿੰਦੂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋਗੇ, ਜੋ ਕਿ ਫੁੱਲ ਦੀ ਕਿਸਮ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। IrisModel.predict species(), ਜਿਸਨੂੰ ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਘੋਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਸੀ, ਨੂੰ ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ ਇਸ ਅੰਤਮ ਬਿੰਦੂ ਦੁਆਰਾ ਬੁਲਾਇਆ ਜਾਂਦਾ ਹੈ।
ਬੇਨਤੀ ਦੀ ਕਿਸਮ ਹੋਰ ਵੱਡੀ ਤਬਦੀਲੀ ਹੈ। URL ਦੀ ਬਜਾਏ JSON ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ, ਇਹ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਤੁਸੀਂ POST ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਮਸ਼ੀਨ ਸਿਖਲਾਈ APIs।
ਉਪਰੋਕਤ ਵਾਕ ਸ਼ਾਇਦ ਅਜੀਬ ਜਿਹਾ ਲੱਗਾ ਹੋਵੇ ਜੇਕਰ ਤੁਸੀਂ ਏ ਡਾਟਾ ਵਿਗਿਆਨੀ, ਪਰ ਇਹ ਠੀਕ ਹੈ। ਮਾਡਲਾਂ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰਨ ਅਤੇ ਲਾਗੂ ਕਰਨ ਲਈ, ਕਿਸੇ ਨੂੰ HTTP ਬੇਨਤੀਆਂ ਅਤੇ REST APIs 'ਤੇ ਮਾਹਰ ਹੋਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ।
ml model.py ਲਈ ਕੰਮ ਕੁਝ ਅਤੇ ਸਿੱਧੇ ਹਨ:
- ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਬਣਾਈ ਗਈ jaymlmodel.py ਫਾਈਲ ਤੋਂ ਹੇਠ ਲਿਖਿਆਂ ਨੂੰ ਆਯਾਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ: uvicorn, FastAPI, IrisModel, ਅਤੇ IrisSpecies।
- FastAPI ਅਤੇ IrisModel ਦੀਆਂ ਉਦਾਹਰਣਾਂ ਬਣਾਓ।
- ਭਵਿੱਖਬਾਣੀ ਕਰਨ ਲਈ https://127.0.0.1:8000/predict 'ਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਘੋਸ਼ਿਤ ਕਰੋ।
- IrisModel.predict species() ਵਿਧੀ IrisSpecies ਕਿਸਮ ਦੀ ਇੱਕ ਵਸਤੂ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ, ਇਸਨੂੰ ਇੱਕ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਬਦਲਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਇਸਨੂੰ ਵਾਪਸ ਕਰਦੀ ਹੈ। ਰਿਟਰਨ ਸੰਭਾਵਿਤ ਸ਼੍ਰੇਣੀ ਅਤੇ ਅਨੁਮਾਨਿਤ ਸੰਭਾਵਨਾ ਹਨ।
- API ਨੂੰ ਚਲਾਉਣ ਲਈ uvicorn ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਫਿਰ ਵੀ, ਇੱਥੇ ਪੂਰੀ ਫਾਈਲ ਦਾ ਕੋਡ ਇਸ ਦੀਆਂ ਟਿੱਪਣੀਆਂ ਦੇ ਨਾਲ ਹੈ:
ਇਹ ਸਭ ਤੁਹਾਨੂੰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਅਗਲੇ ਪੜਾਅ ਵਿੱਚ, ਆਓ API ਦੀ ਜਾਂਚ ਕਰੀਏ।
API ਦੀ ਜਾਂਚ ਕਰ ਰਿਹਾ ਹੈ
API ਨੂੰ ਚਲਾਉਣ ਲਈ ਹੇਠਲੀ ਲਾਈਨ ਨੂੰ ਟਰਮੀਨਲ ਵਿੱਚ ਦੁਬਾਰਾ ਦਾਖਲ ਕਰੋ: uvicorn ml_model:app –reload
ਦਸਤਾਵੇਜ਼ੀ ਪੰਨਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
ਇਸ ਲਈ ਇਹ ਅੱਜ ਲਈ ਹੈ। ਇਸ ਤੋਂ ਬਾਅਦ ਦੇ ਹਿੱਸੇ ਵਿੱਚ, ਆਓ ਸਮਾਪਤ ਕਰੀਏ.
ਸਿੱਟਾ
ਅੱਜ, ਤੁਸੀਂ ਇੱਕ ਸਧਾਰਨ API ਉਦਾਹਰਨ ਅਤੇ ਇੱਕ ਸਧਾਰਨ ਮਸ਼ੀਨ ਸਿਖਲਾਈ ਉਦਾਹਰਨ ਦੋਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, FastAPI ਕੀ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਿਵੇਂ ਵਰਤਣਾ ਹੈ ਬਾਰੇ ਸਿੱਖਿਆ ਹੈ। ਤੁਸੀਂ ਇਹ ਵੀ ਸਿੱਖਿਆ ਹੈ ਕਿ API ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਣਾ ਅਤੇ ਵੇਖਣਾ ਹੈ, ਨਾਲ ਹੀ ਇਸਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰਨੀ ਹੈ।
ਇਹ ਇੱਕ ਸਿੰਗਲ ਟੁਕੜੇ ਲਈ ਬਹੁਤ ਕੁਝ ਹੈ, ਇਸ ਲਈ ਹੈਰਾਨ ਨਾ ਹੋਵੋ ਜੇਕਰ ਇਸਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਮਝਣ ਲਈ ਕੁਝ ਰੀਡਿੰਗਾਂ ਲੱਗਦੀਆਂ ਹਨ।
ਹੈਪੀ ਕੋਡਿੰਗ।
ਕੋਈ ਜਵਾਬ ਛੱਡਣਾ