GPT-4o Mini का फाइन-ट्यूनिंग: चरण-दर-चरण मार्गदर्शिका

GPT-4o Mini मॉडल को फाइन-ट्यून करने से पहले, हम अनुशंसा करते हैं कि आप प्रॉम्प्ट इंजीनियरिंग, प्रॉम्प्ट चेइनिंग, और फंक्शन कॉलिंग का उपयोग करें ताकि मॉडल के उत्तरों को कस्टमाइज़ कर सकें और डोमेन-विशिष्ट जवाब प्राप्त करें।

फाइन-ट्यूनिंग तब आवश्यक होती है जब आप शैली, टोन या फ़ॉर्मेट को समायोजित करना चाहते हैं। यह विश्वसनीयता और सटीकता में सुधार करने, जटिल प्रॉम्प्ट्स संभालने, या ऐसे नए कार्य करने के लिए उपयोग होती है जिन्हें प्रॉम्प्ट इंजीनियर हासिल नहीं कर सका।

इस ट्यूटोरियल में, हम GPT-4o Mini मॉडल को पाठ को "stress" और "non-stress" लेबल में वर्गीकृत करने के लिए फाइन-ट्यून करेंगे। इसके बाद, हम OpenAI API और OpenAI playground का उपयोग करके फाइन-ट्यून किए गए मॉडल तक पहुँचेंगे। अंत में, हम विभिन्न वर्गीकरण मेट्रिक्स का उपयोग करते हुए ट्यूनिंग से पहले और बाद के प्रदर्शन की तुलना करके फाइन-ट्यून किए गए मॉडल का मूल्यांकन करेंगे।

छवि: लेखक द्वारा

GPT-4o Mini का परिचय

GPT-4o Mini उपलब्ध सबसे किफायती जनरल बड़े भाषा मॉडल्स में से एक है। यह MMLU पर 82% स्कोर करता है और वर्तमान में LMSYS लीडरबोर्ड पर चैट प्रेफरेंसेज़ के मामले में Claude 3.5 Sonnet से बेहतर प्रदर्शन करता है। इसकी कीमत प्रति मिलियन इनपुट टोकन 15 सेंट और प्रति मिलियन आउटपुट टोकन 60 सेंट है, जो GPT-3.5 Turbo से 60% सस्ता है।

GPT-4o mini फिलहाल टेक्स्ट और इमेज इनपुट को सपोर्ट करता है। मॉडल का कॉन्टेक्स्ट विंडो 128K टोकन का है, प्रत्येक रिक्वेस्ट पर अधिकतम 16K आउटपुट टोकन सपोर्ट करता है, और इसका ज्ञान अक्टूबर 2023 तक अद्यतन है। GPT-4o Mini गैर-अंग्रेज़ी पाठ को भी संभाल सकता है, क्योंकि यह GPT-4o टोकनाइज़र का उपयोग करता है। हमें कम लागत पर दोनों दुनिया का सर्वश्रेष्ठ मिलता है।

GPT-4o Mini के उपयोग के मामले, चैट कम्प्लीशन API, और विस्तृत बेंचमार्क के बारे में हमारे ब्लॉग What Is GPT-4o Mini? पढ़कर जानें।

OpenAI API सेटअप करना

OpenAI वेबसाइट पर जाएँ और एक खाता बनाएँ। फाइन-ट्यूनिंग महंगी होती है, और API के माध्यम से GPT-4o Mini का उपयोग करने के लिए आपके खाते से पेमेंट मेथड जुड़ा होना चाहिए। किसी भी रुकावट से बचने के लिए, मॉडल को फाइन-ट्यून करने का प्रयास करने से पहले सुनिश्चित करें कि आपके खाते में कम से कम 10 USD का क्रेडिट बैलेंस हो।

मुख्य डैशबोर्ड पर जाएँ, “API keys” टैब पर क्लिक करें, और OpenAI API सीक्रेट की जनरेट करें।

हम कोड एडिटर के रूप में DataCamp का DataLab उपयोग कर रहे हैं। OpenAI API key का environment variable सेट करने के लिए, environment टैब में जाएँ और environment variable विकल्प पर क्लिक करें। फिर, API key के लिए environment variable जोड़ें और उसे नीचे दिखाए अनुसार सक्रिय करें।

