கிரெடிட்டுடன் கூட பைத்தானில் OpenAI API பிழைக் குறியீடு 429 ஐ எவ்வாறு தீர்ப்பது

OpenAI API கோட்டா பிழைகளைப் புரிந்துகொள்வது

OpenAI இன் API உடன் பணிபுரியும் போது, ​​போன்ற பிழையைப் பெறுகிறது பிழைக் குறியீடு 429 குறிப்பாக Python மற்றும் OpenAI இரண்டிற்கும் புதியவர்களுக்கு ஏமாற்றமாக இருக்கலாம். உங்கள் தற்போதைய API பயன்பாட்டு ஒதுக்கீட்டை நீங்கள் தாண்டிவிட்டீர்கள் என்பதை இந்தப் பிழை பொதுவாகக் குறிக்கிறது.

உங்கள் OpenAI கணக்கைச் சரிபார்த்து, உங்களிடம் இன்னும் கிரெடிட்கள் இருப்பதை உறுதிசெய்தால், இந்தப் பிழை ஏன் தொடர்ந்து காண்பிக்கப்படுகிறது என்று நீங்கள் யோசிக்கலாம். டெவலப்பர்கள் தங்கள் API அழைப்புகளை முதலில் அமைக்கும் போது இந்தச் சிக்கலை எதிர்கொள்வது பொதுவானது.

இந்தச் சிக்கலுக்கான காரணத்தைப் புரிந்துகொள்வது, நீங்கள் APIயை திறம்பட பயன்படுத்த முடியும் என்பதை உறுதிசெய்ய மிகவும் முக்கியமானது. இந்த வழிகாட்டி பிழையின் பின்னணியில் உள்ள சாத்தியமான காரணங்களை உடைத்து, அதைத் தீர்ப்பதற்கான வழிமுறைகளை உங்களுக்கு வழங்கும்.

உங்கள் OpenAI கணக்கில் கிரெடிட்கள் இருந்தாலும், இந்த பிழையை நீங்கள் எதிர்கொள்வதற்கான சாத்தியமான காரணங்கள் மற்றும் உங்கள் Python ஸ்கிரிப்ட்டில் அதை எவ்வாறு சரிசெய்வது என்பதை பற்றி பார்ப்போம்.

பைதான் ஸ்கிரிப்ட்கள் OpenAI API விகித வரம்புகளை எவ்வாறு கையாளுகின்றன

மேலே வழங்கப்பட்டுள்ள ஸ்கிரிப்டுகள், OpenAI இன் API ஐப் பயன்படுத்தும் போது டெவலப்பர்கள் எதிர்கொள்ளும் பொதுவான சிக்கலைத் தீர்க்க வடிவமைக்கப்பட்டுள்ளது: நீங்கள் அதிகமாகிவிட்டீர்கள் என்பதைக் குறிக்கும் பிழைச் செய்தியை எதிர்கொண்டால் API ஒதுக்கீடு கடன் இருந்தாலும். இந்தச் சிக்கல் ஒரு குறிப்பிட்ட காலத்திற்குள் கோரிக்கைகளின் எண்ணிக்கையில் OpenAI விதித்துள்ள விகித வரம்புடன் தொடர்புடையது. பிழை கையாளுதல் மற்றும் மறுமுயற்சி பொறிமுறைகளைப் பயன்படுத்தி இந்த சூழ்நிலையை கையாள முதன்மை ஸ்கிரிப்ட் எழுதப்பட்டுள்ளது. இது பயன்படுத்துகிறது RateLimitError ஒரு குறுகிய காலத்தில் பல கோரிக்கைகள் அனுப்பப்பட்டால், பிழையைத் தூண்டும் போது கண்டறிய விதிவிலக்கு. கூடுதலாக, ஸ்கிரிப்ட்கள் விகித வரம்பை அடைந்த பிறகு தானாகவே API அழைப்பை மீண்டும் முயற்சி செய்ய மறுமுயற்சி உத்தியைப் பயன்படுத்துகின்றன.

