Cara Menyelesaikan Kod Ralat API OpenAI 429 dalam Python Walaupun Dengan Kredit

Memahami Ralat Kuota OpenAI API

Apabila bekerja dengan API OpenAI, menerima ralat seperti Kod Ralat 429 boleh mengecewakan, terutamanya bagi mereka yang baru menggunakan Python dan OpenAI. Ralat ini biasanya menunjukkan bahawa anda telah melebihi kuota penggunaan API semasa anda.

Jika anda telah menyemak akaun OpenAI anda dan mengesahkan bahawa anda masih mempunyai kredit yang tersedia, anda mungkin tertanya-tanya mengapa ralat ini terus muncul. Adalah perkara biasa bagi pembangun menghadapi isu ini apabila mula-mula menyediakan panggilan API mereka.

Memahami punca isu ini adalah penting untuk memastikan anda boleh memanfaatkan API dengan berkesan. Panduan ini akan memecahkan kemungkinan sebab di sebalik ralat dan memberi anda langkah untuk menyelesaikannya.

Mari kita mendalami kemungkinan sebab mengapa anda menghadapi ralat ini, walaupun anda mempunyai kredit dalam akaun OpenAI anda, dan cara pendekatan membetulkannya dalam skrip Python anda.

Cara Skrip Python Mengendalikan Had Kadar API OpenAI

Skrip yang disediakan di atas direka untuk menangani masalah biasa yang dihadapi oleh pembangun apabila menggunakan API OpenAI: menghadapi mesej ralat yang menunjukkan bahawa anda telah melebihi kuota API walaupun mempunyai kredit. Isu ini berkaitan dengan had kadar yang dikenakan oleh OpenAI ke atas bilangan permintaan dalam tempoh tertentu. Skrip utama ditulis untuk mengendalikan situasi ini dengan menggunakan mekanisme pengendalian ralat dan cuba semula. Ia menggunakan RateLimitError pengecualian untuk mengesan apabila terlalu banyak permintaan dihantar dalam tempoh yang singkat, mencetuskan ralat. Selain itu, skrip menggunakan strategi cuba semula untuk mencuba panggilan API sekali lagi secara automatik selepas mencapai had kadar.

Untuk melaksanakan strategi ini, skrip pertama mentakrifkan fungsi yang dipanggil create_completion, yang menerima gesaan dan bilangan percubaan semula yang dibenarkan. Fungsi ini cuba membuat panggilan ke API penyiapan OpenAI, menjana respons berdasarkan model dan gesaan yang diberikan. Jika ralat had kadar dikesan, fungsi mencetak mesej bermaklumat dan secara rekursif memanggil dirinya sendiri untuk mencuba semula operasi. Pendekatan ini berkesan dalam mengelakkan penamatan skrip secara mendadak sambil menguruskan had kadar API dengan cekap.

Dalam skrip kedua, strategi pengendalian ralat serupa dilaksanakan tetapi termasuk logik tambahan untuk menukar model jika melebihi had kadar. Ini amat berguna apabila model yang berbeza mungkin mempunyai had kadar yang berbeza-beza. Skrip bermula dengan memulakan klien OpenAI menggunakan fungsi tersuai yang dipanggil mulakan klien. Fungsi ini mengesahkan kesahihan kunci API, memastikan skrip telah disahkan dengan jayanya sebelum meneruskan dengan panggilan selanjutnya. Jika pengesahan gagal, ia mengembalikan mesej ralat yang jelas kepada pengguna, mengurangkan kekeliruan mengenai salah konfigurasi.

Skrip kedua juga memperkenalkan fungsi bernama create_chat, yang mencuba panggilan API menggunakan model tertentu. Jika a RateLimitError dinaikkan, fungsi mencetak mesej yang menunjukkan bahawa ia akan bertukar kepada model sandaran, seperti daripada "davinci-002" kepada "davinci-003". Ini menunjukkan fleksibiliti dalam menguruskan had kadar sambil terus memberikan hasil. Selain itu, skrip menggunakan pembolehubah persekitaran untuk mengurus kunci API dengan selamat menggunakan dotenv pakej, menekankan amalan pengekodan selamat. Pembolehubah persekitaran mengurangkan risiko mendedahkan data sensitif dalam pangkalan kod.

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)

Mengatasi Ralat Had Kadar OpenAI dalam Skrip Python

Apabila bekerja dengan OpenAI API, pengguna sering menghadapi kod ralat 429, yang menunjukkan bahawa bilangan permintaan API yang dibenarkan telah melebihi. Ini boleh membingungkan, terutamanya bagi pemula yang telah menyemak baki kredit mereka dan mengesahkan bahawa mereka mempunyai dana yang mencukupi. Dalam kes sedemikian, isunya mungkin bukan mengenai kredit yang tersedia tetapi mengenai had kadar yang ditetapkan oleh OpenAI. Had ini boleh mengehadkan bilangan panggilan API yang boleh anda buat dalam tempoh masa tertentu. Memahami dan mengurus had ini dengan berkesan adalah penting untuk membina penyelesaian yang boleh dipercayai.

Satu cara untuk mengendalikan ini adalah dengan memperkenalkan mekanisme cuba semula, seperti yang ditunjukkan dalam contoh skrip sebelumnya. Walau bagaimanapun, satu lagi aspek penting yang perlu dipertimbangkan ialah memahami OpenAI dasar kuota secara mendalam. OpenAI mungkin menguatkuasakan had kadar yang berbeza berdasarkan model atau jenis akaun yang digunakan. Sebagai contoh, akaun peringkat bebas mungkin menghadapi had yang lebih ketat berbanding peringkat berbayar, yang boleh mempengaruhi cara anda mereka bentuk panggilan API anda. Selain itu, pengguna harus memastikan bahawa kebenaran kunci API mereka disediakan dengan betul, kerana salah konfigurasi juga boleh mencetuskan ralat kuota.

Selain menguruskan percubaan semula dan memilih model sandaran, mengoptimumkan panggilan API adalah penting. Ini termasuk meminimumkan permintaan API yang tidak perlu dan memfokuskan pada permintaan kritikal. Pembangun juga boleh menjejaki statistik penggunaan API daripada papan pemuka OpenAI untuk mendapatkan cerapan tentang corak penggunaan mereka dan melaraskan skrip mereka dengan sewajarnya. Dengan melaksanakan strategi ini, anda boleh mengurangkan kemungkinan mencapai had kadar dan memastikan interaksi yang lebih lancar dengan API OpenAI.