గ్రిడ్ శోధన యొక్క ప్రయోజనాలు
- ఆటోమేటెడ్ హైపర్‌పారామీటర్ ట్యూనింగ్: గ్రిడ్ శోధన హైపర్‌పారామీటర్ ట్యూనింగ్‌ను ఆటోమేట్ చేస్తుంది, ఇది మాన్యువల్ ట్రయల్ మరియు ఎర్రర్ లేకుండా క్రమబద్ధమైన అన్వేషణను అనుమతిస్తుంది.
- పునరుత్పత్తి: కమ్యూనికేషన్ మరియు విశ్వసనీయతను పెంచే పునరుత్పాదక ఫలితాలను పునరుత్పత్తి చేయడం ద్వారా గ్రిడ్ శోధన పరీక్ష చెల్లుబాటును నిర్ధారిస్తుంది.
- సమగ్ర శోధన: కలయికలను సమగ్రంగా శోధించడం ద్వారా GS మోడల్ కోసం సరైన హైపర్‌పారామీటర్‌లను సమర్ధవంతంగా కనుగొంటుంది.
- దృఢత్వం: గ్రిడ్ శోధన అనేది డేటా నాయిస్‌కు నిరోధకతను కలిగి ఉండే ఒక బలమైన టెక్నిక్, ఇది ఓవర్ ఫిట్టింగ్‌ను తగ్గిస్తుంది.
- ఉపయోగించడానికి సులభమైనది: గ్రిడ్ శోధనను ఉపయోగించడం మరియు అర్థం చేసుకోవడం సులభం, ఇది హైపర్‌పారామీటర్ ట్యూనింగ్‌కు ఆచరణీయమైన పద్ధతిగా చేస్తుంది.
- మోడల్ పోలికలు: గ్రిడ్ శోధన మోడల్ పోలిక మరియు మూల్యాంకన కొలమానాల ఎంపికను సులభతరం చేస్తుంది.
గ్రిడ్ శోధన యొక్క లోపాలు
- గణన ఖర్చు: పెద్ద సంఖ్యలో హైపర్‌పారామీటర్‌లను ట్యూన్ చేయడానికి గ్రిడ్ శోధన గణనపరంగా ఖరీదైనది.
- సమయం తీసుకుంటుంది: సంక్లిష్టమైన హైపర్‌పారామీటర్ సర్దుబాట్లకు ఇది సమయం తీసుకుంటుంది.
- ఎల్లప్పుడూ అవసరం లేదు: ఇది ఇప్పుడు ఎల్లప్పుడూ అవసరం; యాదృచ్ఛిక శోధన దీనికి ఉత్తమ ప్రత్యామ్నాయం.
ఉదాహరణ: యూనివర్సిటీ అడ్మిషన్ సిస్టమ్ కోసం ఉత్తమ మోడల్ సెట్టింగ్‌లను కనుగొనడం
ఆన్‌లైన్ యూనివర్శిటీ అడ్మిషన్ సిస్టమ్ ఫ్రేమ్‌వర్క్ లోపల హైపర్‌పారామీటర్ ట్యూనింగ్ కోసం గ్రిడ్ శోధన ఉదాహరణను చూద్దాం. ఈ ఉదాహరణలో, GPA పాయింట్‌లు, SAT స్కోర్లు, ACT స్కోర్లు మరియు పాఠ్యేతర కార్యకలాపాలు వంటి అంశాల ఆధారంగా విశ్వవిద్యాలయానికి విద్యార్థి అంగీకరించబడే అవకాశాన్ని అంచనా వేయడానికి మేము స్కికిట్-లెర్న్ మరియు స్ట్రెయిట్ గ్రేడియంట్ బూస్టింగ్ క్లాసిఫైయర్ (GBC) వర్గీకరణను ఉపయోగిస్తాము. లాజిస్టిక్ రిగ్రెషన్ (LR), SVM (సపోర్ట్ వెక్టర్ మెషిన్) మొదలైన వాటితో సహా GBCకి బదులుగా గ్రిడ్ శోధన కోసం బహుళ ఎంపికలు అందుబాటులో ఉన్నాయి.
గ్రిడ్ శోధన కోసం MLflow ఉపయోగించి ఆన్‌లైన్ అడ్మిషన్ సిస్టమ్ కోసం యాదృచ్ఛిక డేటాను రూపొందించండి
అడ్మిషన్ సిస్టమ్ కోసం కల్పిత డేటాసెట్‌ను రూపొందించడానికి పైథాన్ యొక్క పాండాలు మరియు యాదృచ్ఛిక ప్యాకేజీలను ఉపయోగించవచ్చు. APP_NO, GPA, SAT స్కోర్, ACT స్కోర్, ఎక్స్‌ట్రా కరిక్యులర్ యాక్టివిటీస్ మరియు అడ్మిషన్ స్టేటస్ కాలమ్‌ల కోసం యాదృచ్ఛిక విలువలతో, ఈ కోడ్ సింథటిక్ అడ్మిషన్ డేటాసెట్‌ను రూపొందిస్తుంది. num_students వేరియబుల్ డేటాసెట్‌లో ఎన్ని అడ్డు వరుసలు ఉన్నాయో నియంత్రిస్తుంది.
అడ్మిషన్ స్టేటస్ యాదృచ్ఛికంగా 70% అంగీకార రేటు ఆధారంగా సెట్ చేయబడింది మరియు యాదృచ్ఛిక మాడ్యూల్ అనేక నిలువు వరుసల కోసం యాదృచ్ఛిక విలువలను ఉత్పత్తి చేయడానికి ఉపయోగించబడుతుంది. ప్రదర్శన ప్రయోజనాల కోసం, కింది కోడ్ ముక్క యాదృచ్ఛిక విలువలతో నకిలీ అడ్మిషన్ డేటాసెట్‌ను సృష్టిస్తుంది మరియు std_admission_dataset.csv ఫైల్‌లో సేవ్ చేయబడుతుంది:
కోడ్ స్నిప్పెట్:
# పాండా మరియు రాండమ్ లైబ్రరీలను దిగుమతి చేయండి
పాండాలను panda_objగా దిగుమతి చేయండి
యాదృచ్ఛికంగా random_objగా దిగుమతి చేయండి
# విద్యార్థి డేటాసెట్ రూపొందించడానికి రికార్డ్‌ల సంఖ్యను సెట్ చేయండి
విద్యార్థులు_రికార్డులు = 1000
# డేటాను నిల్వ చేయడానికి జాబితాలను సృష్టించండి
std_application_numbers = [ 'APP-' + str(random_obj.randint( 1000 , 9999 ) కోసం _ పరిధిలో (స్టూడెంట్స్_రికార్డ్స్)]
std_gpa = [రౌండ్(random_obj.uniform( 2.5 , 4.0 ), 2 _ పరిధిలో (స్టూడెంట్స్_రికార్డ్స్)]
std_sat_scores = [random_obj.randint( 900 , 1600 _ పరిధిలో (స్టూడెంట్స్_రికార్డ్స్)]
std_act_scores = [random_obj.randint( ఇరవై , 36 _ పరిధిలో (స్టూడెంట్స్_రికార్డ్స్)]
std_extra_curriculars = [random_obj.choice([ 'అవును' , 'లేదు' ]) కోసం _ పరిధిలో(స్టూడెంట్స్_రికార్డ్స్)]
# యాదృచ్ఛిక అంగీకార రేటు ఆధారంగా ప్రవేశ స్థితిని లెక్కించండి
std_admission_status = [ 1 random_obj.random() < అయితే 0.7 లేకపోతే 0 కోసం _ పరిధిలో (స్టూడెంట్స్_రికార్డ్స్)]
# విద్యార్థి డేటాను ఉంచడానికి నిఘంటువును సృష్టించండి
std_data = {
'APPLICATION_NO' : std_application_NUMBERs,
'GPA' : std_gpa,
'SAT_స్కోర్' : std_sat_స్కోర్లు,
'ACT_స్కోర్' : std_act_స్కోర్లు,
'ఇతరేతర వ్యాపకాలు' : std_extra_curriculars,
'అడ్మిషన్_స్టేటస్' : std_admission_status
}
# నిఘంటువు నుండి DataFrame DataFrame_Studentని సృష్టించండి
DataFrame_Student = panda_obj.DataFrame(std_data)
# DataFrame DataFrame_Studentని std_admission_dataset.csv అనే CSV ఫైల్‌కి సేవ్ చేయండి
DataFrame_Student.to_csv( 'std_admission_dataset.csv' , సూచిక=తప్పు)
ముద్రణ( 'విద్యార్థి డేటా విజయవంతంగా CSV ఫైల్‌కి ఎగుమతి చేయబడింది!' )
కోడ్ అమలు:
కోడ్‌ను కంపైల్ చేయడానికి పైథాన్ ఆదేశాన్ని ఉపయోగించండి, ఆపై మీరు మాడ్యూల్ దోషాన్ని ఎదుర్కొంటే నిర్దిష్ట మాడ్యూల్‌ను ఇన్‌స్టాల్ చేయడానికి పిప్ ఆదేశాన్ని ఉపయోగించండి. పైథాన్ వెర్షన్ 3.X లేదా అంతకంటే ఎక్కువ అయితే ఇచ్చిన లైబ్రరీని ఇన్‌స్టాల్ చేయడానికి pip3 ఇన్‌స్టాల్ ఆదేశాన్ని ఉపయోగించండి.
విజయవంతమైన అమలు:
నమూనా డేటా స్క్రీన్‌షాట్:
దశ 1: లైబ్రరీలను దిగుమతి చేయండి
- యంత్ర అభ్యాస ప్రయోగం ట్రాకింగ్ కోసం MLflow లైబ్రరీ
- డేటా ప్రాసెసింగ్ మరియు విశ్లేషణను నిర్వహించడానికి పాండాస్ లైబ్రరీ, అలాగే స్కికిట్-లెర్న్ మోడల్‌లను ఏకీకృతం చేయడానికి mlflow.sklearn ప్యాకేజీ.
- నాల్గవ లైన్ లోపాలను అణిచివేసేందుకు 'హెచ్చరికలు' లైబ్రరీని దిగుమతి చేస్తుంది
- sklearn.model_selection మాడ్యూల్‌లో గ్రిడ్ శోధన కోసం పారామీటర్‌గ్రిడ్ క్లాస్
- గ్రిడ్ శోధన మరియు గ్రేడియంట్ బూస్టింగ్ వర్గీకరణ నమూనాల కోసం వరుసగా sklearn.model_selection మరియు సమిష్టి నుండి GridSearchCV మరియు GradientBoostingClassifier
- మోడల్ ఖచ్చితత్వాన్ని లెక్కించడానికి మరియు వర్గీకరణ నివేదికలను రూపొందించడానికి sklearn.metrics మాడ్యూల్ నుండి ఖచ్చితత్వం_స్కోర్ మరియు వర్గీకరణ_నివేదిక విధులు
- కోడ్ OS మాడ్యూల్‌ను దిగుమతి చేస్తుంది మరియు GIT_PYTHON_REFRESH ఎన్విరాన్‌మెంట్ వేరియబుల్‌ని నిశ్శబ్దంగా సెట్ చేస్తుంది.
కోడ్ స్నిప్పెట్:
# దశ-I అవసరమైన లైబ్రరీలను దిగుమతి చేయండిmlflow దిగుమతి
దిగుమతి mlflow.sklearn
హెచ్చరికగా దిగుమతి హెచ్చరికలు
పాండాలను panda_objగా దిగుమతి చేయండి
sklearn.model_selection దిగుమతి train_test_split tts, ParameterGrid pg, GridSearchCV gscv
మమ్మల్ని దిగుమతి చేసుకోండి
GBC వలె sklearn.ensemble దిగుమతి GradientBoostingClassifier నుండి
sklearn.metrics నుండి ఖచ్చితత్వం_స్కోర్‌ని acsగా దిగుమతి చేయండి, వర్గీకరణ_నివేదిక cr వలె
os.environ[ 'GIT_PYTHON_REFRESH' ] = 'నిశ్శబ్ద'
దశ 2: ట్రాకింగ్ URIని సెట్ చేయండి
MLflow సర్వర్ యొక్క ట్రాకింగ్ URI mlflow.set_tracking_uri() ఫంక్షన్‌ని ఉపయోగించి సెట్ చేయబడింది, ప్రయోగాలు మరియు మోడల్‌ల కోసం పోర్ట్ 5000లో లోకల్ మెషీన్‌ని నిర్ధారిస్తుంది.
mlflow.set_tracking_uri( 'http://localhost:5000' )దశ 3: అడ్మిషన్ డేటాసెట్‌ను లోడ్ చేసి, సిద్ధం చేయండి
డేటా మానిప్యులేషన్ మరియు విశ్లేషణ కోసం పాండాస్ లైబ్రరీని panda_objగా దిగుమతి చేయండి. అడ్మిషన్ డేటాసెట్‌ను లోడ్ చేయడానికి read_csv() ఫంక్షన్ వర్తించబడుతుంది. రీడ్_csv() ఫంక్షన్‌కు అవసరమైన ఏకైక ఆర్గ్యుమెంట్ డేటాసెట్‌కు మార్గం. ఈ సందర్భంలో డేటాసెట్‌కి మార్గం std_admission_dataset.csv. read_csv() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా, డేటాసెట్ పాండాస్ డేటాఫ్రేమ్‌లోకి లోడ్ చేయబడుతుంది.
std_admissions_data DataFrame నుండి Admission_Status నిలువు వరుస మొదట కోడ్ ద్వారా తీసివేయబడుతుంది. ఈ నిలువు వరుస లక్ష్య వేరియబుల్‌ని కలిగి ఉన్నందున, ప్రీప్రాసెసింగ్ అవసరం లేదు.
అప్పుడు, కోడ్ రెండు కొత్త వేరియబుల్స్‌ను సృష్టిస్తుంది: “F” మరియు “t”. లక్షణాలు “F” వేరియబుల్‌లో ఉంటాయి, అయితే టార్గెట్ వేరియబుల్ “t” వేరియబుల్‌లో ఉంటుంది.
డేటా తర్వాత పరీక్ష మరియు శిక్షణా సెట్లలో పంపిణీ చేయబడుతుంది. ఇది sklearn.model_selection ప్యాకేజీ నుండి tts() ఫంక్షన్‌ని ఉపయోగించి సాధించబడుతుంది. లక్షణాలు, టార్గెట్ వేరియబుల్, పరీక్ష పరిమాణం మరియు యాదృచ్ఛిక స్థితి tts() ఫంక్షన్‌కు అవసరమైన నాలుగు ఆర్గ్యుమెంట్‌లు. test_size పరామితి పరీక్ష ప్రయోజనాల కోసం ఉపయోగించబడే డేటా యొక్క భాగాన్ని నిర్దేశిస్తుంది. ఈ సందర్భంలో పరీక్ష పరిమాణం 0.2కి సెట్ చేయబడినందున, 20% డేటా పరీక్ష కోసం ఉపయోగించబడుతుంది.
random_state ఎంపిక యాదృచ్ఛిక సంఖ్య జనరేటర్ సీడ్‌ను నిర్దేశిస్తుంది. డేటా యాదృచ్ఛికంగా వేరు చేయబడిందని నిర్ధారించుకోవడానికి ఇది జరుగుతుంది. శిక్షణ మరియు పరీక్ష సెట్‌లు ఇప్పుడు F_training, F_testing, t_training మరియు t_testing వేరియబుల్స్‌లో నిల్వ చేయబడ్డాయి. యంత్ర అభ్యాస నమూనాలను మూల్యాంకనం చేయడానికి మరియు శిక్షణ ఇవ్వడానికి ఈ సెట్‌లను ఉపయోగించవచ్చు.
కోడ్ స్నిప్పెట్:
# దశ-3: అడ్మిషన్ డేటాసెట్‌ను లోడ్ చేయండిstd_admissions_data = panda_obj.read_csv( 'std_admission_dataset.csv' )
# డేటాను ప్రీప్రాసెస్ చేయండి మరియు ఫీచర్లు (F) మరియు టార్గెట్ (t)గా విభజించండి
F = std_admissions_data.drop([ 'అడ్మిషన్_స్టేటస్' ], అక్షం= 1 )
t = std_admissions_data[ 'అడ్మిషన్_స్టేటస్' ]
# వన్-హాట్ ఎన్‌కోడింగ్‌ని ఉపయోగించి వర్గీకరణ వేరియబుల్‌లను సంఖ్యాపరంగా మార్చండి
F = panda_obj.get_dummies(F)
F_training, F_testing, t_training, t_testing = tts(F, t, test_size= 0.2 , random_state= 42 )
దశ 4: MLflow ప్రయోగం పేరును సెట్ చేయండి
adm_experiment_name = 'యూనివర్శిటీ_అడ్మిషన్_ప్రయోగం'mlflow.set_experiment(adm_experiment_name)
దశ 5: గ్రేడియంట్ బూస్టింగ్ వర్గీకరణను నిర్వచించండి
గ్రేడియంట్ బూస్టింగ్ క్లాసిఫైయర్ మోడల్ ఇప్పుడు gbc_obj వేరియబుల్‌లో నిల్వ చేయబడింది. ఈ మోడల్‌ను పరీక్షించడానికి మరియు శిక్షణ ఇవ్వడానికి అడ్మిషన్ డేటాసెట్‌ను ఉపయోగించవచ్చు. రాండమ్_స్టేట్ ఆర్గ్యుమెంట్ విలువ 42. ఇది ఫలితాలను పునరావృతమయ్యేలా చేసే ఖచ్చితమైన రాండమ్ నంబర్ జనరేటర్ సీడ్‌ని ఉపయోగించి మోడల్ శిక్షణ పొందిందని ఇది హామీ ఇస్తుంది.
gbc_obj = GBC(random_state= 42 )దశ 6: హైపర్‌పారామీటర్ గ్రిడ్‌ను నిర్వచించండి
కోడ్ ప్రారంభంలో param_grid నిఘంటువుని సృష్టిస్తుంది. గ్రిడ్ శోధన ద్వారా సర్దుబాటు చేయబడిన హైపర్‌పారామీటర్‌లు ఈ నిఘంటువులో ఉంటాయి. మూడు కీలు param_grid నిఘంటువును తయారు చేస్తాయి: n_estimators, learning_rate మరియు max_depth. ఇవి గ్రేడియంట్-బూస్టింగ్ క్లాసిఫైయర్ మోడల్ యొక్క హైపర్‌పారామీటర్‌లు. మోడల్‌లోని చెట్ల సంఖ్య హైపర్‌పారామీటర్ n_ఎస్టిమేటర్‌ల ద్వారా పేర్కొనబడింది. మోడల్ లెర్నింగ్ రేట్ లెర్నింగ్_రేట్ హైపర్‌పారామీటర్ ద్వారా పేర్కొనబడింది. హైపర్‌పారామీటర్ max_depth మోడల్ చెట్ల యొక్క అత్యధిక లోతును నిర్వచిస్తుంది.
కోడ్ స్నిప్పెట్:
param_grid = {'n_estimators' :[ 100 , 150 , 200 ],
'లెర్నింగ్_రేట్' :[ 0.01 , 0.1 , 0.2 ],
'గరిష్ట_లోతు' :[ 4 , 5 , 6 ]
}
దశ 7: MLflow ట్రాకింగ్‌తో గ్రిడ్ శోధనను జరుపుము
కోడ్ అప్పుడు param_grid నిఘంటువుపై పునరావృతమవుతుంది. డిక్షనరీలోని ప్రతి హైపర్‌పారామీటర్‌ల కోసం, కోడ్ కింది వాటిని చేస్తుంది:
- కొత్త MLflow రన్‌ను ప్రారంభిస్తుంది
- హైపర్‌పారామీటర్‌లు ఇప్పటికే జాబితా కానట్లయితే వాటిని జాబితాగా మారుస్తుంది
- హైపర్‌పారామీటర్‌లను MLflowకి లాగ్ చేస్తుంది
- పేర్కొన్న హైపర్‌పారామీటర్‌లతో గ్రిడ్ శోధన మోడల్‌కు శిక్షణ ఇస్తుంది
- గ్రిడ్ శోధన నుండి ఉత్తమ మోడల్‌ను పొందుతుంది
- ఉత్తమ మోడల్‌గా పని చేస్తున్న పరీక్ష డేటాపై అంచనాలను చేస్తుంది
- మోడల్ యొక్క ఖచ్చితత్వాన్ని గణిస్తుంది
- హైపర్‌పారామీటర్‌లు, ఖచ్చితత్వం మరియు వర్గీకరణ నివేదికను ప్రింట్ చేస్తుంది
- MLflowకి ఖచ్చితత్వం మరియు మోడల్‌ను లాగ్ చేస్తుంది
కోడ్ స్నిప్పెట్:
warn.catch_warnings():warn.filterwarnings( 'పట్టించుకోకుండా' , వర్గం=యూజర్ వార్నింగ్, మాడ్యూల్= '.* డిస్టిటిల్.*' )
pg(param_grid)లోని పారామ్‌ల కోసం:
mlflow.start_run(run_name=తో 'అడ్మిషన్స్_స్టేటస్ రన్' ):
# ఒకే విలువలను జాబితాలుగా మార్చండి
params = {key: [value] కాకపోతే instance(విలువ, జాబితా) కీ కోసం వేరే విలువ, params.items()}లో విలువ
mlflow.log_params(పరాములు)
grid_search = gscv(gbc_obj, param_grid=params, cv= 5 )
grid_search.fit(F_training, t_training)
std_best_model = grid_search.best_estimator_
model_predictions = std_best_model.predict(F_testing)
model_accuracy_score = acs(t_testing, model_predictions)
ముద్రణ( 'హైపర్‌పారామీటర్‌లు:' , పారాములు)
ముద్రణ( 'ఖచ్చితత్వం:' , model_accuracy_score)
# నిర్వచించబడని మెట్రిక్ హెచ్చరికను స్పష్టంగా విస్మరించండి
warn.catch_warnings():
warn.filterwarnings( 'పట్టించుకోకుండా' , వర్గం=హెచ్చరిక)
ముద్రణ( 'వర్గీకరణ నివేదిక:' )
ప్రింట్(cr(t_testing, model_predictions, zero_division= 1 ))
mlflow.log_metric( 'ఖచ్చితత్వం' , model_accuracy_score)
mlflow.sklearn.log_model(std_best_model, 'gb_classifier_model' )
దశ 8: పైథాన్ ఉపయోగించి ప్రోగ్రామ్‌ను అమలు చేయండి
MLflow సర్వర్‌లో అవుట్‌పుట్ ఇక్కడ ఉంది:
ముగింపు
MLflow యొక్క గ్రిడ్ శోధన సాధనం ట్వీకింగ్, ఫలితాలను ట్రాక్ చేయడం మరియు మెషిన్ లెర్నింగ్ మోడల్‌లలో హైపర్‌పారామీటర్‌లను సవరించడాన్ని ఆటోమేట్ చేస్తుంది. ఇది ఆదర్శ హైపర్‌పారామీటర్‌లను గుర్తించడంలో సహాయపడుతుంది మరియు నమ్మదగిన ఫలితాలను నిర్ధారిస్తుంది కానీ విస్తృతమైన హైపర్‌పారామీటర్ ప్రయోగాలకు గణనపరంగా ఖరీదైనది కావచ్చు.