இந்த உத்திகளைச் செயல்படுத்த, முதல் ஸ்கிரிப்ட் ஒரு செயல்பாட்டை வரையறுக்கிறது உருவாக்குதல்_நிறைவு, இது ஒரு ப்ராம்ட் மற்றும் அனுமதிக்கப்பட்ட மறு முயற்சிகளின் எண்ணிக்கையை ஏற்றுக்கொள்கிறது. இந்த செயல்பாடு OpenAI இன் நிறைவு API க்கு அழைப்பை மேற்கொள்ள முயற்சிக்கிறது, கொடுக்கப்பட்ட மாதிரி மற்றும் ப்ராம்ட் அடிப்படையில் பதிலை உருவாக்குகிறது. விகித வரம்பு பிழை கண்டறியப்பட்டால், செயல்பாடு ஒரு தகவல் செய்தியை அச்சிடுகிறது மற்றும் செயல்பாட்டை மீண்டும் முயற்சி செய்ய மீண்டும் மீண்டும் தன்னை அழைக்கிறது. API வீத வரம்புகளை திறம்பட நிர்வகிக்கும் போது, ​​திடீர் ஸ்கிரிப்ட் முடிவுகளைத் தவிர்ப்பதில் இந்த அணுகுமுறை பயனுள்ளதாக இருக்கும்.

இரண்டாவது ஸ்கிரிப்ட்டில், இதேபோன்ற பிழை கையாளும் உத்தி செயல்படுத்தப்படுகிறது, ஆனால் விகித வரம்பை மீறினால் மாதிரிகளை மாற்ற கூடுதல் லாஜிக் உள்ளது. வெவ்வேறு மாதிரிகள் மாறுபட்ட விகித வரம்புகளைக் கொண்டிருக்கும்போது இது மிகவும் பயனுள்ளதாக இருக்கும். தனிப்பயன் செயல்பாட்டைப் பயன்படுத்தி OpenAI கிளையண்டை துவக்குவதன் மூலம் ஸ்கிரிப்ட் தொடங்குகிறது வாடிக்கையாளரை துவக்கவும். இந்தச் செயல்பாடு API விசையின் செல்லுபடியை சரிபார்க்கிறது, மேலும் அழைப்புகளைத் தொடர்வதற்கு முன் ஸ்கிரிப்ட் வெற்றிகரமாக அங்கீகரிக்கப்பட்டதை உறுதிசெய்கிறது. அங்கீகாரம் தோல்வியுற்றால், அது பயனருக்கு தெளிவான பிழைச் செய்தியைத் தருகிறது, தவறான உள்ளமைவுகளைச் சுற்றியுள்ள குழப்பத்தைக் குறைக்கிறது.

இரண்டாவது ஸ்கிரிப்ட் பெயரிடப்பட்ட ஒரு செயல்பாட்டையும் அறிமுகப்படுத்துகிறது உருவாக்க_அரட்டை, இது ஒரு குறிப்பிட்ட மாதிரியைப் பயன்படுத்தி API அழைப்பை முயற்சிக்கிறது. ஒரு என்றால் RateLimitError உயர்த்தப்பட்டது, செயல்பாடு "davinci-002" இலிருந்து "davinci-003" போன்ற ஒரு ஃபால்பேக் மாடலுக்கு மாறும் என்பதைக் குறிக்கும் செய்தியை அச்சிடுகிறது. முடிவுகளை வழங்குவதைத் தொடர்ந்து விகித வரம்புகளை நிர்வகிப்பதற்கான நெகிழ்வுத்தன்மையை இது நிரூபிக்கிறது. கூடுதலாக, ஸ்கிரிப்டுகள் API விசையைப் பாதுகாப்பாக நிர்வகிக்க சூழல் மாறிகளைப் பயன்படுத்துகின்றன dotenv தொகுப்பு, பாதுகாப்பான குறியீட்டு நடைமுறைகளை வலியுறுத்துகிறது. சுற்றுச்சூழல் மாறிகள் கோட்பேஸில் முக்கியமான தரவுகளை வெளிப்படுத்தும் அபாயத்தைக் குறைக்கிறது.

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError
# Load environment variables from a .env file
load_dotenv()
# Retrieve API key securely
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client
client = openai.OpenAI(api_key=api_key)
# Define a function to handle API calls with retry mechanism
def create_completion(prompt, retries=3):
    try:
        response = client.Completion.create(
            model="davinci-002",
            prompt=prompt,
            max_tokens=50
        )
        return response
    except RateLimitError as e:
        if retries > 0:
            print("Rate limit exceeded. Retrying...")
            return create_completion(prompt, retries - 1)
        else:
            print(f"Failed after multiple attempts: {str(e)}")
            return None
# Testing prompt
result = create_completion("Say this is a test")
if result:
    print(result)

import os
from dotenv import load_dotenv
import openai
from openai.error import RateLimitError, AuthenticationError
# Load environment variables
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
# Initialize OpenAI client with API key validation
def initialize_client(api_key):
    try:
        return openai.OpenAI(api_key=api_key)
    except AuthenticationError as auth_error:
        print("Invalid API key provided:", str(auth_error))
        return None
