OpenAI o1-preview ट्यूटोरियल: एक मशीन लर्निंग प्रोजेक्ट बनाना

इस ट्यूटोरियल में, हम शुरू से एक वाटर क्वालिटी क्लासिफायर एप्लिकेशन बनाएंगे और उसे Docker का उपयोग करके क्लाउड पर डिप्लॉय करेंगे।

हम OpenAI o1 मॉडल का अन्वेषण करने और इसकी कार्यक्षमता समझने से शुरुआत करेंगे। इसके बाद हम API और ChatGPT के माध्यम से मॉडल तक पहुँचेंगे, o1-preview और o1-mini दोनों संस्करणों के साथ प्रयोग करेंगे, और फिर वाटर क्वालिटी क्लासिफायर एप्लिकेशन बनाने के लिए प्रभावी प्रॉम्प्ट विकसित करेंगे।

आउटपुट मिलने के बाद, हम o1 मॉडल द्वारा दिए गए कोड और फाइलों को प्रोजेक्ट फोल्डर में जोड़ेंगे और फिर लोकली Python कोड चलाकर लोड, प्रीप्रोसेस, ट्रेन और इवैल्यूएट करेंगे। अंत में, हम एक FastAPI एप्लिकेशन बनाएंगे और उसे Docker का उपयोग करके Hugging Face पर डिप्लॉय करेंगे।

यदि आप AI में नए हैं, तो AI Fundamentals स्किल ट्रैक शुरू करने के लिए बेहतरीन जगह है। इससे आपको ChatGPT और बड़े भाषा मॉडलों जैसे लोकप्रिय AI विषयों के बारे में सीखने में मदद मिलेगी।

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

OpenAI का o1 रीजनिंग मॉडल क्या है?

OpenAI ने o1 मॉडल पेश किया है, जो मनुष्यों जैसे तर्क कार्य करने के लिए डिज़ाइन किया गया नया AI है—जैसे बहु-चरण समस्याओं का समाधान, जटिल गणितीय समीकरण, और कोडिंग प्रश्न।

कठिन प्रश्न का उत्तर देने से पहले, o1 समस्या को हल करने की कोशिश करते समय चेन ऑफ थॉट का उपयोग करता है। रीइन्फोर्समेंट लर्निंग के माध्यम से, o1 अपनी चेन ऑफ थॉट को निखारता है और अपनी रणनीतियों को परिष्कृत करता है। यह अपनी गलतियों को पहचानना और सुधारना सीखता है।

o1 मॉडल दो वेरिएंट में उपलब्ध है: o1-preview और o1-mini।

o1-preview का उपयोग गहन तर्क संबंधी प्रश्नों के लिए किया जाता है, जबकि o1-mini एक तेज़ मॉडल है जो कोडिंग और गणित समस्याओं के लिए उपयुक्त है। दोनों मॉडल ChatGPT Plus और Team उपयोगकर्ताओं के लिए उपलब्ध हैं। यदि आप टियर 5 संगठन हैं, तो आप उन्हें OpenAI API के माध्यम से भी एक्सेस कर सकते हैं।

मॉडल का वर्तमान संस्करण वेब ब्राउज़िंग, फाइल अपलोडिंग और Python REPL जैसी सुविधाओं से वंचित है, जिन्हें OpenAI भविष्य के अपडेट में जोड़ने की योजना बना रहा है।

स्रोत: Learning to Reason with LLMs | OpenAI

जैसा कि हम देख सकते हैं, o1-preview और o1 मॉडल नए बेंचमार्क स्थापित कर रहे हैं। उन्होंने गणित और कोडिंग प्रतियोगिताओं में उत्कृष्ट प्रदर्शन किया है और Ph.D. छात्रों के विज्ञान संबंधी प्रश्नों को संभाल सकते हैं।

विस्तृत विश्लेषण और यह जानने के लिए कि यह कैसे काम करता है तथा इसके बेंचमार्क क्या हैं, OpenAI o1 गाइड: कैसे काम करता है, उपयोग के मामले, API और अधिक पढ़ें।

o1-preview और o1-mini के साथ शुरुआत

o1 मॉडल तक पहुँचने के कई आसान तरीके हैं, लेकिन आधिकारिक तरीके या तो OpenAI API के माध्यम से हैं या ChatGPT Plus या Team सदस्यता का उपयोग करके।

इस खंड में, हम सीखेंगे कि हम उनका उपयोग जटिल समस्याएँ सुलझाने के लिए कैसे कर सकते हैं।

o1 मॉडल तक पहुँच

यदि आप चैट कम्प्लीशन के लिए OpenAI API से परिचित हैं, तो आपको मॉडल का नाम "o1-preview" सेट करना है और विस्तृत प्रॉम्प्ट देना है। बस इतना ही सरल है।

from openai import OpenAI
client = OpenAI()

