डीपचेक्स ट्यूटोरियल: मशीन लर्निंग टेस्टिंग का स्वचालन

इस ट्यूटोरियल में, हम DeepChecks के बारे में जानेंगे और इसका उपयोग करके डेटा वैलिडेशन और मशीन लर्निंग टेस्टिंग कैसे करें। हम GitHub Actions का उपयोग करके मॉडल टेस्टिंग को स्वचालित करेंगे और परिणामों को आर्टिफैक्ट्स के रूप में सहेजेंगे। 

आगे बढ़ते हुए, हम मशीन लर्निंग टेस्टिंग और DeepChecks के बारे में सीखेंगे, DeepChecks डेटा इंटीग्रिटी सूट चलाएँगे और एक विस्तृत रिपोर्ट बनाएँगे। हम मॉडल इवैल्युएशन सूट चलाकर मशीन लर्निंग टेस्टिंग रिपोर्ट भी जनरेट करेंगे, पूरी सूट की बजाय एक एकल परीक्षण चलाना सीखेंगे, GitHub Actions के साथ अपनी टेस्टिंग वर्कफ़्लो को स्वचालित करेंगे, और मशीन लर्निंग टेस्टिंग रिपोर्ट को GitHub Artifact के रूप में सहेजेंगे। 

चित्र: लेखक द्वारा

मशीन लर्निंग टेस्टिंग क्या है?

मशीन लर्निंग टेस्टिंग एक महत्त्वपूर्ण प्रक्रिया है जिसमें मशीन लर्निंग मॉडल्स के प्रदर्शन का मूल्यांकन और वैधता जाँचना शामिल है ताकि उनकी निष्पक्षता, सटीकता, और मजबूती सुनिश्चित की जा सके। यह सिर्फ मॉडल की एक्यूरेसी और परफॉर्मेंस तक सीमित नहीं है। हमें मॉडल बायस, फॉल्स पॉज़िटिव्स, फॉल्स नेगेटिव्स, विभिन्न प्रदर्शन मीट्रिक्स, मॉडल थ्रूपुट, और AI नैतिकता के साथ मॉडल संरेखण पर भी ध्यान देना होता है। 

टेस्टिंग प्रक्रिया में डेटा वैलिडेशन, क्रॉस-वैलिडेशन, F1-स्कोर, कन्फ्यूज़न मैट्रिक्स, प्रेडिक्शन ड्रिफ्ट, डेटा ड्रिफ्ट, और रोबस्टनेस टेस्टिंग जैसी विभिन्न जाँचें शामिल होती हैं, जिनका उद्देश्य मॉडल के प्रदर्शन और विश्वसनीयता के अलग-अलग पहलुओं को परखना होता है। 

हम अपने डेटासेट को तीन हिस्सों में भी बाँटते हैं ताकि प्रशिक्षण प्रक्रिया के दौरान और प्रशिक्षण के बाद अनदेखे डेटा पर मॉडल का मूल्यांकन किया जा सके। 

मशीन लर्निंग टेस्टिंग AI अनुप्रयोगों का एक अनिवार्य हिस्सा है, और इसे मॉडल प्रशिक्षण के साथ स्वचालित करने से हमें लोगों के लिए भरोसेमंद AI सिस्टम मिलते हैं।

यदि आप मशीन लर्निंग में नए हैं और बुनियादी बातें सीखना चाहते हैं, तो Machine Learning Fundamentals with Python स्किल ट्रैक करें। यह कोर्स Python के साथ मशीन लर्निंग की बुनियाद सिखाएगा, scikit-learn लाइब्रेरी का उपयोग करते हुए सुपरवाइज़्ड लर्निंग से शुरुआत करते हुए।

DeepChecks के साथ शुरुआत

DeepChecks एक ओपन-सोर्स Python पैकेज है, जिसे मशीन लर्निंग मॉडल्स और डेटा की व्यापक टेस्टिंग और वैलिडेशन को आसान बनाने के लिए डिज़ाइन किया गया है। यह मॉडल प्रदर्शन, डेटा डिस्ट्रीब्यूशन, डेटा इंटीग्रिटी आदि से संबंधित समस्याओं की पहचान करने के लिए कई बिल्ट-इन चेक प्रदान करता है। DeepChecks में सतत वैलिडेशन की क्षमताएँ भी शामिल हैं, जिससे वास्तविक-world परिनियोजन और उपयोग के दौरान मॉडल विश्वसनीय और प्रभावी बने रहते हैं।