client = initialize_client(api_key)
# API call with fallback model if rate limit is reached
def create_chat(prompt, model="text-davinci-002"):
    try:
        response = client.Completion.create(
            model=model,
            prompt=prompt,
            max_tokens=60
        )
        return response
    except RateLimitError:
        print("Rate limit reached. Switching model...")
        return create_chat(prompt, model="text-davinci-003")
# Testing fallback mechanism
result = create_chat("Say this is another test")
if result:
    print(result)

பைதான் ஸ்கிரிப்ட்களில் OpenAI விகித வரம்பு பிழைகளை சமாளித்தல்

OpenAI API உடன் பணிபுரியும் போது, ​​பயனர்கள் அடிக்கடி பிழைக் குறியீட்டை எதிர்கொள்கின்றனர் 429, அனுமதிக்கப்பட்ட API கோரிக்கைகளின் எண்ணிக்கை மீறப்பட்டதைக் குறிக்கிறது. இது புதிராக இருக்கும், குறிப்பாக தங்கள் கடன் இருப்பை சரிபார்த்து, அவர்களிடம் போதுமான நிதி இருப்பதை உறுதிசெய்த ஆரம்பநிலையாளர்களுக்கு. இதுபோன்ற சந்தர்ப்பங்களில், சிக்கல் கிடைக்கக்கூடிய கிரெடிட்டைப் பற்றியது அல்ல, ஆனால் OpenAI ஆல் நிர்ணயிக்கப்பட்ட கட்டண வரம்புகளைப் பற்றியது. இந்த வரம்புகள் ஒரு குறிப்பிட்ட காலத்திற்குள் நீங்கள் செய்யக்கூடிய API அழைப்புகளின் எண்ணிக்கையை கட்டுப்படுத்தலாம். இந்த வரம்புகளை திறம்பட புரிந்துகொள்வதும் நிர்வகிப்பதும் நம்பகமான தீர்வை உருவாக்குவதற்கு முக்கியமானது.

முந்தைய ஸ்கிரிப்ட் எடுத்துக்காட்டுகளில் காட்டப்பட்டுள்ளபடி, மீண்டும் முயற்சி செய்யும் பொறிமுறையை அறிமுகப்படுத்துவதன் மூலம் இதைக் கையாள ஒரு வழி. இருப்பினும், கருத்தில் கொள்ள வேண்டிய மற்றொரு முக்கியமான அம்சம் OpenAI களைப் புரிந்துகொள்வது ஒதுக்கீடு கொள்கைகள் ஆழத்தில். OpenAI ஆனது மாதிரி அல்லது பயன்படுத்தப்படும் கணக்கு வகையின் அடிப்படையில் வெவ்வேறு கட்டண வரம்புகளைச் செயல்படுத்தலாம். எடுத்துக்காட்டாக, இலவச அடுக்கு கணக்குகள் கட்டண அடுக்குகளுடன் ஒப்பிடும்போது மிகவும் கடுமையான வரம்புகளை எதிர்கொள்ளக்கூடும், இது உங்கள் API அழைப்புகளை நீங்கள் வடிவமைக்கும் விதத்தை பாதிக்கலாம். கூடுதலாக, பயனர்கள் தங்கள் API விசை அனுமதிகள் சரியாக அமைக்கப்பட்டிருப்பதை உறுதி செய்ய வேண்டும், ஏனெனில் தவறான உள்ளமைவு ஒதுக்கீடு பிழைகளையும் தூண்டலாம்.

மறுமுயற்சிகளை நிர்வகிப்பது மற்றும் ஃபால்பேக் மாடல்களைத் தேர்ந்தெடுப்பது தவிர, API அழைப்புகளை மேம்படுத்துவது அவசியம். தேவையற்ற API கோரிக்கைகளைக் குறைப்பது மற்றும் முக்கியமானவற்றில் கவனம் செலுத்துவது ஆகியவை இதில் அடங்கும். டெவலப்பர்கள் தங்கள் நுகர்வு முறைகளைப் பற்றிய நுண்ணறிவுகளைப் பெறுவதற்கும் அதற்கேற்ப தங்கள் ஸ்கிரிப்ட்களை சரிசெய்யவும் OpenAI இன் டாஷ்போர்டில் இருந்து API பயன்பாட்டு புள்ளிவிவரங்களைக் கண்காணிக்கலாம். இந்த உத்திகளைச் செயல்படுத்துவதன் மூலம், நீங்கள் விகித வரம்புகளைத் தாக்கும் வாய்ப்பைக் குறைக்கலாம் மற்றும் OpenAI இன் API உடன் மென்மையான தொடர்புகளை உறுதிசெய்யலாம்.