response = client.chat.completions.create(
    model="o1-preview",
    messages=[
        {
            "role": "user", 
            "content": "Create an SQL database from scratch, including guides on usage and code everything in Python."
        }
    ]
)

print(response.choices[0].message.content)संचालित द्वारा

ChatGPT पर इसे एक्सेस करने के लिए, आपको मॉडल चयन ड्रॉपडाउन विकल्प पर क्लिक करना होगा और नीचे दिखाए अनुसार “o1-preview” मॉडल चुनना होगा।

ChatGPT में o1-preview मॉडल का उपयोग

o1 मॉडल के प्रॉम्प्ट अलग तरह के होते हैं। इसकी पूरी क्षमता को पाने के लिए आपको इसे कई निर्देश या विस्तृत प्रश्न देने होते हैं। यह लंबे और जटिल निर्देश लेकर एक इष्टतम उत्तर जनरेट कर सकता है।

यूरोप में फ्रीलांस व्यवसाय के लिए टैक्स की गणना जटिल हो सकती है। हम स्पेनिश सरकार के प्रति अपनी कर देनदारी निर्धारित करने के लिए o1 मॉडल का उपयोग करेंगे।

प्रॉम्प्ट: “मैं स्पेन में एक फ्रीलांसर हूँ और एक अमेरिकी कंपनी के लिए काम करता/करती हूँ। पिछले वर्ष मैंने 120,000 USD कमाए हैं, और मुझे यह गणना करनी है कि मुझे कितना टैक्स देना है। कृपया यह ध्यान में रखें कि मैं 8 महीने पहले स्पेन आया/आई हूँ।”

उत्तर आने में लगभग 30 सेकंड लगे, लेकिन प्रतिक्रिया विस्तृत थी। इसमें गणितीय समीकरण, कर संबंधी जानकारी, और स्पेनिश सरकार को कितनी राशि देनी है यह निर्धारित करने के लिए सभी आवश्यक विवरण शामिल थे।

प्रतिक्रिया निम्नलिखित भागों में विभाजित थी:

अपनी कर निवास स्थिति निर्धारित करें
अपनी आय को यूरो में बदलें
अपनी कर योग्य आय की गणना करें
सामाजिक सुरक्षा अंशदान की गणना करें
कुल अनुमानित देय कर
महत्वपूर्ण टिप्पणियाँ
अगले कदम

सारांश अनुभाग की समीक्षा करने से हमें सरकार को देय अनुमानित कर राशि मिल जाती है, जो काफी सहायक है।

आप चैट प्रतिक्रिया में ड्रॉप-डाउन मेनू पर क्लिक करके चेन ऑफ थॉट और निर्णय-प्रक्रिया देख सकते हैं।

हम देख सकते हैं कि मॉडल आपके प्रश्न का उत्तर देने से पहले संदर्भ, कर निहितार्थ और कर ब्रैकेट को समझता है।

ChatGPT में o1-mini मॉडल का उपयोग

o1-mini मॉडल, o1-preview की तुलना में कम सटीक लेकिन तेज़ है। हमारे मामले में, हम इस मॉडल का उपयोग डेटा साइंस रेज़्यूमे के लिए एक स्टैटिक वेबसाइट बनाने के लिए करेंगे।

प्रॉम्प्ट: “कृपया मेरे डेटा साइंस रेज़्यूमे के लिए किसी Python फ्रेमवर्क का उपयोग करके एक स्टैटिक वेबसाइट बनाएं।”

इसने न केवल एक उपयुक्त रेज़्यूमे वेबसाइट बनाई, बल्कि हमें इसे GitHub Pages पर निःशुल्क प्रकाशित करने के तरीके पर मार्गदर्शन भी दिया।

प्रतिक्रिया निम्न भागों में विभाजित थी:

Pelican का परिचय
पूर्वापेक्षाएँ
Pelican सेटअप करना
थीम चुनना
अपना रेज़्यूमे कंटेंट बनाना
साइट बनाना
Makefile के साथ ऑटोमेशन
अपनी रेज़्यूमे वेबसाइट डिप्लॉय करना
अपनी रेज़्यूमे वेबसाइट को बेहतर बनाना
अतिरिक्त संसाधन

प्रतिक्रिया में चेन ऑफ थॉट दिखाना एक शानदार सुविधा है। हम स्पष्ट रूप से देख सकते हैं कि मॉडल एक वेब फ्रेमवर्क के रूप में Pelican, Flask, या Hugo में से किसी का उपयोग करने पर विचार कर रहा है। अंत में, इसने सबसे बेहतर समाधान चुना।

OpenAI o1-preview ट्यूटोरियल: वाटर क्वालिटी क्लासिफायर एप्लिकेशन बनाना

इस प्रोजेक्ट में, हम o1-preview मॉडल का उपयोग करके एक वाटर क्वालिटी क्लासिफिकेशन एप्लिकेशन बनाएंगे और डिप्लॉय करेंगे। यह एक काफी जटिल प्रोजेक्ट है, क्योंकि हम इसे अपनी अपेक्षाओं का विस्तृत विवरण प्रदान करेंगे।