GPT-4o Mini तक पहुँचने के लिए OpenAI Python पैकेज इंस्टॉल करें।

%%capture
%pip install openai
संचालित द्वारा

OpenAI API key का उपयोग करके क्लाइंट बनाएँ और सैंपल प्रॉम्प्ट से एक प्रतिक्रिया जनरेट करें। चैट कम्प्लीशन फ़ंक्शन को मॉडल का नाम और संदेशों की सूची डिक्शनरी फ़ॉर्मेट में चाहिए।

from IPython.display import Markdown, display
from openai import OpenAI
import os

openai_api_key = os.environ["OPENAI_API_KEY"]

client = OpenAI(api_key=openai_api_key)

response = client.chat.completions.create(
  model="gpt-4o-mini",
  messages=[
    {"role": "system", "content": "You are a great philosopher."},
    {"role": "user", "content": "What is the meaning of life?"}
  ]
)
display(Markdown(response.choices[0].message.content))संचालित द्वारा

हमारा OpenAI API पूरी तरह सेट हो गया है, और हम फाइन-ट्यूनिंग जॉब शुरू करने के लिए तैयार हैं।

OpenAI के API में नए हैं? आप यह सरल और विस्तृत ट्यूटोरियल देख सकते हैं GPT-4o API Tutorial: Getting Started with OpenAI's API, जिससे आप अत्याधुनिक मॉडल तक पहुँचने के लिए कुछ पंक्तियों का कोड लिखना समझ सकते हैं।

GPT-4o Mini का फाइन-ट्यूनिंग

इस खंड में, हम Kaggle के Stress Detection from the Social Media Articles डेटासेट पर GPT-4o Mini मॉडल को फाइन-ट्यून करेंगे। इस डेटासेट में Reddit और Twitter के पोस्ट शामिल हैं, जिन्हें stress और non-stress लेबल में वर्गीकृत किया गया है।

डेटासेट बनाना

अब हम डेटासेट लोड और प्रोसेस करेंगे।

Reddit पोस्ट डेटासेट से शीर्ष 200 पंक्तियाँ लोड करें।
'title' और 'label' को छोड़कर सभी कॉलम हटाएँ।
labels कॉलम को मैप करें ताकि 0 और 1 को "non-stress" और "stress" लेबल में बदला जा सके।
डेटासेट को training और validation सेट में विभाजित करें।
दोनों training और validation सेट को JSONL फ़ॉर्मेट में सहेजें।

नोट: सही डेटासेट फ़ॉर्मेट सुनिश्चित करें, जिसमें system प्रॉम्प्ट, user क्वेरी और response शामिल हो। response में लेबल होगा।

import pandas as pd
import json
from sklearn.model_selection import train_test_split

# Load the CSV file with the correct delimiter
file_path = 'Reddit_Title.csv'  # Change this to your local path
data = pd.read_csv(file_path, sep=';')

# Clean up and drop unnecessary columns, and select the top 200 rows
data_cleaned = data[['title', 'label']].head(200)

# Mapping the 'label' column to more human-readable text
label_mapping = {0: "non-stress", 1: "stress"}
data_cleaned['label'] = data_cleaned['label'].map(label_mapping)

# Split the data into training and validation sets (80% train, 20% validation)
train_data, validation_data = train_test_split(data_cleaned, test_size=0.2, random_state=42)

def save_to_jsonl(data, output_file_path):
    jsonl_data = []
    for index, row in data.iterrows():
        jsonl_data.append({
            "messages": [
                {"role": "system", "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'."},
                {"role": "user", "content": row['title']},
                {"role": "assistant", "content": f"\"{row['label']}\""}
            ]
        })

    # Save to JSONL format
    with open(output_file_path, 'w') as f:
        for item in jsonl_data:
            f.write(json.dumps(item) + '\n')

# Save the training and validation sets to separate JSONL files
train_output_file_path = 'stress_detection_train.jsonl' 
validation_output_file_path = 'stress_detection_validation.jsonl'

save_to_jsonl(train_data, train_output_file_path)
save_to_jsonl(validation_data, validation_output_file_path)

print(f"Training dataset save to {train_output_file_path}")
print(f"Validation dataset save to {validation_output_file_path}")संचालित द्वारा

