Bermigrasi ke pustaka OPENAI Python API 1.x

Artikel
10/16/2024

OpenAI merilis versi baru pustaka OpenAI Python API. Panduan ini bersifat tambahan untuk panduan migrasi OpenAI dan akan membantu Anda mempercepat perubahan khusus untuk Azure OpenAI.

Pembaruan

Ini adalah versi baru dari pustaka OPENAI Python API.
Mulai tanggal 6 November 2023 pip install openai dan pip install openai --upgrade akan menginstal version 1.x pustaka OpenAI Python.
Memutakhirkan dari version 0.28.1 ke version 1.x adalah perubahan yang melanggar, Anda harus menguji dan memperbarui kode Anda.
Coba lagi secara otomatis dengan backoff jika ada kesalahan
Jenis yang tepat (untuk mypy/pyright/editors)
Anda sekarang dapat membuat instans klien, alih-alih menggunakan default global.
Beralih ke instansiasi klien eksplisit
Perubahan nama

Masalah umum

DALL-E3didukung penuh dengan rilis 1.x terbaru.DALL-E2 dapat digunakan dengan 1.x dengan membuat modifikasi berikut pada kode Anda.
embeddings_utils.py yang digunakan untuk menyediakan fungsionalitas seperti kesamaan kosinus untuk pencarian teks semantik tidak lagi menjadi bagian dari pustaka OPENAI Python API.
Anda juga harus memeriksa Masalah GitHub aktif untuk pustaka OpenAI Python.

Uji sebelum Anda bermigrasi

Penting

Migrasi otomatis kode Anda menggunakan openai migrate tidak didukung dengan Azure OpenAI.

Karena ini adalah versi baru pustaka dengan perubahan yang melanggar, Anda harus menguji kode Anda secara ekstensif terhadap rilis baru sebelum memigrasikan aplikasi produksi apa pun untuk mengandalkan versi 1.x. Anda juga harus meninjau kode dan proses internal untuk memastikan bahwa Anda mengikuti praktik terbaik dan menyematkan kode produksi hanya ke versi yang telah Anda uji sepenuhnya.

Untuk mempermudah proses migrasi, kami memperbarui contoh kode yang ada di dokumen kami untuk Python ke pengalaman bertab:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai --upgrade

pip install openai==0.28.1

Ini menyediakan konteks untuk apa yang telah berubah dan memungkinkan Anda menguji pustaka baru secara paralel sambil terus memberikan dukungan untuk versi 0.28.1. Jika Anda meningkatkan ke 1.x dan menyadari bahwa Anda perlu mengembalikan untuk sementara ke versi sebelumnya, Anda selalu pip uninstall openai dapat dan kemudian menginstal ulang yang ditargetkan dengan 0.28.1 pip install openai==0.28.1.

Anda perlu mengatur model variabel ke nama penyebaran yang Anda pilih saat menyebarkan model GPT-3.5-Turbo atau GPT-4. Memasukkan nama model menghasilkan kesalahan kecuali Anda memilih nama penyebaran yang identik dengan nama model yang mendasar.

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"), 
  api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version="2024-02-01"
)

response = client.chat.completions.create(
    model="gpt-35-turbo", # model = "deployment_name"
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response.choices[0].message.content)

Contoh tambahan dapat ditemukan di artikel Penyelesaian Obrolan mendalam kami.

Anda perlu mengatur engine variabel ke nama penyebaran yang Anda pilih saat menyebarkan model GPT-3.5-Turbo atau GPT-4. Memasukkan nama model akan mengakibatkan kesalahan kecuali Anda memilih nama penyebaran yang identik dengan nama model yang mendasar.

import os
import openai
openai.api_type = "azure"
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") 
openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_version = "2024-02-01"

response = openai.ChatCompletion.create(
    engine="gpt-35-turbo", # engine = "deployment_name".
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Does Azure OpenAI support customer managed keys?"},
        {"role": "assistant", "content": "Yes, customer managed keys are supported by Azure OpenAI."},
        {"role": "user", "content": "Do other Azure AI services support this too?"}
    ]
)

print(response)
print(response['choices'][0]['message']['content'])

Penyelesaian

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-02-01",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
)
    
deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 
    
# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = client.completions.create(model=deployment_name, prompt=start_phrase, max_tokens=10) # model = "deployment_name"
print(response.choices[0].text)

import os
import openai

openai.api_key = os.getenv("AZURE_OPENAI_API_KEY")
openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # your endpoint should look like the following https://YOUR_RESOURCE_NAME.openai.azure.com/
openai.api_type = 'azure'
openai.api_version = '2024-02-01' # this might change in the future