हम pip कमांड का उपयोग करके Python पैकेज इंस्टॉल करने से शुरुआत करेंगे।

%pip install deepchecks --upgrade -qसंचालित द्वारा

डेटासेट लोड करना

इस ट्यूटोरियल के लिए, हम DataCamp डेटासेट्स से Loan Data का उपयोग कर रहे हैं। इसमें 9578 पंक्तियाँ हैं और ऋण संरचना, उधारकर्ता, तथा ऋण के पूर्ण भुगतान होने या न होने की जानकारी शामिल है।

Pandas का उपयोग करके CSV फ़ाइल लोड करें और शीर्ष 5 पंक्तियाँ प्रदर्शित करें।

import pandas as pd
loan_data = pd.read_csv("loan_data.csv")
loan_data.head()संचालित द्वारा

डेटासेट तैयार करना

Loan डेटासेट, लेबल कॉलम नाम, और श्रेणीबद्ध फीचर के नाम का उपयोग करके DeepChecks डेटासेट बनाएँ।

from sklearn.model_selection import train_test_split
from deepchecks.tabular import Dataset

label_col = 'not.fully.paid'

deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])संचालित द्वारा

DeepChecks डेटा इंटीग्रिटी सूट चलाना

हम टेब्युलर डेटा के लिए डेटा इंटीग्रिटी सूट का उपयोग करेंगे। सूट सभी टेस्ट स्वचालित रूप से चलाएगा और परिणामों के साथ एक इंटरैक्टिव रिपोर्ट जनरेट करेगा। 

इसके लिए, हम डेटा इंटीग्रिटी सूट आयात करेंगे, उसे इनिशिएट करेंगे, फिर DeepChecks लोन डेटा देकर सूट चलाएँगे। अंत में, हम परिणाम प्रदर्शित करेंगे।

from deepchecks.tabular.suites import data_integrity

integ_suite = data_integrity()
suite_result = integ_suite.run(deep_loan_data)
suite_result.show()संचालित द्वारा

नोट: हम DataLab को डेवलपर वातावरण के रूप में उपयोग कर रहे हैं। ipywidgets का उपयोग अक्षम है, जिससे परिणाम प्रदर्शित नहीं हो पाते। इसके बजाय, हम परिणाम को एक iframe के रूप में दिखाने के लिए 'show_in_iframe' फ़ंक्शन का उपयोग करेंगे। सभी स्तरों पर परिणाम समान रहेंगे।

suite_result.show_in_iframe()संचालित द्वारा

हमारी डेटा इंटीग्रिटी रिपोर्ट में इन परीक्षणों के परिणाम शामिल हैं:

• फ़ीचर-लेबल सहसंबंध
• फ़ीचर-फ़ीचर सहसंबंध
• कॉलम में एकल मान
• विशेष अक्षर
• मिश्रित नल मान
• मिश्रित डेटा प्रकार
• स्ट्रिंग असंगति
• डेटा डुप्लीकेट्स
• स्ट्रिंग लंबाई सीमा से बाहर
• परस्पर-विरोधी लेबल्स
• आउटलायर सैंपल डिटेक्शन

Jupyter Notebook में डेटा इंटीग्रिटी टेस्ट परिणाम। 

आप परिणामों को HTML फ़ाइल के रूप में सहेजकर अपने सहकर्मियों के साथ साझा भी कर सकते हैं। 

suite_result.save_as_html()संचालित द्वारा

'output.html'संचालित द्वारा

एकल परीक्षण चलाना

बड़े डेटासेट पर पूरी सूट चलाना कुशल नहीं होता, क्योंकि परिणाम जनरेट करने में अधिक समय लगता है। इसके बजाय, आप अपने डेटा से संबंधित कुछ व्यक्तिगत टेस्ट चला सकते हैं और अपनी रिपोर्ट स्वयं बना सकते हैं।