आउटपुट:

Training dataset save to stress_detection_train.jsonl
Validation dataset save to stress_detection_validation.jsonlसंचालित द्वारा

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

अब हम OpenAI क्लाइंट का उपयोग करके फाइन-ट्यूनिंग के लिए training और validation दोनों डेटासेट अपलोड करेंगे।

train_file = client.files.create(
  file=open(train_output_file_path, "rb"),
  purpose="fine-tune"
)

valid_file = client.files.create(
  file=open(validation_output_file_path, "rb"),
  purpose="fine-tune"
)

print(f"Training file Info: {train_file}")
print(f"Validation file Info: {valid_file}")संचालित द्वारा

OpenAI API पहले डेटासेट को वैलिडेट करेगा, फिर उन्हें अपलोड करेगा और ऐसी मेटाडेटा जनरेट करेगा जिसका उपयोग हम मॉडल को फाइन-ट्यून करने में कर सकते हैं।

Training file Info: FileObject(id='file-b2lo2chod6xuMhYg9JcEsnp6', bytes=48563, created_at=1727133513, filename='stress_detection_train.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None)
Validation file Info: FileObject(id='file-Fae0AVSUhTGr49qhQz8d2yyp', bytes=12284, created_at=1727133514, filename='stress_detection_validation.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None)संचालित द्वारा

यह जाँचने के लिए कि क्या डेटासेट सफलतापूर्वक क्लाउड पर भेजा गया है, डैशबोर्ड में जाएँ और “Storage” टैब पर क्लिक करें। वहाँ दो फ़ाइलें मौजूद होंगी और उपयोग के लिए तैयार होंगी।

फाइन-ट्यूनिंग जॉब शुरू करना

क्लाइंट API का उपयोग करके फाइन-ट्यूनिंग जॉब बनाएँ। फाइन-ट्यूनिंग फ़ंक्शन को training डेटासेट फ़ाइल ID, validation डेटासेट फ़ाइल ID, मॉडल नाम, और हाइपरपैरामीटर्स की आवश्यकता होती है। हम अपने मॉडल को तीन epochs के लिए फाइन-ट्यून करेंगे। प्रदर्शन सुधारने के लिए, आप हमेशा पूरे डेटासेट पर कम से कम 5 epochs के साथ ट्रेन कर सकते हैं।

model = client.fine_tuning.jobs.create(
  training_file=train_file.id, 
  validation_file=valid_file.id,
  model="gpt-4o-mini-2024-07-18", 
  hyperparameters={
    "n_epochs": 3,
	"batch_size": 3,
	"learning_rate_multiplier": 0.3
  }
)
job_id = model.id
status = model.status

print(f'Fine-tuning model with jobID: {job_id}.')
print(f"Training Response: {model}")
print(f"Training Status: {status}")संचालित द्वारा

फ़ंक्शन चलाते ही फाइन-ट्यूनिंग जॉब शुरू हो जाएगा और लॉग्स दिखाएगा।

Fine-tuning model with jobID: ftjob-rgIMFxZSsWDqCNfOev54e4Jq.
Training Response: FineTuningJob(id='ftjob-rgIMFxZSsWDqCNfOev54e4Jq', created_at=1727135628, error=Error(code=None, message=None, param=None), fine_tuned_model=None, finished_at=None, hyperparameters=Hyperparameters(n_epochs=3, batch_size=3, learning_rate_multiplier=0.3), model='gpt-4o-mini-2024-07-18', object='fine_tuning.job', organization_id='org-jLXWbL5JssIxj9KNgoFBK7Qi', result_files=[], seed=748607710, status='validating_files', trained_tokens=None, training_file='file-b2lo2chod6xuMhYg9JcEsnp6', validation_file='file-Fae0AVSUhTGr49qhQz8d2yyp', estimated_finish=None, integrations=[], user_provided_suffix=None)
Training Status: validating_filesसंचालित द्वारा

हम डैशबोर्ड पर “Fine-tuning” टैब पर क्लिक करके और जॉब ID पर क्लिक करके फाइन-ट्यूनिंग जॉब की स्थिति देख सकते हैं।

या हम jobs.retrieve फ़ंक्शन का उपयोग करके फाइन-ट्यूनिंग जॉब की स्थिति जाँच सकते हैं।

# Retrieve the state of a fine-tune
client.fine_tuning.jobs.retrieve(job_id)संचालित द्वारा

आउटपुट:

FineTuningJob(id='ftjob-rgIMFxZSsWDqCNfOev54e4Jq', created_at=1727135628, error=Error(code=None, message=None, param=None), fine_tuned_model=None, finished_at=None, hyperparameters=Hyperparameters(n_epochs=3, batch_size=3, learning_rate_multiplier=0.3), model='gpt-4o-mini-2024-07-18', object='fine_tuning.job', organization_id='org-jLXWbL5JssIxj9KNgoFBK7Qi', result_files=[], seed=748607710, status='running', trained_tokens=None, training_file='file-b2lo2chod6xuMhYg9JcEsnp6', validation_file='file-Fae0AVSUhTGr49qhQz8d2yyp', estimated_finish=1727135943, integrations=[], user_provided_suffix=None)संचालित द्वारा

यदि आपको लगता है कि लॉस कम नहीं हो रहा है, तो आप jobs.cancel फ़ंक्शन का उपयोग करके जॉब रद्द कर सकते हैं।

# Cancel a job
client.fine_tuning.jobs.cancel(job_id)संचालित द्वारा

जब फाइन-ट्यूनिंग जॉब पूरा हो जाएगा, तो आपको ईमेल प्राप्त होगा जिसमें बताया जाएगा कि फाइन-ट्यून किया हुआ मॉडल उपयोग के लिए तैयार है।

API का उपयोग करके फाइन-ट्यून किए मॉडल तक पहुँचना

फाइन-ट्यून किए मॉडल तक पहुँचने के लिए हमें उसके नाम की आवश्यकता होगी। इसके लिए, हम सभी फाइन-ट्यूनिंग जॉब्स की जानकारी इकट्ठा करेंगे, नवीनतम को चुनेंगे, और फिर मॉडल का नाम चुनेंगे।

result = client.fine_tuning.jobs.list()

# Retrieve the fine tuned model
fine_tuned_model = result.data[0].fine_tuned_model
print(fine_tuned_model)संचालित द्वारा

यह हमारा फाइन-ट्यून किया हुआ मॉडल नाम है।

ft:gpt-4o-mini-2024-07-18:personal::AAnFfX5qसंचालित द्वारा

चैट कम्प्लीशन फ़ंक्शन को फाइन-ट्यून किए मॉडल का नाम, सही system प्रॉम्प्ट के साथ संदेश, और डेटासेट से एक सैंपल देकर प्रतिक्रिया जनरेट करें।

completion = client.chat.completions.create(
  model = fine_tuned_model,
  messages=[
    {"role": "system", "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'."},
    {"role": "user", "content": "Just went to my first homecoming, and they played a song I've always wanted to dance to at an official dance. Sorry for the terrible quality, but my happiness in this moment couldn't be exaggerated!"}
  ]
)
print(completion.choices[0].message.content)संचालित द्वारा

सफलता! मैंने लेबल सही तरीके से भविष्यवाणी किया।

"non-stress"संचालित द्वारा

यदि आप अपने मॉडल से संतुष्ट नहीं हैं, तो आप हमेशा निम्न कमांड का उपयोग करके इसे हटा सकते हैं। हम ऐसा नहीं करेंगे क्योंकि हमें पहले अतिरिक्त मॉडल मूल्यांकन चलाने हैं।

# Delete a fine-tuned model (must be an owner of the org the model was created in)
client.models.delete(fine_tuned_model)संचालित द्वारा

Playground का उपयोग करके फाइन-ट्यून किए मॉडल तक पहुँचना

फाइन-ट्यून किए मॉडल तक पहुँचने और उसे विभिन्न प्रॉम्प्ट्स पर अधिक कुशलता से जाँचने का एक और तरीका भी है।

OpenAI डैशबोर्ड पर जाएँ, "Fine-tuning" टैब पर क्लिक करें, हाल ही में चले जॉब का चयन करें, और फिर नीचे दाईं ओर स्थित "Playground" बटन पर क्लिक करें।

यह आपको चैटबॉट एप्लिकेशन पर ले जाएगा। वहाँ, आप system प्रॉम्प्ट प्रदान कर सकते हैं और सैंपल Reddit पोस्ट टाइप करना शुरू कर सकते हैं।

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

मॉडल मूल्यांकन

हमने मॉडल को फाइन-ट्यून कर लिया है और हमें लगता है कि यह पर्याप्त अच्छा है। लेकिन क्या आपने यह भी सोचा कि क्या यह शुरुआत से ही बेहतर था? हमने अभी तक पहले और बाद का विस्तृत तुलना नहीं की है।

इस खंड में, हम validation डाटा का उपयोग करके बेस मॉडल से लेबल्स की भविष्यवाणी करेंगे और फिर उसे फाइन-ट्यून किए मॉडल से तुलना करेंगे। हम दोनों मॉडलों की तुलना accuracy, classification रिपोर्ट, और confusion मैट्रिक्स के आधार पर करेंगे।

फाइन-ट्यूनिंग से पहले मॉडल मूल्यांकन

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

def predict(test, model):
    y_pred = []
    categories = ["non-stress", "stress"]

    for index, row in test.iterrows():
        response = client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "system",
                    "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'.",
                },
                {"role": "user", "content": row["title"]},
            ],
        )

        answer = response.choices[0].message.content

        # Determine the predicted category

        for category in categories:
            if category.lower() in answer.lower():
                y_pred.append(category)
                break
        else:
            y_pred.append("none")
    return y_predसंचालित द्वारा