deployment_name='REPLACE_WITH_YOUR_DEPLOYMENT_NAME' #This will correspond to the custom name you chose for your deployment when you deployed a model. 

# Send a completion call to generate an answer
print('Sending a test completion job')
start_phrase = 'Write a tagline for an ice cream shop. '
response = openai.Completion.create(engine=deployment_name, prompt=start_phrase, max_tokens=10)
text = response['choices'][0]['text'].replace('\n', '').replace(' .', '.').strip()
print(start_phrase+text)

Penyematan

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
from openai import AzureOpenAI

client = AzureOpenAI(
  api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
  api_version = "2024-02-01",
  azure_endpoint =os.getenv("AZURE_OPENAI_ENDPOINT") 
)

response = client.embeddings.create(
    input = "Your text string goes here",
    model= "text-embedding-ada-002"  # model = "deployment_name".
)

print(response.model_dump_json(indent=2))

Contoh tambahan termasuk cara menangani pencarian teks semantik tanpa embeddings_utils.py dapat ditemukan dalam tutorial penyematan kami.

import openai

openai.api_type = "azure"
openai.api_key = YOUR_API_KEY
openai.api_base = "https://YOUR_RESOURCE_NAME.openai.azure.com"
openai.api_version = "2024-02-01"

response = openai.Embedding.create(
    input="Your text string goes here",
    engine="YOUR_DEPLOYMENT_NAME"
)
embeddings = response['data'][0]['embedding']
print(embeddings)

Asinkron

OpenAI tidak mendukung panggilan metode asinkron di klien tingkat modul, sebagai gantinya Anda harus membuat instans klien asinkron.

import os
import asyncio
from openai import AsyncAzureOpenAI

async def main():
    client = AsyncAzureOpenAI(  
      api_key = os.getenv("AZURE_OPENAI_API_KEY"),  
      api_version = "2024-02-01",
      azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )
    response = await client.chat.completions.create(model="gpt-35-turbo", messages=[{"role": "user", "content": "Hello world"}]) # model = model deployment name

    print(response.model_dump_json(indent=2))

asyncio.run(main())

Autentikasi

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default")

api_version = "2024-02-01"
endpoint = "https://my-resource.openai.azure.com"

client = AzureOpenAI(
    api_version=api_version,
    azure_endpoint=endpoint,
    azure_ad_token_provider=token_provider,
)

completion = client.chat.completions.create(
    model="deployment-name",  # model = "deployment_name"
    messages=[
        {
            "role": "user",
            "content": "How do I output all files in a directory using Python?",
        },
    ],
)
print(completion.model_dump_json(indent=2))

Menggunakan data Anda

Untuk langkah-langkah konfigurasi lengkap yang diperlukan untuk membuat contoh kode ini berfungsi, lihat menggunakan mulai cepat data Anda.

OpenAI Python 1.x
OpenAI Python 0.28.1

import os
import openai
import dotenv

dotenv.load_dotenv()

endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
api_key = os.environ.get("AZURE_OPENAI_API_KEY")
deployment = os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID")

client = openai.AzureOpenAI(
    base_url=f"{endpoint}/openai/deployments/{deployment}/extensions",
    api_key=api_key,
    api_version="2023-08-01-preview",
)

completion = client.chat.completions.create(
    model=deployment, # model = "deployment_name"
    messages=[
        {
            "role": "user",
            "content": "How is Azure machine learning different than Azure OpenAI?",
        },
    ],
    extra_body={
        "dataSources": [
            {
                "type": "AzureCognitiveSearch",
                "parameters": {
                    "endpoint": os.environ["AZURE_AI_SEARCH_ENDPOINT"],
                    "key": os.environ["AZURE_AI_SEARCH_API_KEY"],
                    "indexName": os.environ["AZURE_AI_SEARCH_INDEX"]
                }
            }
        ]
    }
)

print(completion.model_dump_json(indent=2))

import os
import openai
import dotenv
import requests

dotenv.load_dotenv()

openai.api_base = os.environ.get("AZURE_OPENAI_ENDPOINT")
openai.api_version = "2023-08-01-preview"
openai.api_type = 'azure'
openai.api_key = os.environ.get("AZURE_OPENAI_API_KEY")