एकल परीक्षण चलाने के लिए, टेब्युलर चेक्स आयात करें, चेक को इनिशिएट करें, और DeepCheck लोन डेटा के साथ चलाएँ। उसके बाद, results.value फ़ंक्शन का उपयोग करके इंटरैक्टिव रिपोर्ट जनरेट करने के बजाय मान प्रदर्शित करें।

from deepchecks.tabular.checks import IsSingleValue, DataDuplicates

result = IsSingleValue().run(deep_loan_data)
result.valueसंचालित द्वारा

जैसा कि हम देख सकते हैं, यह प्रत्येक कॉलम में मौजूद अद्वितीय मानों की संख्या दिखाता है। 

{'credit.policy': 2,
 'purpose': 7,
 'int.rate': 249,
 'installment': 4788,
 'log.annual.inc': 1987,
 'dti': 2529,
 'fico': 44,
 'days.with.cr.line': 2687,
 'revol.bal': 7869,
 'revol.util': 1035,
 'inq.last.6mths': 28,
 'delinq.2yrs': 11,
 'pub.rec': 6,
 'not.fully.paid': 2}संचालित द्वारा

आइए अपने डेटा के भीतर डुप्लीकेट सैंपल की जाँच करने की कोशिश करें। 

result = DataDuplicates().run(deep_loan_data)
result.valueसंचालित द्वारा

हमारे डेटासेट में डुप्लीकेट्स की संख्या शून्य है। 

0.0संचालित द्वारा

DeepChecks के साथ मशीन लर्निंग टेस्टिंग

इस खंड में, हम कई मॉडलों का एन्सेम्बल बनाएँगे और उन्हें प्रोसेस किए गए लोन डेटासेट पर प्रशिक्षित करेंगे। फिर, मॉडल टेस्टिंग रिपोर्ट बनाने के लिए, हम प्रशिक्षण और परीक्षण डेटासेट्स पर मॉडल इवैल्युएशन सूट चलाएँगे। 

डेटा प्रोसेसिंग और मॉडल प्रशिक्षण

1. Scikit-learn लाइब्रेरी से आवश्यक फ़ंक्शंस आयात करें। 
2. डेटासेट को ट्रेन और टेस्ट सेट में विभाजित करें। 
3. श्रेणीबद्ध कॉलम 'purpose' को लेबल एन्कोडर का उपयोग करके संख्यात्मक में बदलें।
4. LogisticRegression, RandomForestClassifier, और GaussianNB मॉडल परिभाषित करें। 
5. वोटिंग क्लासिफ़ायर का उपयोग करके मॉडलों का एन्सेम्बल बनाएं। 
6. ट्रेनिंग सेट पर एन्सेम्बल मॉडल को प्रशिक्षित करें। 

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import VotingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder

# Train test split
df_train, df_test = train_test_split(loan_data, stratify=loan_data[label_col], random_state=0)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train['purpose'] = label_encoder.fit_transform(df_train['purpose'])
df_test['purpose'] = label_encoder.fit_transform(df_test['purpose'])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[('lr', model_1), ('rf', model_2), ('svc', model_3)],
    voting='soft'
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])संचालित द्वारा

मॉडल इवैल्युएशन सूट चलाना

हम मॉडल के प्रदर्शन का मूल्यांकन करने के लिए DeepChecks मॉडल इवैल्युएशन सूट चलाएँगे। 

7. ट्रेन और टेस्ट दोनों सेटों को DeepCheck डेटासेट में बदलें। 
8. मॉडल इवैल्युएशन इनिशिएट करें और उसे ट्रेन, टेस्ट सेट और मॉडल के साथ चलाएँ। 
9. परिणामों को iframe में दिखाएँ। 

from deepchecks.tabular.suites import model_evaluation

deep_train = Dataset(df_train, label=label_col, cat_features=[])
deep_test =  Dataset(df_test,  label=label_col, cat_features=[])

evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)
suite_result.show_in_iframe()संचालित द्वारा

हमारी मॉडल इवैल्युएशन रिपोर्ट में इन परीक्षणों के परिणाम शामिल हैं:

• ROC रिपोर्ट
• कमज़ोर सेगमेंट प्रदर्शन
• अप्रयुक्त फीचर्स
• ट्रेन-टेस्ट प्रदर्शन
• प्रेडिक्शन ड्रिफ्ट
• सिंपल मॉडल तुलना
• मॉडल इन्फ़रेंस समय
• कन्फ्यूज़न मैट्रिक्स रिपोर्ट
• आदि

10. परिणाम को JSON फ़ॉर्मेट में देखने के लिए to_json() फ़ंक्शन का उपयोग करें। 

suite_result.to_json()संचालित द्वारा

एकल परीक्षण चलाना

बिल्कुल डेटा वैलिडेशन की तरह, आप एकल मशीन लर्निंग टेस्ट भी चला सकते हैं। हमारे मामले में, हम ट्रेनिंग और टेस्ट स्प्लिट पर लेबल ड्रिफ्ट चलाएँगे ताकि जाँच सकें कि समय के साथ हमारे लेबल बदले हैं या नहीं। 

from deepchecks.tabular.checks import LabelDrift
check = LabelDrift()
result = check.run(deep_train, deep_test)
result.valueसंचालित द्वारा

डेटा में कोई ड्रिफ्ट नहीं पाई गई।

{'Drift score': 0.0, 'Method': "Cramer's V"}संचालित द्वारा

यदि आपको डेटा वैलिडेशन और मॉडल इवैल्युएशन सूट चलाने में कठिनाई हो रही है, तो कृपया DataLab वर्कस्पेस देखें: Machine Learning Testing with DeepChecks.

यदि आप "मैन्युअल" मशीन लर्निंग टेस्टिंग में रुचि रखते हैं, तो Machine Learning Experimentation ट्यूटोरियल देखें और Weights & Biases का उपयोग करते हुए अपने मशीन लर्निंग प्रयोगों को संरचित, लॉग और विश्लेषित करना सीखें।

GitHub Actions और DeepChecks का उपयोग करके मशीन लर्निंग टेस्टिंग का स्वचालन

आइए GitHub Actions के साथ डेटा वैलिडेशन, मॉडल प्रशिक्षण, और मॉडल इवैल्युएशन चरण को स्वचालित करें और परिणामों को zip फ़ाइल के रूप में सहेजें। 

मशीन लर्निंग टेस्टिंग का स्वचालन MLOps पाइपलाइन का अभिन्न हिस्सा है। इसके बारे में अधिक जानने के लिए MLOps Fundamentals स्किल ट्रैक करें। इस श्रृंखला में, आप मॉडल्स को प्रोडक्शन में डालने और उन्हें मॉनिटर करने के बुनियादी सिद्धांत सीखेंगे ताकि व्यावसायिक मूल्य प्रदान किया जा सके।

सेटअप

1. GitHub खाते पर जाएँ और आवश्यक जानकारी के साथ एक नया रिपोजिटरी बनाएं। 

2. रिपोजिटरी को लोकल सिस्टम पर क्लोन करें।
3. डायरेक्टरी को रिपोजिटरी पर बदलें। 
4. एक नया फ़ोल्डर “data” बनाएँ और "Downloads" फ़ोल्डर से लोन डेटा CSV फ़ाइल को रिपोजिटरी फ़ोल्डर में ले जाएँ। 
5. Python में डेटा वैलिडेशन बनाएं और VSCode (इंटीग्रेटेड डेवलपर एनवायरनमेंट) लॉन्च करें। 

$ cd C:\Repository\GitHub\
$ git clone https://github.com/kingabzpro/Automating-Machine-Learning-Testing.git

$ cd .\Automating-Machine-Learning-Testing\
$ mkdir data
$ mv -v ".Downloads\loan_data.csv" ".\Automating-Machine-Learning-Testing\data"
$ code -r data_validation.pyसंचालित द्वारा

डेटा वैलिडेशन फ़ाइल

6. डेटा वैलिडेशन फ़ाइल में, आप CSV फ़ाइल लोड करेंगे, उसे DeepChecks डेटासेट में बदलेंगे, डेटा इंटीग्रेशन सूट को इनिशिएट करेंगे, और उसे लोन डेटासेट पर चलाएँगे। 
7. नया फ़ोल्डर “results” बनाएँ और इसे HTML फ़ाइल के रूप में सहेजें। 