यदि आप ChatGPT का उपयोग करके डेटा साइंस प्रोजेक्ट बनाना चाहते हैं, तो A Guide to Using ChatGPT for Data Science Projects देखें। आप सीखेंगे कि प्रोजेक्ट प्लानिंग, डेटा विश्लेषण, डेटा प्रीप्रोसेसिंग, मॉडल चयन, हाइपरपैरामीटर ट्यूनिंग, वेब ऐप विकसित करने और उसे डिप्लॉय करने के लिए ChatGPT का कैसे उपयोग करें।

1. प्रॉम्प्ट इंजीनियरिंग

हम प्रॉम्प्ट इंजीनियरिंग पर अधिक समय खर्च करेंगे, क्योंकि हम यह सुनिश्चित करना चाहते हैं कि सभी प्रोजेक्ट निर्देश मॉडल को दिए जाएँ।

प्रॉम्प्ट तीन भागों में विभाजित है:

प्रोजेक्ट विवरण: हम क्या बनाना चाहते हैं इसकी विस्तृत व्याख्या।
लक्ष्य और प्रतिबंध: जैसे 90% सटीकता हासिल करने का लक्ष्य बताना।
अनुसरण करने के चरण: वे सभी आवश्यक चरण जिनका आप पालन कराना चाहते हैं। उदाहरण के लिए, Kaggle API का उपयोग करके डेटा इनजेशन, फोल्डर में मेट्रिक्स सेव करना, डेटा विश्लेषण करना, मॉडल को ट्रेन और इवैल्यूएट करना, आदि। यथासंभव अधिक चरण लिखें।

ChatGPT में उचित प्रॉम्प्ट कैसे लिखें और आवश्यक परिणाम कैसे जनरेट करें, यह सीखने के लिए A Beginner's Guide to ChatGPT Prompt Engineering पढ़ें। प्रॉम्प्ट इंजीनियरिंग एक कला है, और o1 मॉडल के आने के साथ इसे सीखना और भी जरूरी हो गया है।

प्रॉम्प्ट: “मेरे प्रोजेक्ट मैनेजर ने हमें https://www.kaggle.com/datasets/adityakadiwal/water-potability पर उपलब्ध Kaggle डेटासेट का उपयोग करके एक वाटर क्वालिटी एप्लिकेशन विकसित करने का कार्य दिया है। कृपया हमें उच्च सटीकता वाला मॉडल बनाने के लिए फाइलों, Python पैकेजों और कोड पर सभी आवश्यक जानकारी प्रदान करें।

लक्ष्य 90% समग्र सटीकता हासिल करना है।

कृपया प्रोजेक्ट बनाने के लिए इन चरणों का पालन करें:

1. Kaggle API का उपयोग करके डेटासेट लोड करें और उसे data फोल्डर में अनज़िप करें।

2. डेटा को प्रीप्रोसेस करें और कुछ डेटा विश्लेषण करें। विश्लेषण के चित्र और फाइलें metrics फोल्डर में सेव करें।

3. scikit-learn फ्रेमवर्क का उपयोग करके मॉडल ट्रेन करें। सुनिश्चित करें कि आप प्रयोगों को ट्रैक करें और मॉडल फाइलें और मेटाडेटा सेव करें। मॉडल को skops लाइब्रेरी का उपयोग करके सेव करें।

4. विस्तृत मॉडल इवैल्यूएशन करें और परिणाम सेव करें।

5. एक FastAPI एप्लिकेशन बनाएं जो उपयोगकर्ता से इनपुट लेकर पानी की क्वालिटी का अनुमान लगाए।

6. सुनिश्चित करें कि आप Jinja2 टेम्पलेट्स का उपयोग करके यूजर इंटरफेस जोड़ें।

7. Docker विकल्प का उपयोग करके ऐप को Hugging Face हब पर डिप्लॉय करें.”

जनरेट की गई प्रतिक्रिया ने हमें डेटा लोड करने, प्रीप्रोसेस करने, मॉडल ट्रेन और इवैल्यूएट करने, FastAPI एप्लिकेशन बनाने, यूजर इंटरफेस बनाने और उसे डिप्लॉय करने के लिए आवश्यक सभी जानकारी दे दी है।

समस्या यह है कि यह विखंडित है और हम चाहते हैं कि यह हमारे लिए Python और HTML फाइलें बना दे ताकि हम बस कोड कॉपी-पेस्ट कर सकें।

अब हम सारा कोड Python और HTML फाइलों में बदलेंगे, जिससे काम और आसान हो जाएगा।

फॉलो-अप प्रॉम्प्ट: “कृपया कोड को Python फाइलों में कन्वर्ट करें।”