def setup_byod(deployment_id: str) -> None:
    """Sets up the OpenAI Python SDK to use your own data for the chat endpoint.

    :param deployment_id: The deployment ID for the model to use with your own data.

    To remove this configuration, simply set openai.requestssession to None.
    """

    class BringYourOwnDataAdapter(requests.adapters.HTTPAdapter):

     def send(self, request, **kwargs):
         request.url = f"{openai.api_base}/openai/deployments/{deployment_id}/extensions/chat/completions?api-version={openai.api_version}"
         return super().send(request, **kwargs)

    session = requests.Session()

    # Mount a custom adapter which will use the extensions endpoint for any call using the given `deployment_id`
    session.mount(
        prefix=f"{openai.api_base}/openai/deployments/{deployment_id}",
        adapter=BringYourOwnDataAdapter()
    )

    openai.requestssession = session

aoai_deployment_id = os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID")
setup_byod(aoai_deployment_id)

completion = openai.ChatCompletion.create(
    messages=[{"role": "user", "content": "What are the differences between Azure Machine Learning and Azure AI services?"}],
    deployment_id=os.environ.get("AZURE_OPEN_AI_DEPLOYMENT_ID"),
    dataSources=[  # camelCase is intentional, as this is the format the API expects
        {
            "type": "AzureCognitiveSearch",
            "parameters": {
                "endpoint": os.environ.get("AZURE_AI_SEARCH_ENDPOINT"),
                "key": os.environ.get("AZURE_AI_SEARCH_API_KEY"),
                "indexName": os.environ.get("AZURE_AI_SEARCH_INDEX"),
            }
        }
    ]
)
print(completion)

Perbaikan DALL-E

Perbaikan DALLE
Asinkron Perbaikan DALLE

import time
import json
import httpx
import openai


class CustomHTTPTransport(httpx.HTTPTransport):
    def handle_request(
        self,
        request: httpx.Request,
    ) -> httpx.Response:
        if "images/generations" in request.url.path and request.url.params[
            "api-version"
        ] in [
            "2023-06-01-preview",
            "2023-07-01-preview",
            "2023-08-01-preview",
            "2023-09-01-preview",
            "2023-10-01-preview",
        ]:
            request.url = request.url.copy_with(path="/openai/images/generations:submit")
            response = super().handle_request(request)
            operation_location_url = response.headers["operation-location"]
            request.url = httpx.URL(operation_location_url)
            request.method = "GET"
            response = super().handle_request(request)
            response.read()

            timeout_secs: int = 120
            start_time = time.time()
            while response.json()["status"] not in ["succeeded", "failed"]:
                if time.time() - start_time > timeout_secs:
                    timeout = {"error": {"code": "Timeout", "message": "Operation polling timed out."}}
                    return httpx.Response(
                        status_code=400,
                        headers=response.headers,
                        content=json.dumps(timeout).encode("utf-8"),
                        request=request,
                    )

                time.sleep(int(response.headers.get("retry-after")) or 10)
                response = super().handle_request(request)
                response.read()

            if response.json()["status"] == "failed":
                error_data = response.json()
                return httpx.Response(
                    status_code=400,
                    headers=response.headers,
                    content=json.dumps(error_data).encode("utf-8"),
                    request=request,
                )

            result = response.json()["result"]
            return httpx.Response(
                status_code=200,
                headers=response.headers,
                content=json.dumps(result).encode("utf-8"),
                request=request,
            )
        return super().handle_request(request)


client = openai.AzureOpenAI(
    azure_endpoint="<azure_endpoint>",
    api_key="<api_key>",
    api_version="<api_version>",
    http_client=httpx.Client(
        transport=CustomHTTPTransport(),
    ),
)
image = client.images.generate(prompt="a cute baby seal")

print(image.data[0].url)

import time
import asyncio
import json
import httpx
import openai


