మెషీన్ లెర్నింగ్ మోడల్ని సృష్టించడం అనేది దృష్టాంతంలోని ఒక అంశం. ఇది వాస్తవ ప్రపంచంలో ఉపయోగించదగినదిగా ఉండాలి మరియు వినియోగదారులు మరియు డెవలపర్లకు అందుబాటులో ఉండాలి.
మెషీన్ లెర్నింగ్ మోడల్లను అమలు చేయడానికి సులభమైన మరియు అత్యంత ప్రజాదరణ పొందిన మార్గం వాటిని REST APIలో చేర్చడం.
FastAPI అని పిలవబడే ప్రసిద్ధ లైబ్రరీతో, ఈ రోజు మనం సాధించబోయేది అదే.
కానీ, ఏమిటి FastAPI?
సమకాలీన పైథాన్ సామర్థ్యాలను సద్వినియోగం చేసుకోవడానికి FastAPI పైథాన్ వెబ్ ఫ్రేమ్వర్క్ గ్రౌండ్ నుండి సృష్టించబడింది.
క్లయింట్లతో అసమకాలిక, ఏకకాలిక కమ్యూనికేషన్ కోసం, ఇది ASGI ప్రమాణానికి కట్టుబడి ఉంటుంది, అయితే ఇది WSGIని ఉపయోగించగల సామర్థ్యాన్ని కలిగి ఉంటుంది.
ఎండ్పాయింట్లు మరియు మార్గాలు రెండూ అసమకాలిక ఫంక్షన్లను ఉపయోగించగలవు. అదనంగా, FastAPI టైప్-హింటెడ్, క్లీన్, కాంటెంపరరీ పైథాన్ కోడ్లో వెబ్ యాప్ల ఉత్పాదక సృష్టిని అనుమతిస్తుంది.
FastAPI యొక్క ప్రధాన వినియోగ సందర్భం, పేరు సూచించినట్లుగా, API ముగింపు పాయింట్లను సృష్టించడం.
ఇంటరాక్టివ్ స్వాగర్ UIని కలిగి ఉన్న OpenAPI ప్రమాణాన్ని ఉపయోగించడం లేదా JSONగా పైథాన్ నిఘంటువు డేటాను అందించడం రెండూ దీన్ని సాధించడానికి సులభమైన మార్గాలు. అయితే, FastAPI అనేది APIల కోసం మాత్రమే కాదు.
ఇది జింజా2 టెంప్లేట్ ఇంజిన్ని ఉపయోగించి ప్రామాణిక వెబ్ పేజీలను అందించడానికి మరియు వెబ్ ఫ్రేమ్వర్క్ చేయగల అన్నిటితో పాటు వెబ్సాకెట్లను ఉపయోగించి యాప్లను అందించడానికి ఉపయోగించవచ్చు.
ఈ కథనంలో, మేము సరళమైన మెషీన్ లెర్నింగ్ మోడల్ను అభివృద్ధి చేస్తాము మరియు దానిని అమలు చేయడానికి 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 ఉదాహరణకి అదే పేరును కలిగి ఉండాలి.
-reloadని ఉపయోగించడం ద్వారా, మీరు మొదటి నుండి ప్రారంభించకుండా ఫైల్ను సేవ్ చేసినప్పుడు అది స్వయంచాలకంగా రీలోడ్ కావాలని మీరు APIకి చెబుతారు.
ఇప్పుడు బ్రౌజర్ను ప్రారంభించి, https://127.0.0.1:8000కి నావిగేట్ చేయండి; ఫలితం క్రింది విధంగా కనిపించాలి:
FastAPIని ఉపయోగించి సాధారణ APIని ఎలా సృష్టించాలో మీరు ఇప్పుడు అర్థం చేసుకున్నారు.
మెషిన్ లెర్నింగ్ మోడల్ను రూపొందించడం మరియు శిక్షణ ఇవ్వడం
ఏ డేటాను సేకరించకుండా లేదా విశ్లేషించకుండా, మేము కేవలం ఒక సాధారణ మోడల్కు శిక్షణ ఇస్తాము. ఇవి మోడల్ల విస్తరణకు సంబంధం లేనివి మరియు చేతిలో ఉన్న అంశానికి అవసరం లేదు.
ఐరిస్ డేటాసెట్ ఆధారంగా ఒక మోడల్ను అదే ఉపయోగించి ఇన్స్టాల్ చేయవచ్చు నాడీ నెట్వర్క్ సంస్థాపన పద్ధతి.
మరియు మేము దీన్ని చేస్తాము: డౌన్లోడ్ చేయండి ఐరిస్ డేటాసెట్ మరియు మోడల్కు శిక్షణ ఇవ్వండి. అది సామాన్యమైనది కాదు. ప్రారంభించడానికి, jaysmlmodel.py అనే ఫైల్ను రూపొందించండి.
అందులో, మీరు ఈ క్రింది వాటిని చేస్తారు:
- దిగుమతులు — మీకు పాండాలు, స్కికిట్-రాండమ్ఫోర్కాస్ట్క్లాసిఫైయర్, నేర్చుకునే పైడాంటిక్ బేస్ మోడల్ (మీరు క్రింది దశలో ఎందుకు కనుగొంటారు) మరియు మోడల్లను నిల్వ చేయడానికి మరియు లోడ్ చేయడానికి జాబ్లిబ్ అవసరం.
- బేస్ మోడల్ నుండి వారసత్వంగా పొందే IrisSpecies తరగతిని ప్రకటించండి. ఈ తరగతి ఒకే పూల జాతులను అంచనా వేయడానికి అవసరమైన ఫీల్డ్లను మాత్రమే కలిగి ఉంది (తదుపరి విభాగంలో దాని గురించి మరిన్ని)
- తరగతిని సృష్టించండి. IrisModel ఒక మోడల్ శిక్షణ మరియు అంచనా సాధనం.
- IrisModel లోపల _train మోడల్ పేరుతో ఒక పద్ధతిని ప్రకటించండి. ఇది రాండమ్ ఫారెస్ట్ టెక్నిక్ ఉపయోగించి మోడల్లకు శిక్షణ ఇవ్వడానికి ఉపయోగించబడుతుంది. శిక్షణ పొందిన మోడల్ ప్రక్రియ ద్వారా తిరిగి ఇవ్వబడుతుంది.
- IrisModel లోపల ఊహించిన జాతుల పనితీరును ప్రకటించండి. ఇది 4 ఇన్పుట్ కారకాల (పువ్వుల కొలతలు) ఆధారంగా అంచనా వేయడానికి ఉపయోగించబడుతుంది. సూచన (పుష్ప జాతులు) మరియు అంచనా సంభావ్యత రెండూ అల్గోరిథం ద్వారా అందించబడతాయి.
- ఐరిస్ మోడల్లో కన్స్ట్రక్టర్ను మార్చండి, తద్వారా ఇది ఐరిస్ డేటాసెట్ను లోడ్ చేస్తుంది మరియు ఫోల్డర్లో కనిపించకపోతే మోడల్కు శిక్షణ ఇస్తుంది. ఇది కొత్త మోడళ్లకు పదేపదే శిక్షణ ఇచ్చే సమస్యను పరిష్కరిస్తుంది. జాబ్లిబ్ లైబ్రరీ మోడల్ లోడింగ్ మరియు సేవ్ కోసం ఉపయోగించబడుతుంది.
ఇక్కడ మొత్తం కోడ్ ఉంది:
ఇది సృష్టించడానికి గణనీయమైన మొత్తంలో కోడ్ అయినప్పటికీ ఎగువ జాబితా మరియు వ్యాఖ్యలు సులభంగా గ్రహించాయని నేను ఆశిస్తున్నాను. ఇప్పుడు ఈ మోడల్ అభివృద్ధి చేయబడింది, దాని అంచనా సామర్థ్యాలను a పై ప్రచురిద్దాము REST API.
పూర్తి REST APIని నిర్మిస్తోంది
ml_model.py ఫైల్కి తిరిగి వెళ్లి, మొత్తం డేటాను ప్రక్షాళన చేయండి. బాయిలర్ప్లేట్ తప్పనిసరిగా మీరు ఇంతకు ముందు కలిగి ఉన్న దానిలాగే ఉంటుంది, కానీ మేము ఖాళీ ఫైల్తో ప్రారంభించాలి.
మీరు ఈసారి ఒక ముగింపు బిందువును మాత్రమే నిర్వచిస్తారు, ఇది పువ్వు రకాన్ని నిర్ణయించడానికి ఉపయోగించబడుతుంది. IrisModel.predict species(), ఇది మునుపటి విభాగంలో ప్రకటించబడింది, ఇది అంచనాను అమలు చేయడానికి ఈ ముగింపు స్థానం ద్వారా పిలువబడుతుంది.
అభ్యర్థన రకం ఇతర పెద్ద మార్పు. URL కాకుండా JSONలో పారామితులను ప్రసారం చేయడానికి, మీరు ఉపయోగిస్తున్నప్పుడు POSTని ఉపయోగించాలని సిఫార్సు చేయబడింది యంత్ర అభ్యాసం API లు.
మీరు ఒక అయితే పై వాక్యం అస్పష్టంగా అనిపించి ఉండవచ్చు డేటా సైంటిస్ట్, కానీ అది సరే. మోడల్లను రూపొందించడానికి మరియు అమలు చేయడానికి, ఒకరు తప్పనిసరిగా 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 డాక్యుమెంటేషన్ను ఎలా సృష్టించాలో మరియు వీక్షించాలో అలాగే దాన్ని ఎలా పరీక్షించాలో కూడా నేర్చుకున్నారు.
ఒక్క ముక్కకు ఇది చాలా ఎక్కువ, కాబట్టి సరిగ్గా అర్థం చేసుకోవడానికి కొన్ని రీడింగులను తీసుకుంటే ఆశ్చర్యపోకండి.
హ్యాపీ కోడింగ్.
సమాధానం ఇవ్వూ