ಸನ್ನಿವೇಶದ ಒಂದು ಅಂಶವು ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ರಚಿಸುತ್ತಿದೆ. ಇದು ನೈಜ ಜಗತ್ತಿನಲ್ಲಿ ಬಳಸಬಹುದಾದ ಮತ್ತು ಗ್ರಾಹಕರು ಮತ್ತು ಡೆವಲಪರ್ಗಳಿಗೆ ಲಭ್ಯವಿರಬೇಕು.
ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸಲು ಸರಳ ಮತ್ತು ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಮಾರ್ಗವೆಂದರೆ ಅವುಗಳನ್ನು REST API ನಲ್ಲಿ ಸೇರಿಸುವುದು.
FastAPI ಎಂಬ ಜನಪ್ರಿಯ ಲೈಬ್ರರಿಯೊಂದಿಗೆ, ನಾವು ಇಂದು ನಿಖರವಾಗಿ ಏನನ್ನು ಸಾಧಿಸುತ್ತೇವೆ.
ಆದರೆ, ಏನು FastAPI?
ಸಮಕಾಲೀನ ಪೈಥಾನ್ ಸಾಮರ್ಥ್ಯಗಳ ಲಾಭವನ್ನು ಪಡೆಯಲು FastAPI ಪೈಥಾನ್ ವೆಬ್ ಫ್ರೇಮ್ವರ್ಕ್ ಅನ್ನು ನೆಲದಿಂದ ರಚಿಸಲಾಗಿದೆ.
ಗ್ರಾಹಕರೊಂದಿಗೆ ಅಸಮಕಾಲಿಕ, ಏಕಕಾಲಿಕ ಸಂವಹನಕ್ಕಾಗಿ, ಇದು ASGI ಮಾನದಂಡಕ್ಕೆ ಬದ್ಧವಾಗಿದೆ, ಆದರೆ ಇದು WSGI ಅನ್ನು ಬಳಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ.
ಅಂತ್ಯಬಿಂದುಗಳು ಮತ್ತು ಮಾರ್ಗಗಳು ಎರಡೂ ಅಸಿಂಕ್ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಹೆಚ್ಚುವರಿಯಾಗಿ, FastAPI ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳ ಉತ್ಪಾದಕ ರಚನೆಯನ್ನು ಟೈಪ್-ಹಿಂಟೆಡ್, ಕ್ಲೀನ್, ಸಮಕಾಲೀನ ಪೈಥಾನ್ ಕೋಡ್ನಲ್ಲಿ ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
FastAPI ಯ ಮುಖ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭವೆಂದರೆ, ಹೆಸರೇ ಸೂಚಿಸುವಂತೆ, API ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ರಚಿಸುವುದು.
ಸಂವಾದಾತ್ಮಕ ಸ್ವಾಗ್ಗರ್ UI ಅನ್ನು ಒಳಗೊಂಡಿರುವ OpenAPI ಮಾನದಂಡವನ್ನು ಬಳಸುವುದು ಅಥವಾ JSON ನಂತೆ ಪೈಥಾನ್ ನಿಘಂಟಿನ ಡೇಟಾವನ್ನು ಒದಗಿಸುವುದು ಇದನ್ನು ಸಾಧಿಸಲು ಎರಡೂ ಸರಳ ಮಾರ್ಗಗಳಾಗಿವೆ. ಆದಾಗ್ಯೂ, FastAPI ಕೇವಲ API ಗಳಿಗೆ ಮಾತ್ರವಲ್ಲ.
Jinja2 ಟೆಂಪ್ಲೇಟ್ ಎಂಜಿನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಮಾಣಿತ ವೆಬ್ ಪುಟಗಳನ್ನು ನೀಡಲು ಮತ್ತು ವೆಬ್ ಫ್ರೇಮ್ವರ್ಕ್ ಮಾಡಬಹುದಾದ ಎಲ್ಲದರ ಜೊತೆಗೆ ವೆಬ್ಸಾಕೆಟ್ಗಳನ್ನು ಬಳಸುವ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಪೂರೈಸಲು ಇದನ್ನು ಬಳಸಬಹುದು.
ಈ ಲೇಖನದಲ್ಲಿ, ನಾವು ಸರಳವಾದ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ನಿಯೋಜಿಸಲು FastAPI ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಆರಂಭಿಸೋಣ.
FastAPI ಸ್ಥಾಪನೆ ಮತ್ತು ಮೊದಲ API ರಚನೆ
ಲೈಬ್ರರಿ ಮತ್ತು ASGI ಸರ್ವರ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ಮೊದಲು ಅಗತ್ಯವಿದೆ; ಯುವಿಕಾರ್ನ್ ಅಥವಾ ಹೈಪರ್ಕಾರ್ನ್ ಕೆಲಸ ಮಾಡುತ್ತದೆ. ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಟರ್ಮಿನಲ್ಗೆ ನಮೂದಿಸುವ ಮೂಲಕ ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:
ಈಗ 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 ನಿದರ್ಶನದಂತೆಯೇ ಅದೇ ಹೆಸರನ್ನು ಹೊಂದಿರಬೇಕು.
-reload ಅನ್ನು ಬಳಸುವ ಮೂಲಕ, ನೀವು ಮೊದಲಿನಿಂದ ಪ್ರಾರಂಭಿಸುವ ಬದಲು ಫೈಲ್ ಅನ್ನು ಉಳಿಸಿದಾಗ ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಲೋಡ್ ಮಾಡಲು ನೀವು API ಗೆ ಹೇಳುತ್ತೀರಿ.
ಈಗ ಬ್ರೌಸರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು https://127.0.0.1:8000 ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ; ಫಲಿತಾಂಶವು ಈ ಕೆಳಗಿನಂತೆ ಗೋಚರಿಸಬೇಕು:
FastAPI ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸರಳ API ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನೀವು ಈಗ ಅರ್ಥಮಾಡಿಕೊಂಡಿದ್ದೀರಿ.
ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸುವುದು ಮತ್ತು ತರಬೇತಿ ನೀಡುವುದು
ಯಾವುದೇ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸದೆ ಅಥವಾ ವಿಶ್ಲೇಷಿಸದೆ, ನಾವು ಸರಳ ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡುತ್ತೇವೆ. ಇವುಗಳು ಮಾದರಿಗಳ ನಿಯೋಜನೆಗೆ ಸಂಬಂಧಿಸಿಲ್ಲ ಮತ್ತು ಕೈಯಲ್ಲಿರುವ ವಿಷಯಕ್ಕೆ ಅನಿವಾರ್ಯವಲ್ಲ.
ಐರಿಸ್ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಆಧರಿಸಿದ ಮಾದರಿಯನ್ನು ಅದೇ ಬಳಸಿಕೊಂಡು ಸ್ಥಾಪಿಸಬಹುದು ನರಮಂಡಲ ಅನುಸ್ಥಾಪನ ವಿಧಾನ.
ಮತ್ತು ನಾವು ಅದನ್ನು ಮಾಡುತ್ತೇವೆ: ಡೌನ್ಲೋಡ್ ಮಾಡಿ ಐರಿಸ್ ಡೇಟಾಸೆಟ್ ಮತ್ತು ಮಾದರಿಯನ್ನು ತರಬೇತಿ ಮಾಡಿ. ಅದು ಸರಳವಾಗುವುದಿಲ್ಲ. ಪ್ರಾರಂಭಿಸಲು, jaysmlmodel.py ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ಮಾಡಿ.
ಅದರಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡುತ್ತೀರಿ:
- ಆಮದುಗಳು — ನಿಮಗೆ ಪಾಂಡಾಗಳು, scikit-RandomForecastClassifier, Learn's pydantic's BaseModel (ಏಕೆ ಎಂಬುದನ್ನು ಮುಂದಿನ ಹಂತದಲ್ಲಿ ನೀವು ಕಂಡುಕೊಳ್ಳುವಿರಿ) ಮತ್ತು ಮಾದರಿಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಲೋಡ್ ಮಾಡಲು ಜಾಬ್ಲಿಬ್ ಅಗತ್ಯವಿದೆ.
- ಮೂಲ ಮಾದರಿಯಿಂದ ಆನುವಂಶಿಕವಾಗಿ ಪಡೆಯುವ IrisSpecies ವರ್ಗವನ್ನು ಘೋಷಿಸಿ. ಈ ವರ್ಗವು ಒಂದೇ ಹೂವಿನ ಜಾತಿಗಳನ್ನು ಮುನ್ಸೂಚಿಸಲು ಅಗತ್ಯವಿರುವ ಕ್ಷೇತ್ರಗಳನ್ನು ಮಾತ್ರ ಒಳಗೊಂಡಿದೆ (ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಅದರ ಕುರಿತು ಇನ್ನಷ್ಟು)
- ಒಂದು ವರ್ಗವನ್ನು ರಚಿಸಿ. IrisModel ಒಂದು ಮಾದರಿ ತರಬೇತಿ ಮತ್ತು ಭವಿಷ್ಯ ಸಾಧನವಾಗಿದೆ.
- IrisModel ಒಳಗೆ _train model ಹೆಸರಿನ ವಿಧಾನವನ್ನು ಘೋಷಿಸಿ. ರಾಂಡಮ್ ಫಾರೆಸ್ಟ್ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಗಳನ್ನು ತರಬೇತಿ ಮಾಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ತರಬೇತಿ ಪಡೆದ ಮಾದರಿಯನ್ನು ಕಾರ್ಯವಿಧಾನದ ಮೂಲಕ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
- ಐರಿಸ್ಮಾಡೆಲ್ನೊಳಗೆ ಊಹಿಸಲಾದ ಜಾತಿಯ ಕಾರ್ಯವನ್ನು ಘೋಷಿಸಿ. 4 ಇನ್ಪುಟ್ ಅಂಶಗಳ (ಹೂವಿನ ಅಳತೆಗಳು) ಆಧಾರದ ಮೇಲೆ ಮುನ್ಸೂಚನೆ ನೀಡಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮುನ್ಸೂಚನೆ (ಹೂವಿನ ಜಾತಿಗಳು) ಮತ್ತು ಮುನ್ಸೂಚನೆಯ ಸಂಭವನೀಯತೆ ಎರಡನ್ನೂ ಅಲ್ಗಾರಿದಮ್ ಮೂಲಕ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.
- ಐರಿಸ್ಮಾಡೆಲ್ನಲ್ಲಿ ಕನ್ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬದಲಾಯಿಸಿ ಇದರಿಂದ ಅದು ಐರಿಸ್ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಫೋಲ್ಡರ್ನಿಂದ ಕಾಣೆಯಾಗಿದ್ದರೆ ಮಾದರಿಗೆ ತರಬೇತಿ ನೀಡುತ್ತದೆ. ಇದು ಹೊಸ ಮಾದರಿಗಳನ್ನು ಪದೇ ಪದೇ ತರಬೇತಿ ನೀಡುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಜಾಬ್ಲಿಬ್ ಲೈಬ್ರರಿಯನ್ನು ಮಾದರಿ ಲೋಡ್ ಮಾಡಲು ಮತ್ತು ಉಳಿಸಲು ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.
ಸಂಪೂರ್ಣ ಕೋಡ್ ಇಲ್ಲಿದೆ:
ಮೇಲಿನ ಪಟ್ಟಿ ಮತ್ತು ಕಾಮೆಂಟ್ಗಳು ಇದನ್ನು ರಚಿಸಲು ಸಾಕಷ್ಟು ಪ್ರಮಾಣದ ಕೋಡ್ ಆಗಿದ್ದರೂ ಸಹ ಗ್ರಹಿಸಲು ಸುಲಭವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಈಗ ಈ ಮಾದರಿಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ, ಅದರ ಮುನ್ಸೂಚನೆಯ ಸಾಮರ್ಥ್ಯಗಳನ್ನು a ಮೇಲೆ ಪ್ರಕಟಿಸೋಣ REST API ಅನ್ನು.
ಪೂರ್ಣ REST API ಅನ್ನು ನಿರ್ಮಿಸಲಾಗುತ್ತಿದೆ
ml_model.py ಫೈಲ್ಗೆ ಹಿಂತಿರುಗಿ ಮತ್ತು ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಶುದ್ಧೀಕರಿಸಿ. ಬಾಯ್ಲರ್ ಪ್ಲೇಟ್ ಮೂಲಭೂತವಾಗಿ ನೀವು ಮೊದಲು ಹೊಂದಿದ್ದಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ ನಾವು ಖಾಲಿ ಫೈಲ್ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಬೇಕು.
ನೀವು ಈ ಸಮಯದಲ್ಲಿ ಒಂದು ಅಂತಿಮ ಬಿಂದುವನ್ನು ಮಾತ್ರ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೀರಿ, ಇದು ಹೂವಿನ ಪ್ರಕಾರವನ್ನು ನಿರ್ಧರಿಸಲು ಬಳಸಲ್ಪಡುತ್ತದೆ. IrisModel.predict species() ಅನ್ನು ಹಿಂದಿನ ವಿಭಾಗದಲ್ಲಿ ಘೋಷಿಸಲಾಗಿದೆ, ಭವಿಷ್ಯವನ್ನು ಕೈಗೊಳ್ಳಲು ಈ ಅಂತಿಮ ಬಿಂದುವಿನಿಂದ ಕರೆಯಲಾಗುತ್ತದೆ.
ವಿನಂತಿಯ ಪ್ರಕಾರವು ಇತರ ದೊಡ್ಡ ಬದಲಾವಣೆಯಾಗಿದೆ. URL ಗಿಂತ JSON ನಲ್ಲಿ ನಿಯತಾಂಕಗಳನ್ನು ರವಾನಿಸಲು, ಬಳಸುವಾಗ ನೀವು POST ಅನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ ಯಂತ್ರ ಕಲಿಕೆ API ಗಳು.
ನೀವು a ಆಗಿದ್ದರೆ ಮೇಲಿನ ವಾಕ್ಯವು ದಡ್ಡತನದಂತೆ ತೋರಬಹುದು ಡೇಟಾ ವಿಜ್ಞಾನಿ, ಆದರೆ ಅದು ಸರಿ. ಮಾದರಿಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು, ಒಬ್ಬರು HTTP ವಿನಂತಿಗಳು ಮತ್ತು REST API ಗಳಲ್ಲಿ ಪರಿಣಿತರಾಗಿರಬೇಕಾಗಿಲ್ಲ.
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 ದಸ್ತಾವೇಜನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಮತ್ತು ವೀಕ್ಷಿಸುವುದು, ಹಾಗೆಯೇ ಅದನ್ನು ಪರೀಕ್ಷಿಸುವುದು ಹೇಗೆ ಎಂಬುದನ್ನು ಸಹ ನೀವು ಕಲಿತಿದ್ದೀರಿ.
ಒಂದೇ ತುಣುಕಿಗೆ ಇದು ಬಹಳಷ್ಟು, ಆದ್ದರಿಂದ ಸರಿಯಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಕೆಲವು ಓದುವಿಕೆಗಳನ್ನು ತೆಗೆದುಕೊಂಡರೆ ಆಶ್ಚರ್ಯಪಡಬೇಡಿ.
ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್.
ಪ್ರತ್ಯುತ್ತರ ನೀಡಿ