जैसा कि हम देख सकते हैं, हमारे पास सभी फाइलों और कोड के साथ प्रोजेक्ट संरचना मौजूद है। हमें सिर्फ फोल्डर और फाइलें बनानी हैं और कोड कॉपी-पेस्ट करना है।

2. सेटअप

o1 मॉडल प्रोजेक्ट डायरेक्टरी सेट करने के लिए आवश्यक सभी जानकारी देता है। हमें बस कोड एडिटर का उपयोग करके प्रोजेक्ट डायरेक्टरी के भीतर फोल्डर और फाइलें बनानी हैं।

हम निम्नलिखित फोल्डर बनाएंगे:

app: इस फोल्डर में FastAPI के लिए ऐप फाइल और HTML टेम्पलेट्स होंगे।
data: इस फोल्डर में ओरिजिनल और प्रीप्रोसेस्ड डेटा होगा।
metrics: इस फोल्डर में मॉडल इवैल्यूएशन डेटा और डेटा विश्लेषण होगा।
models: इस फोल्डर में सेव किए गए मॉडल और स्केलर ऑब्जेक्ट्स होंगे।
src: इस फोल्डर में वे सभी Python फाइलें होंगी जो लोडिंग, प्रोसेसिंग, ट्रेनिंग और इवैल्यूएशन में मदद करेंगी।

इसके अलावा, मुख्य डायरेक्टरी में Dockerfile, README और requirements.txt फाइल होगी।

3. डेटासेट लोड करें

हम Kaggle API का उपयोग करके Water Quality Kaggle डेटासेट लोड करेंगे और उसे data फोल्डर में अनज़िप करेंगे।

data\download_data.py:

import os

# Ensure the data directory exists
os.makedirs("data", exist_ok=True)

# Download the dataset
os.system("kaggle datasets download -d adityakadiwal/water-potability -p data --unzip")संचालित द्वारा

Python फाइल चलाने पर डेटासेट डाउनलोड होगा, अनज़िप होगा और ज़िप फाइल हट जाएगी।

$ python .\src\download_data.py

Dataset URL: https://www.kaggle.com/datasets/adityakadiwal/water-potability
License(s): CC0-1.0
Downloading water-potability.zip to data
100%|████████████████████████████████████████████████████████████████████████████████| 251k/251k [00:00<00:00, 304kB/s]
100%|████████████████████████████████████████████████████████████████████████████████| 251k/251k [00:00<00:00, 303kB/s]संचालित द्वारा

4. डेटा प्रीप्रोसेस करें और डेटा विश्लेषण करें

प्रीप्रोसेसिंग वाली Python फाइल डेटा को लोड, साफ, मिसिंग डेटा को हैंडल, स्केल करेगी और फिर स्केलर तथा प्रीप्रोसेस्ड डेटासेट सेव करेगी। यह डेटा विश्लेषण भी करेगी और मेट्रिक्स तथा डेटा विज़ुअलाइज़ेशन सेव करेगी।

data\preprocess_data.py:

import os
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
import joblib

# Create directories if they don't exist
os.makedirs("metrics", exist_ok=True)
os.makedirs("models", exist_ok=True)

# Load the dataset
data = pd.read_csv("data/water_potability.csv")

# Check for missing values and save the summary
missing_values = data.isnull().sum()
missing_values.to_csv("metrics/missing_values.csv")

# Statistical summary
stats = data.describe()
stats.to_csv("metrics/data_statistics.csv")

# Pair plot
sns.pairplot(data, hue="Potability")
plt.savefig("metrics/pairplot.png")

# Correlation heatmap
plt.figure(figsize=(10, 8))
sns.heatmap(data.corr(), annot=True)
plt.savefig("metrics/correlation_heatmap.png")

# Handle missing values
imputer = SimpleImputer(strategy="mean")
data_imputed = pd.DataFrame(imputer.fit_transform(data), columns=data.columns)

# Feature scaling
scaler = StandardScaler()
features = data_imputed.drop("Potability", axis=1)
target = data_imputed["Potability"]
features_scaled = scaler.fit_transform(features)

# Save the scaler
joblib.dump(scaler, "models/scaler.joblib")

# Save preprocessed data
preprocessed_data = pd.DataFrame(features_scaled, columns=features.columns)
preprocessed_data["Potability"] = target
preprocessed_data.to_csv("metrics/preprocessed_data.csv", index=False)संचालित द्वारा

$ python .\src\preprocess_data.py संचालित द्वारा

हमें प्रीप्रोसेस्ड डेटा और सभी डेटा विश्लेषण रिपोर्टें चित्रों सहित मिल गई हैं।

5. मॉडल बनाना और ट्रेनिंग

ट्रेनिंग स्क्रिप्ट प्रीप्रोसेस्ड डेटा लोड करती है और Random Forest Classifier को ट्रेन करने के लिए इसका उपयोग करती है। इसके बाद Skope का उपयोग मॉडल सेव करने, प्रयोगों को मैन्युअली ट्रैक करने और मॉडल मेटाडेटा को JSON फाइल के रूप में सेव करने के लिए किया जाता है।