इसके बाद, हम evaluate फ़ंक्शन बनाएँगे, जो भविष्यवाणी किए गए और वास्तविक लेबल्स का उपयोग कर accuracy स्कोर, classification रिपोर्ट, और confusion मैट्रिक्स जनरेट करेगा।

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import numpy as np


def evaluate(y_true, y_pred):
    labels = ["non-stress", "stress"]
    mapping = {label: idx for idx, label in enumerate(labels)}

    def map_func(x):
        return mapping.get(
            x, -1
        )  # Map to -1 if not found, but should not occur with correct data

    y_true_mapped = np.vectorize(map_func)(y_true)
    y_pred_mapped = np.vectorize(map_func)(y_pred)

    # Calculate accuracy

    accuracy = accuracy_score(y_true=y_true_mapped, y_pred=y_pred_mapped)
    print(f"Accuracy: {accuracy:.3f}")

    # Generate accuracy report

    unique_labels = set(y_true_mapped)  # Get unique labels

    for label in unique_labels:
        label_indices = [
            i for i in range(len(y_true_mapped)) if y_true_mapped[i] == label
        ]
        label_y_true = [y_true_mapped[i] for i in label_indices]
        label_y_pred = [y_pred_mapped[i] for i in label_indices]
        label_accuracy = accuracy_score(label_y_true, label_y_pred)
        print(f"Accuracy for label {labels[label]}: {label_accuracy:.3f}")
    # Generate classification report

    class_report = classification_report(
        y_true=y_true_mapped,
        y_pred=y_pred_mapped,
        target_names=labels,
        labels=list(range(len(labels))),
    )
    print("\nClassification Report:")
    print(class_report)

    # Generate confusion matrix

    conf_matrix = confusion_matrix(
        y_true=y_true_mapped, y_pred=y_pred_mapped, labels=list(range(len(labels)))
    )
    print("\nConfusion Matrix:")
    print(conf_matrix)
