Migrera till OpenAI Python API-biblioteket 1.x

Artikel
10/16/2024

OpenAI släppte en ny version av OpenAI Python API-biblioteket. Den här guiden är ett komplement till OpenAI:s migreringsguide och hjälper dig att komma igång med de ändringar som är specifika för Azure OpenAI.

Uppdateringar

Det här är en ny version av OpenAI Python API-biblioteket.
Från och med den 6 november 2023 pip install openai installeras pip install openai --upgrade version 1.x OpenAI Python-biblioteket.
Att uppgradera från version 0.28.1 till version 1.x är en icke-bakåtkompatibel ändring. Du måste testa och uppdatera koden.
Försök igen med backoff om det uppstår ett fel
Rätt typer (för mypy/pyright/editors)
Nu kan du instansiera en klient i stället för att använda ett globalt standardvärde.
Växla till explicit klient-instansiering
Namnändringar

Kända problem

DALL-E3 stöds fullt ut med den senaste versionen av 1.x.DALL-E2 kan användas med 1.x genom att göra följande ändringar i koden.
embeddings_utils.py som användes för att tillhandahålla funktioner som cosinualitet för semantisk textsökning är inte längre en del av OpenAI Python API-biblioteket.
Du bör också kontrollera aktiva GitHub-problem för OpenAI Python-biblioteket.

Testa innan du migrerar

Viktigt!

Automatisk migrering av din kod med hjälp av openai migrate stöds inte med Azure OpenAI.

Eftersom det här är en ny version av biblioteket med icke-bakåtkompatibla ändringar bör du testa koden i stor utsträckning mot den nya versionen innan du migrerar några produktionsprogram för att förlita dig på version 1.x. Du bör också granska koden och de interna processerna för att se till att du följer metodtipsen och fäster produktionskoden på endast versioner som du har testat fullt ut.

För att göra migreringsprocessen enklare uppdaterar vi befintliga kodexempel i våra dokument för Python till en tabbed-upplevelse:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai --upgrade

pip install openai==0.28.1

Detta ger kontext för vad som har ändrats och gör att du kan testa det nya biblioteket parallellt samtidigt som du fortsätter att ge stöd för version 0.28.1. Om du uppgraderar till 1.x och inser att du tillfälligt behöver återgå till den tidigare versionen kan du alltid pip uninstall openai och sedan installera om riktad till 0.28.1 med pip install openai==0.28.1.

Du måste ange variabeln model till det distributionsnamn du valde när du distribuerade modellerna GPT-3.5-Turbo eller GPT-4. Om du anger modellnamnet resulterar det i ett fel om du inte väljer ett distributionsnamn som är identiskt med det underliggande modellnamnet.

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)

Ytterligare exempel finns i vår djupgående artikel om chattens slutförande.

Du måste ange variabeln engine till det distributionsnamn du valde när du distribuerade modellerna GPT-3.5-Turbo eller GPT-4. Om du anger modellnamnet uppstår ett fel om du inte väljer ett distributionsnamn som är identiskt med det underliggande modellnamnet.

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'])

Kompletteringar

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)

Inbäddningar

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))

Ytterligare exempel som hur du hanterar semantisk textsökning utan embeddings_utils.py finns i vår självstudie om inbäddningar.

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)

Asynkrona

OpenAI stöder inte anrop av asynkrona metoder i klienten på modulnivå, utan du bör i stället instansiera en asynkron klient.

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())

Autentisering

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))

Använda dina data

De fullständiga konfigurationssteg som krävs för att dessa kodexempel ska fungera finns i snabbstarten använda dina data.

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)

DALL-E-korrigering

DALLE-Fix
DALLE-Fix Async

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())

Namnändringar

Kommentar

Alla a* metoder har tagits bort. async-klienten måste användas i stället.

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`

Borttagna

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 använder httpxnu )
openai.aiosession (OpenAI använder httpxnu )
openai.Deployment (Används tidigare för Azure OpenAI)
openai.Engine
openai.File.find_matching_files()

Dela via