src\train_model.py:

import os
import json
import skops.io as sio
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# Load preprocessed data
data = pd.read_csv("metrics/preprocessed_data.csv")
features = data.drop("Potability", axis=1)
target = data["Potability"]

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    features, target, test_size=0.2, random_state=42, stratify=target
)

# Train the model
model = RandomForestClassifier(n_estimators=200, random_state=42)
model.fit(X_train, y_train)

# Save the model using skops
os.makedirs("models", exist_ok=True)
sio.dump(model, "models/water_quality_model.skops")

# Track experiments and save metadata
metadata = {
    "model_name": "RandomForestClassifier",
    "parameters": model.get_params(),
    "training_score": model.score(X_train, y_train),
}

with open("models/metadata.json", "w") as f:
    json.dump(metadata, f, indent=4)संचालित द्वारा

$ python .\src\train_model.py संचालित द्वारा

ट्रेनिंग स्क्रिप्ट नीचे दिखाए अनुसार एक मॉडल फाइल और मेटाडेटा जनरेट करेगी।

6. मॉडल इवैल्यूएशन

मॉडल इवैल्यूएशन स्क्रिप्ट प्रोसेस्ड डेटा और सेव किए गए मॉडल को लोड करती है ताकि क्लासिफिकेशन रिपोर्ट, कन्फ्यूज़न मैट्रिक्स, ROC कर्व, AUC, और समग्र सटीकता जनरेट की जा सके। सभी मेट्रिक्स और चित्र metrics फोल्डर में सेव होते हैं।

src\evaluate_model.py :

import os
import json
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.metrics import (
    classification_report,
    confusion_matrix,
    roc_auc_score,
    roc_curve,
)
import skops.io as sio
from sklearn.model_selection import train_test_split

# Load preprocessed data
data = pd.read_csv("metrics/preprocessed_data.csv")
features = data.drop("Potability", axis=1)
target = data["Potability"]

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    features, target, test_size=0.2, random_state=42, stratify=target
)

# Load the model
model = sio.load("models/water_quality_model.skops")

# Predictions
y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:, 1]

# Classification report
report = classification_report(y_test, y_pred, output_dict=True)
with open("metrics/classification_report.json", "w") as f:
    json.dump(report, f, indent=4)

# Confusion matrix
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt="d")
plt.title("Confusion Matrix")
plt.ylabel("Actual Label")
plt.xlabel("Predicted Label")
plt.savefig("metrics/confusion_matrix.png")

# ROC curve and AUC
fpr, tpr, _ = roc_curve(y_test, y_pred_proba)
roc_auc = roc_auc_score(y_test, y_pred_proba)

plt.figure()
plt.plot(fpr, tpr, label="AUC = %0.2f" % roc_auc)
plt.plot([0, 1], [0, 1], "k--")
plt.legend(loc="lower right")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Receiver Operating Characteristic")
plt.savefig("metrics/roc_curve.png")

# Overall accuracy
accuracy = model.score(X_test, y_test)
print(f"Overall Accuracy: {accuracy * 100:.2f}%")संचालित द्वारा

$ python .\src\evaluate_model.py  संचालित द्वारा

समग्र सटीकता उतनी अच्छी नहीं है। हालाँकि, हम हमेशा o1 मॉडल से सटीकता में सुधार के लिए कह सकते हैं।

Overall Accuracy: 65.55%संचालित द्वारा

metrics फोल्डर में सभी सेव किए गए मॉडल इवैल्यूएशन चित्र और मेट्रिक्स हैं। हम इसे मैन्युअली रिव्यू कर सकते हैं ताकि मॉडल के प्रदर्शन को विस्तार से समझा जा सके।

7. FastAPI एप्लिकेशन बनाएं

FastAPI एप्लिकेशन के लिए यूजर इंटरफेस बनाने हेतु, हमें इंडेक्स और रिज़ल्ट पेज बनाने होंगे। यह ऐप डायरेक्टरी के भीतर टेम्पलेट फोल्डर बनाकर और दो HTML फाइलें जोड़कर किया जा सकता है: एक मुख्य पेज के लिए और एक परिणाम पेज के लिए।

FastAPI फ्रेमवर्क के बारे में विस्तार से जानने और इसे अपने प्रोजेक्ट में लागू करने के लिए FastAPI Tutorial: An Introduction to Using FastAPI देखें।

यदि आप HTML से परिचित नहीं हैं, तो चिंता न करें। आपको बस कोड कॉपी-पेस्ट करना है और o1 मॉडल पर भरोसा करना है।

app\templates\form.html:

<!DOCTYPE html>
<html>
<head>
    <title>Water Quality Prediction</title>