संचालित द्वारा

predict फ़ंक्शन को validation डेटासेट और बेस मॉडल नाम के साथ चलाएँ। फिर, भविष्यवाणी किए और वास्तविक लेबल्स को evaluate फ़ंक्शन में दें और मॉडल मूल्यांकन रिपोर्ट जनरेट करें।

y_pred = predict(validation_data, "gpt-4o-mini-2024-07-18")
y_true = validation_data["label"]
evaluate(y_true, y_pred)संचालित द्वारा

हमारा बेस मॉडल पाठ को वर्गीकृत करने में काफ़ी अच्छा है। हमने 92.5% accuracy हासिल की।

Accuracy: 0.925
Accuracy for label non-stress: 0.947
Accuracy for label stress: 0.905

Classification Report:
              precision    recall  f1-score   support

  non-stress       0.90      0.95      0.92        19
      stress       0.95      0.90      0.93        21

    accuracy                           0.93        40
   macro avg       0.93      0.93      0.92        40
weighted avg       0.93      0.93      0.93        40


Confusion Matrix:
[[18  1]
 [ 2 19]]संचालित द्वारा

फाइन-ट्यूनिंग के बाद मॉडल मूल्यांकन

आइए predict फ़ंक्शन का उपयोग फाइन-ट्यून किए मॉडल नाम के साथ करके stress लेबल जनरेट करें। फिर, भविष्यवाणी किए गए और वास्तविक लेबल्स का उपयोग करके विस्तृत मॉडल मूल्यांकन रिपोर्ट बनाएँ।