class AsyncCustomHTTPTransport(httpx.AsyncHTTPTransport):
    async def handle_async_request(
        self,
        request: httpx.Request,
    ) -> httpx.Response:
        if "images/generations" in request.url.path and request.url.params[
            "api-version"
        ] in [
            "2023-06-01-preview",
            "2023-07-01-preview",
            "2023-08-01-preview",
            "2023-09-01-preview",
            "2023-10-01-preview",
        ]:
            request.url = request.url.copy_with(path="/openai/images/generations:submit")
            response = await super().handle_async_request(request)
            operation_location_url = response.headers["operation-location"]
            request.url = httpx.URL(operation_location_url)
            request.method = "GET"
            response = await super().handle_async_request(request)
            await response.aread()

            timeout_secs: int = 120
            start_time = time.time()
            while response.json()["status"] not in ["succeeded", "failed"]:
                if time.time() - start_time > timeout_secs:
                    timeout = {"error": {"code": "Timeout", "message": "Operation polling timed out."}}
                    return httpx.Response(
                        status_code=400,
                        headers=response.headers,
                        content=json.dumps(timeout).encode("utf-8"),
                        request=request,
                    )

                await asyncio.sleep(int(response.headers.get("retry-after")) or 10)
                response = await super().handle_async_request(request)
                await response.aread()

            if response.json()["status"] == "failed":
                error_data = response.json()
                return httpx.Response(
                    status_code=400,
                    headers=response.headers,
                    content=json.dumps(error_data).encode("utf-8"),
                    request=request,
                )

            result = response.json()["result"]
            return httpx.Response(
                status_code=200,
                headers=response.headers,
                content=json.dumps(result).encode("utf-8"),
                request=request,
            )
        return await super().handle_async_request(request)


async def dall_e():
    client = openai.AsyncAzureOpenAI(
        azure_endpoint="<azure_endpoint>",
        api_key="<api_key>",
        api_version="<api_version>",
        http_client=httpx.AsyncClient(
            transport=AsyncCustomHTTPTransport(),
        ),
    )
    image = await client.images.generate(prompt="a cute baby seal")

    print(image.data[0].url)

asyncio.run(dall_e())

Perubahan nama

Catatan

Semua metode a* telah dihapus; klien asinkron harus digunakan sebagai gantinya.

OpenAI Python 0.28.1	OpenAI Python 1.x
`openai.api_base`	`openai.base_url`
`openai.proxy`	`openai.proxies`
`openai.InvalidRequestError`	`openai.BadRequestError`
`openai.Audio.transcribe()`	`client.audio.transcriptions.create()`
`openai.Audio.translate()`	`client.audio.translations.create()`
`openai.ChatCompletion.create()`	`client.chat.completions.create()`
`openai.Completion.create()`	`client.completions.create()`
`openai.Edit.create()`	`client.edits.create()`
`openai.Embedding.create()`	`client.embeddings.create()`
`openai.File.create()`	`client.files.create()`
`openai.File.list()`	`client.files.list()`
`openai.File.retrieve()`	`client.files.retrieve()`
`openai.File.download()`	`client.files.retrieve_content()`
`openai.FineTune.cancel()`	`client.fine_tunes.cancel()`
`openai.FineTune.list()`	`client.fine_tunes.list()`
`openai.FineTune.list_events()`	`client.fine_tunes.list_events()`
`openai.FineTune.stream_events()`	`client.fine_tunes.list_events(stream=True)`
`openai.FineTune.retrieve()`	`client.fine_tunes.retrieve()`
`openai.FineTune.delete()`	`client.fine_tunes.delete()`
`openai.FineTune.create()`	`client.fine_tunes.create()`
`openai.FineTuningJob.create()`	`client.fine_tuning.jobs.create()`
`openai.FineTuningJob.cancel()`	`client.fine_tuning.jobs.cancel()`
`openai.FineTuningJob.delete()`	`client.fine_tuning.jobs.create()`
`openai.FineTuningJob.retrieve()`	`client.fine_tuning.jobs.retrieve()`
`openai.FineTuningJob.list()`	`client.fine_tuning.jobs.list()`
`openai.FineTuningJob.list_events()`	`client.fine_tuning.jobs.list_events()`
`openai.Image.create()`	`client.images.generate()`
`openai.Image.create_variation()`	`client.images.create_variation()`
`openai.Image.create_edit()`	`client.images.edit()`
`openai.Model.list()`	`client.models.list()`
`openai.Model.delete()`	`client.models.delete()`
`openai.Model.retrieve()`	`client.models.retrieve()`
`openai.Moderation.create()`	`client.moderations.create()`
`openai.api_resources`	`openai.resources`

Dihapus

openai.api_key_path
openai.app_info
openai.debug
openai.log
openai.OpenAIError
openai.Audio.transcribe_raw()
openai.Audio.translate_raw()
openai.ErrorObject
openai.Customer
openai.api_version
openai.verify_ssl_certs
openai.api_type
openai.enable_telemetry
openai.ca_bundle_path
openai.requestssession (OpenAI sekarang menggunakan httpx)
openai.aiosession (OpenAI sekarang menggunakan httpx)
openai.Deployment (Sebelumnya digunakan untuk Azure OpenAI)
openai.Engine
openai.File.find_matching_files()

Bagikan melalui