import pandas as pd
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import data_integrity

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Create a Deepchecks Dataset object with the loan data
deep_loan_data = Dataset(loan_data, label=label_col, cat_features=["purpose"])

# Initialize the data integrity suite
integ_suite = data_integrity()

# Run the data integrity suite on the dataset
suite_result = integ_suite.run(deep_loan_data)

# Save the results of the data integrity suite as an HTML file
suite_result.save_as_html("results/data_validation.html")संचालित द्वारा

मॉडल टेस्टिंग फ़ाइल

8. डेटा प्रोसेसिंग, मॉडल बिल्डिंग, प्रशिक्षण, और इवैल्युएशन सहित डेटा वैलिडेशन के लिए एक Python फ़ाइल बनाएँ। फ़ाइल में डेटासेट को DeepChecks डेटासेट में बदलना, मॉडल इवैल्युएशन सूट चलाना, और "results" फ़ोल्डर में उसे HTML फ़ाइल के रूप में सहेजना भी शामिल होना चाहिए।

$ code -r train_validation.pyसंचालित द्वारा

import pandas as pd
from sklearn.ensemble import RandomForestClassifier, VotingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from sklearn.preprocessing import LabelEncoder, StandardScaler
from deepchecks.tabular import Dataset
from deepchecks.tabular.suites import model_evaluation

# Load the loan data from a CSV file
loan_data = pd.read_csv("data/loan_data.csv")

# Define the label column
label_col = "not.fully.paid"

# Train test split
df_train, df_test = train_test_split(
    loan_data, stratify=loan_data[label_col], random_state=0
)

# Encode the 'purpose' column
label_encoder = LabelEncoder()
df_train["purpose"] = label_encoder.fit_transform(df_train["purpose"])
df_test["purpose"] = label_encoder.transform(df_test["purpose"])

# Standardize the features
scaler = StandardScaler()
df_train[df_train.columns.difference([label_col])] = scaler.fit_transform(df_train[df_train.columns.difference([label_col])])
df_test[df_test.columns.difference([label_col])] = scaler.transform(df_test[df_test.columns.difference([label_col])])

# Define models
model_1 = LogisticRegression(random_state=1, max_iter=10000)
model_2 = RandomForestClassifier(n_estimators=50, random_state=1)
model_3 = GaussianNB()

# Create the VotingClassifier
clf_model = VotingClassifier(
    estimators=[("lr", model_1), ("rf", model_2), ("gnb", model_3)], voting="soft"
)

# Train the model
clf_model.fit(df_train.drop(label_col, axis=1), df_train[label_col])

# Calculate the accuracy score using the .score function
accuracy = clf_model.score(df_test.drop(label_col, axis=1), df_test[label_col])

# Print the accuracy score
print(f"Accuracy: {accuracy:.2f}")

# Create Deepchecks datasets
deep_train = Dataset(df_train, label=label_col, cat_features=["purpose"])
deep_test = Dataset(df_test, label=label_col, cat_features=["purpose"])

# Run the evaluation suite
evaluation_suite = model_evaluation()
suite_result = evaluation_suite.run(deep_train, deep_test, clf_model)

# Save the results as HTML
suite_result.save_as_html("results/model_validation.html")संचालित द्वारा

GitHub Actions का उपयोग

यदि आप GitHub Actions में नए हैं, तो स्वचालन प्रक्रिया शुरू करने से पहले "GitHub Actions और MakeFile: एक हैंड्स-ऑन परिचय" ट्यूटोरियल पूरा करें। यह ट्यूटोरियल कोड उदाहरणों के साथ बताएगा कि GitHub Actions कैसे काम करता है।

9. GitHub Actions को इनिशिएट करने के लिए, आपको परिवर्तनों को स्टेज और कमिट करना है और उन्हें रिमोट GitHub रिपोजिटरी पर पुश करना है। 

$ git add .
$ git commit -m "Data and Validation files"  
$ git pushसंचालित द्वारा

10. GitHub रिपोजिटरी पर जाएँ, “Actions” टैब पर क्लिक करें और उसके बाद नीले टेक्स्ट “set up a workflow yourself” पर क्लिक करें। 