fine_tuned_model = "ft:gpt-4o-mini-2024-07-18:personal::AAnFfX5q"

y_pred = predict(validation_data,fine_tuned_model)
evaluate(y_true, y_pred)संचालित द्वारा

हमारे मॉडल का प्रदर्शन बेहतर हुआ है। हमने 97.5% accuracy हासिल की, जो एक महत्वपूर्ण सुधार है।

Accuracy: 0.975
Accuracy for label non-stress: 1.000
Accuracy for label stress: 0.952

Classification Report:
              precision    recall  f1-score   support

  non-stress       0.95      1.00      0.97        19
      stress       1.00      0.95      0.98        21

    accuracy                           0.97        40
   macro avg       0.97      0.98      0.97        40
weighted avg       0.98      0.97      0.98        40


Confusion Matrix:
[[19  0]
 [ 1 20]]संचालित द्वारा

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

यदि आपको ऊपर दिया गया कोड चलाने में समस्याएँ आ रही हैं, तो कृपया DataLab वर्कस्पेस देखें: Fine-tuning GPT-4 Mini.

आपकी अगली यात्रा का कदम है इस फाइन-ट्यून किए मॉडल का उपयोग करके एक उचित AI एप्लिकेशन बनाना। आप इसे कोड-अलॉन्ग के माध्यम से सीख सकते हैं: Creating AI Assistants with GPT-4o।

निष्कर्ष

इस ट्यूटोरियल में, हमने सफलतापूर्वक GPT-4o mini मॉडल को "stress" और "non-stress" लेबल में पाठ को वर्गीकृत करने के लिए फाइन-ट्यून किया। फिर हमने इस फाइन-ट्यून किए मॉडल तक OpenAI API और OpenAI playground के माध्यम से पहुँच बनाई, जिससे व्यावहारिक उपयोग और आगे की जाँच संभव हुई।

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

यदि आप किसी नि:शुल्क, ओपन-सोर्स मॉडल का उपयोग करना चाहते हैं, तो हमारे पास एक उत्कृष्ट ट्यूटोरियल है Fine-tuning Llama 3.2 and Using It Locally: A Step-by-Step Guide। इस गाइड में, हम आपको नवीनतम Llama मॉडल को फाइन-ट्यून करने और उसे आपके लैपटॉप पर लोकल उपयोग के लिए GGUF फ़ॉर्मेट में बदलने का तरीका दिखाएँगे।

लेखक

Abid Ali Awan

LinkedIn Twitter

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

विषय

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

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

विषय

GPT-4o Mini का फाइन-ट्यूनिंग: चरण-दर-चरण मार्गदर्शिका

AI के साथ खोजें

GPT-4o Mini का परिचय

OpenAI API सेटअप करना

GPT-4o Mini का फाइन-ट्यूनिंग

डेटासेट बनाना

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

फाइन-ट्यूनिंग जॉब शुरू करना

API का उपयोग करके फाइन-ट्यून किए मॉडल तक पहुँचना

Playground का उपयोग करके फाइन-ट्यून किए मॉडल तक पहुँचना

मॉडल मूल्यांकन

फाइन-ट्यूनिंग से पहले मॉडल मूल्यांकन

फाइन-ट्यूनिंग के बाद मॉडल मूल्यांकन

निष्कर्ष

विषय

शीर्ष DataCamp OpenAI कोर्स

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

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

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

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

विषय

शीर्ष DataCamp OpenAI कोर्स

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

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

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