</head>
<body>
    <h2>Enter Water Parameters</h2>
    <form action="/predict" method="post">
        {% for feature in ['ph', 'Hardness', 'Solids', 'Chloramines', 'Sulfate', 'Conductivity', 'Organic_carbon', 'Trihalomethanes', 'Turbidity'] %}
        <label for="{{ feature }}">{{ feature.replace('_', ' ').title() }}:</label><br>
        <input type="number" step="any" id="{{ feature }}" name="{{ feature }}" required><br><br>
        {% endfor %}
        <input type="submit" value="Predict">
    </form>
</body>
</html>संचालित द्वारा

app\templates\result.html:

<!DOCTYPE html>
<html>
<head>
    <title>Prediction Result</title>
</head>
<body>
    <h2>Prediction Result</h2>
    <p>The water is predicted to be: <strong>{{ result }}</strong></p>
    <a href="/">Try Again</a>
</body>
</html>संचालित द्वारा

मुख्य एप्लिकेशन Python फाइल में दो Python फ़ंक्शन हैं: home और predict। "home" फ़ंक्शन वेलकम पेज दिखाता है जिसमें इनपुट बॉक्स और एक बटन होता है। "predict" फ़ंक्शन यूजर इनपुट को ट्रांसफॉर्म करता है, उसे मॉडल से गुजारता है, और परिणाम दिखाता है कि पानी पीने योग्य है या नहीं।

app\templates\main.py:

from fastapi import FastAPI, Request, Form
from fastapi.responses import HTMLResponse
from fastapi.templating import Jinja2Templates
import numpy as np
import skops.io as sio
import joblib

app = FastAPI()
templates = Jinja2Templates(directory="app/templates")

# Load the saved model and preprocessing pipeline
model = sio.load("models/water_quality_model.skops", trusted=True)
preprocessing_pipeline = joblib.load("models/preprocessing_pipeline.joblib")


@app.get("/", response_class=HTMLResponse)
async def home(request: Request):
    return templates.TemplateResponse("form.html", {"request": request})


@app.post("/predict", response_class=HTMLResponse)
async def predict(
    request: Request,
    ph: float = Form(...),
    Hardness: float = Form(...),
    Solids: float = Form(...),
    Chloramines: float = Form(...),
    Sulfate: float = Form(...),
    Conductivity: float = Form(...),
    Organic_carbon: float = Form(...),
    Trihalomethanes: float = Form(...),
    Turbidity: float = Form(...),
):
    input_data = np.array(
        [
            [
                ph,
                Hardness,
                Solids,
                Chloramines,
                Sulfate,
                Conductivity,
                Organic_carbon,
                Trihalomethanes,
                Turbidity,
            ]
        ]
    )
    # Preprocess input data
    input_preprocessed = preprocessing_pipeline.transform(input_data)
    prediction = model.predict(input_preprocessed)
    result = "Potable" if prediction[0] == 1 else "Not Potable"
    return templates.TemplateResponse(
        "result.html", {"request": request, "result": result}
    )संचालित द्वारा

हम पहले लोकली ऐप का परीक्षण करेंगे ताकि यह सत्यापित हो सके कि यह चल रहा है।

$ uvicorn app.main:app --reload संचालित द्वारा

uvicorn का उपयोग करके Python फाइल चलाने पर हमें लोकल एड्रेस मिलता है जिसे हम अपने ब्राउज़र में कॉपी-पेस्ट कर सकते हैं।

नोट: फाइलें कैसे चलानी हैं, इसकी सारी जानकारी भी o1 मॉडल ने प्रदान की है।

INFO:     Will watch for changes in these directories: ['C:\\Repository\\GitHub\\Water-Quality-App']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [34792] using StatReloadसंचालित द्वारा

जैसा कि हम देख सकते हैं, ऐप सही से काम कर रहा है।

आइए पानी की क्वालिटी जांचने के लिए रैंडम मान प्रदान करें और Predict बटन दबाएँ।

परिणाम शानदार है। यह दिखाता है कि पानी पीने योग्य नहीं है।

आप URL के बाद “/docs” टाइप करके FastAPI Swagger UI तक भी पहुँच सकते हैं ताकि API का परीक्षण हो सके और परिणाम जनरेट किए जा सकें।

8. Docker का उपयोग करके Hugging Face Hub पर ऐप डिप्लॉय करें

OpenAI o1 मॉडल ने हमें Docker कोड, गाइड और संदर्भ लिंक दिए हैं ताकि हम Hugging Face पर एप्लिकेशन को सफलतापूर्वक डिप्लॉय करना सीख सकें।

यह जानने के लिए कि Docker कैसे काम करता है, Docker for Data Science: An Introduction ट्यूटोरियल पढ़ें। आप सीखेंगे कि Docker कैसे सेटअप करें, Docker कमांड्स का उपयोग करें, मशीन लर्निंग एप्लिकेशन को डॉकराइज़ करें, और उद्योग-व्यापी सर्वोत्तम प्रथाओं का पालन करें।