11. हमें वर्कफ़्लो main.yml फ़ाइल पर रीडायरेक्ट किया जाएगा। कृपया नीचे दिया गया कोड कॉपी-पेस्ट करें। यह कोड पहले एनवायरनमेंट सेटअप करेगा और DeepChecks पैकेज इंस्टॉल करेगा। उसके बाद यह फ़ोल्डर बनाएगा, डेटा वैलिडेशन और मॉडल इवैल्युएशन चलाएगा, और परिणामों को GitHub Artifact के रूप में सहेजेगा।

name: Model Training and Validation

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v4

      - name: Set up Python 3.10
        uses: actions/setup-python@v5
        with:
          python-version: '3.10'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install deepchecks
          
      - name: Create a folder
        run: |
          mkdir -p results
          
      - name: Validate Data
        run: |
          python data_validation.py
      - name: Validate Model Performance
        run: |
          python train_validation.py
      - name: Archive Deepchecks Results
        uses: actions/upload-artifact@v4
        if: always()
        with:
          name: deepchecks results
          path: results/*_validation.htmlसंचालित द्वारा

12. परिवर्तनों को संदेश सहित कमिट करें। 

मुख्य शाखा पर परिवर्तन कमिट करने से वर्कफ़्लो रन शुरू हो जाएगा। रन लॉग देखने के लिए, "Actions" टैब पर जाएँ और कमिट संदेश से संबंधित वर्तमान वर्कफ़्लो रन पर क्लिक करें।

13. वर्कफ़्लो रन पूरा हो जाने पर, कृपया नीचे स्क्रॉल करें और “Artifacts” अनुभाग के तहत zip फ़ाइल डाउनलोड करें।

14. zip फ़ाइल को लोकल रूप से खोलें और डेटा तथा मॉडल वैलिडेशन परिणाम देखें। 

कृपया मार्गदर्शिका के रूप में kingabzpro/Automating-Machine-Learning-Testing GitHub रिपोजिटरी देखें। इसमें डेटा, Python कोड, वर्कफ़्लो फ़ाइलें, और पूर्ण स्वचालित टेस्टिंग चलाने के लिए आवश्यक अन्य फ़ाइलें शामिल हैं। 

पूरी मशीन लर्निंग पाइपलाइन को स्वचालित करने के लिए विभिन्न प्रक्रियाओं और टूल्स का ज्ञान आवश्यक है। इनके बारे में सीखने के लिए MLOps Deployment and Lifecycle कोर्स करने पर विचार करें। यह कोर्स आधुनिक MLOps फ्रेमवर्क्स की पड़ताल करता है, विशेष रूप से मशीन लर्निंग मॉडलों के लाइफसाइकल और डिप्लॉयमेंट पर फोकस करते हुए।

निष्कर्ष

टेस्टिंग प्रक्रिया को स्वचालित करके, डेवलपर्स बड़े और जटिल डेटासेट्स पर मॉडलों की सटीकता और मजबूती को तेज़ी और कुशलता से वैलिडेट कर सकते हैं। स्वचालित टेस्टिंग शुरुआती चरण में ही डेटा असंगतियों, डेटा ड्रिफ्ट, और मॉडल बायस जैसी समस्याओं की पहचान करने में मदद करती है, जो मैनुअल टेस्टिंग से स्पष्ट नहीं होतीं। इससे समय की बचत होती है और मॉडल की निष्पक्ष एवं सटीक भविष्यवाणी करने की क्षमता बढ़ती है।

इस ट्यूटोरियल में, हमने मशीन लर्निंग टेस्टिंग और डेटा वैलिडेशन तथा मशीन लर्निंग टेस्टिंग के लिए DeepChecks का उपयोग करना सीखा। हमने डेटा और मॉडल टेस्टिंग को भी स्वचालित किया और GitHub Actions का उपयोग करके परिणामों को आर्टिफैक्ट्स के रूप में सहेजा। 

यदि आपको यह ट्यूटोरियल पसंद आया और आप मशीन लर्निंग में करियर शुरू करना चाहते हैं, तो Machine Learning Scientist with Python करियर ट्रैक में नामांकन करने पर विचार करें। सभी कोर्स 3 महीनों में पूर्ण करें और मशीन लर्निंग साइंटिस्ट की नौकरी के लिए आवश्यक कौशल हासिल करें।