सबसे पहले, Hugging Face वेबसाइट पर प्रोफाइल तस्वीर पर क्लिक करके और फिर "New Space" बटन पर क्लिक करके एक नया Space बनाएं। ऐप का नाम टाइप करें, SDK प्रकार (Docker) चुनें, लाइसेंस प्रकार चुनें और “Create Space” दबाएँ।

स्रोत: Hugging Face

Docker का उपयोग करके ऐप डिप्लॉय करने के सभी निर्देश मुख्य पेज पर दिए गए हैं।

स्रोत: Water Quality Classifier

इसके बाद, हमें रिपॉजिटरी क्लोन करनी होगी।

git clone https://huggingface.co/spaces/kingabzpro/Water-Quality-Classifierसंचालित द्वारा

रिपॉजिटरी के भीतर, app और model फोल्डर को मूव करें। एक Dockerfile बनाएँ और निम्न कमांड लिखें। o1 मॉडल ने हमें कोड दिया है; हमें केवल पोर्ट नंबर 7860 में बदलना है।

Dockerfile:

# Use an official Python runtime as a parent image
FROM python:3.9-slim

# Set the working directory
WORKDIR /app

# Copy the current directory contents into the container at /app
COPY . /app

# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt

# Expose port 7860
EXPOSE 7860

# Run the application
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]संचालित द्वारा

Python पैकेजों की जानकारी वाली requirements.txt फाइल बनाएँ। हम इस फाइल का उपयोग क्लाउड सर्वर पर सभी आवश्यक Python पैकेज डाउनलोड और इंस्टॉल करने के लिए करेंगे।

requirements.txt:

fastapi
uvicorn
jinja2
pydantic
skops
joblib
numpy
pandas
scikit-learn==1.5.1
matplotlib
seaborn
kaggle
imbalanced-learn
python-multipartसंचालित द्वारा

हमारी ऐप रिपॉजिटरी इस तरह दिखनी चाहिए:

हमारा मॉडल एक बड़ा फाइल है (> 10MB), इसलिए हमें इसे ट्रैक करने के लिए Git LFS का उपयोग करना होगा। Git LFS इंस्टॉल करें और “.skops” एक्सटेंशन वाली सभी फाइलों को ट्रैक करें।

git lfs install
git lfs track "*.skops" संचालित द्वारा

सभी बदलावों को स्टेज करें, संदेश के साथ कमिट करें, और उसे रिमोट सर्वर पर पुश करें।

git add .
git commit -m "pushing all the files"
git pushसंचालित द्वारा

Hugging Face पर अपने ऐप पेज पर जाएँ, और आप देखेंगे कि यह कंटेनर बना रहा है और सभी आवश्यक पैकेज इंस्टॉल कर रहा है।

स्रोत: Water Quality Classifier

कुछ मिनटों बाद, ऐप उपयोग के लिए तैयार हो जाएगा। यह लोकल ऐप जैसा ही दिखता है। आइए सैंपल मान दें और परिणाम जनरेट करें।

स्रोत: Water Quality Classifier

हमारा ऐप बिल्कुल सही काम कर रहा है और अपेक्षित परिणाम दे रहा है।

स्रोत: Water Quality Classifier

यह Hugging Face Space ऐप किसी के लिए भी उपलब्ध है, यानी हम टर्मिनल में curl कमांड का उपयोग करके इसे एक्सेस कर सकते हैं।

curl -X 'POST' \
  'https://kingabzpro-water-quality-classifier.hf.space/predict' \
  -H 'accept: text/html' \
  -H 'Content-Type: application/x-www-form-urlencoded' \
  -d 'Organic_carbon=10&Hardness=200&Turbidity=4&Solids=10000&Chloramines=7&Trihalomethanes=80&Sulfate=300&ph=7&Conductivity=400' \
  | grep -oP '(?<=<strong>).*(?=</strong>)'संचालित द्वारा

आउटपुट:

Not Potableसंचालित द्वारा

सभी प्रोजेक्ट फाइलें, डेटा, मॉडल और मेटाडेटा kingabzpro/Water-Quality-App GitHub रिपॉजिटरी पर उपलब्ध हैं।

लेखक की राय

o1-preview मॉडल GPT-4o से कहीं बेहतर है। यह निर्देशों का पूरी तरह पालन करता है और बग-फ्री है, इसलिए इसका जनरेट किया गया कोड इस्तेमाल के लिए तैयार होता है। मशीन लर्निंग ऐप बनाते समय, मुझे केवल लगभग 5% मामूली बदलाव करने पड़े। सबसे अच्छी बात यह है कि मैंने AI मॉडल की निर्णय-प्रक्रिया से भी सीखा, समझा कि उसने कुछ चुनाव क्यों किए।

Abid Ali Awan

निष्कर्ष

इस ट्यूटोरियल में, हमने देखा कि OpenAI का o1 रीजनिंग मॉडल कितना शक्तिशाली हो सकता है। हमने कोड में कुछ ही बदलावों के साथ एक संपूर्ण मशीन लर्निंग प्रोजेक्ट बनाया, और यह तुरंत काम करने लगा। मॉडल ने हर कमांड को बेहतरीन तरीके से संभाला और बिना फॉलो-अप निर्देशों की आवश्यकता के शानदार परिणाम दिए।

अभी हमारे पास o1 मॉडल के छोटे संस्करण, जैसे o1-preview और o1-mini तक पहुंच है। भविष्य में, हमारे पास पूरे o1 मॉडल तक पहुंच होगी, जो जटिल प्रोजेक्ट बनाने के लिए और भी बेहतर होगा। मुख्य बात यह है कि मॉडल से अधिकतम लाभ पाने के लिए सही प्रश्न पूछने पर काम करें।

AI मॉडलों के साथ मशीन लर्निंग प्रोजेक्ट बनाना सरल है, लेकिन यदि आप इसे करियर बनाना चाहते हैं, तो आपको समझना होगा कि ये मॉडल कैसे काम करते हैं। इसके बिना समस्याएँ ठीक करना या मॉडलों को विशिष्ट व्यावसायिक जरूरतों पर लागू करना कठिन हो सकता है। इस समझ को विकसित करने के लिए, हम शुरुआती लोगों को Machine Learning Scientist with Python करियर ट्रैक लेने की सलाह देते हैं। इसमें 21 कोर्स और 3 प्रोजेक्ट शामिल हैं जो आपको विभिन्न प्रकार के मशीन लर्निंग मॉडल बनाना और उन्हें बेहतर बनाना सिखाते हैं।

लेखक

Abid Ali Awan

LinkedIn Twitter

एक प्रमाणित डेटा साइंटिस्ट के रूप में, मैं अत्याधुनिक तकनीक का उपयोग करके नवाचारी मशीन लर्निंग अनुप्रयोग बनाने के लिए उत्साहित रहता/रहती हूँ। स्पीच रिकॉग्निशन, डेटा विश्लेषण और रिपोर्टिंग, MLOps, संवादात्मक AI और NLP में मजबूत पृष्ठभूमि के साथ, मैंने ऐसे बुद्धिमान सिस्टम विकसित करने में अपनी विशेषज्ञता निखारी है जो वास्तविक प्रभाव डाल सकें। तकनीकी दक्षता के अलावा, मैं जटिल अवधारणाओं को स्पष्ट और संक्षिप्त भाषा में प्रस्तुत करने में भी निपुण हूँ। परिणामस्वरूप, मैं डेटा साइंस पर एक मांग में रहने वाला/वाली ब्लॉगर बन गया/गई हूँ, और डेटा प्रोफेशनलों के बढ़ते समुदाय के साथ अपने अनुभव और विचार साझा करता/करती हूँ। वर्तमान में, मैं कंटेंट निर्माण और संपादन पर केंद्रित हूँ, बड़े भाषा मॉडलों के साथ काम करते हुए ऐसा प्रभावशाली और आकर्षक कंटेंट विकसित कर रहा/रही हूँ जो व्यवसायों और व्यक्तियों दोनों को अपने डेटा का अधिकतम लाभ उठाने में मदद कर सके।

विषय

कृत्रिम बुद्धिमत्ता OpenAI बड़े भाषा मॉडल

प्रौद्योगिकियाँ

विषय

OpenAI o1-preview ट्यूटोरियल: एक मशीन लर्निंग प्रोजेक्ट बनाना

AI के साथ खोजें

OpenAI का o1 रीजनिंग मॉडल क्या है?

o1-preview और o1-mini के साथ शुरुआत

o1 मॉडल तक पहुँच

ChatGPT में o1-preview मॉडल का उपयोग

ChatGPT में o1-mini मॉडल का उपयोग

OpenAI o1-preview ट्यूटोरियल: वाटर क्वालिटी क्लासिफायर एप्लिकेशन बनाना

1. प्रॉम्प्ट इंजीनियरिंग

2. सेटअप

3. डेटासेट लोड करें

4. डेटा प्रीप्रोसेस करें और डेटा विश्लेषण करें

5. मॉडल बनाना और ट्रेनिंग

6. मॉडल इवैल्यूएशन

7. FastAPI एप्लिकेशन बनाएं

8. Docker का उपयोग करके Hugging Face Hub पर ऐप डिप्लॉय करें

लेखक की राय

निष्कर्ष

विषय

Top OpenAI Courses

OpenAI API के साथ काम करना

OpenAI API के साथ AI सिस्टम बनाना

OpenAI API के साथ Embeddings परिचय

प्रौद्योगिकियाँ

विषय

Top OpenAI Courses

OpenAI API के साथ काम करना

OpenAI API के साथ AI सिस्टम बनाना

OpenAI API के साथ Embeddings परिचय