Migrazione alla libreria API OpenAI Python 1.x

OpenAI ha rilasciato una nuova versione della libreria API OpenAI Python. Questa è una guida supplementare alla guida alla migrazione di OpenAI e consente di velocizzare le modifiche specifiche di Azure OpenAI.

Aggiornamenti

• Si tratta di una nuova versione della libreria API OpenAI Python.
• A partire dal 6 novembre 2023, pip install openai e pip install openai --upgrade installeranno version 1.x della libreria OpenAI Python.
• L'aggiornamento da version 0.28.1 a version 1.x è una modifica che causa un'interruzione, e sarà necessario testare e aggiornare il codice.
• Se si verifica un errore, riprovare automaticamente con backoff
• Tipi appropriati (per mypy/pyright/editor)
• È ora possibile creare un'istanza di un client, anziché usare le impostazioni globali predefinite.
• Passare alla creazione di un’istanza esplicita del client
• Modifiche al nome

Problemi noti

• DALL-E3 è interamente supportato con la versione 1.x più recente. DALL-E2 può essere usato con 1.x apportando le seguenti modifiche al codice.
• embeddings_utils.py, che era stato usato per fornire funzionalità come la somiglianza coseno per la ricerca di testo semantico non fa più parte della libreria API OpenAI Python.
• È anche consigliabile controllare i problemi di GitHub attivi per la libreria OpenAI Python.

Eseguire un prima della migrazione

Importante

La migrazione automatica del codice utilizzando openai migrate non è supportata con Azure OpenAI.

Poiché si tratta di una nuova versione della libreria con modifiche che causano un’interruzione, prima di eseguire la migrazione di qualsiasi applicazione di produzione, è necessario testare il codice in modo esteso rispetto alla nuova versione, in modo che si basi sulla versione 1.x. Inoltre è consigliabile esaminare il codice e i processi interni per assicurarsi di seguire le procedure consigliate, e aggiungere il codice di produzione solo alle versioni completamente testate.

Per semplificare il processo di migrazione, nella documentazione di Python sono in aggiornamento gli esempi di codice esistenti, per un'esperienza a schede:

OpenAI Python 1.x

pip install openai --upgrade

OpenAI Python 0.28.1

pip install openai==0.28.1

In questo modo viene fornito il contesto per le modifiche apportate e consente di testare la nuova libreria in parallelo, continuando a fornire il supporto per la versione 0.28.1. Se si esegue l'aggiornamento a 1.x e ci si rende conto di dover ripristinare temporaneamente la versione precedente, è sempre possibile pip uninstall openai, e quindi reinstallare la destinazione 0.28.1 con pip install openai==0.28.1.

Completamenti della chat

OpenAI Python 1.x

È necessario impostare la variabile model sul nome della distribuzione scelto quando sono stati distribuiti i modelli GPT-3.5-Turbo o GPT-4. Se si immette il nome del modello, viene generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante.

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)

Altri esempi sono disponibili nell'articolo approfondito sul Completamento chat.

OpenAI Python 0.28.1

È necessario impostare la variabile engine sul nome della distribuzione scelto quando sono stati distribuiti i modelli GPT-3.5-Turbo o GPT-4. Se si immette il nome del modello, verrà generato un errore, a meno che non sia stato scelto un nome di distribuzione identico a quello del modello sottostante.

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

Completamenti

OpenAI Python 1.x

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)

OpenAI Python 0.28.1

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)

Incorporamenti

OpenAI Python 1.x

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

Per altri esempi, tra cui come gestire la ricerca di testo semantico senza embeddings_utils.py, vedere l'esercitazione sugli incorporamenti.

OpenAI Python 0.28.1

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)

Async

OpenAI non supporta la chiamata di metodi asincroni nel client a livello di modulo, quindi è consigliabile creare un'istanza di un client asincrono.

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

Autenticazione

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

Usare i dati

Per tutti i passaggi di configurazione necessari per eseguire questi esempi di codice, vedere l'argomento di avvio rapido sull'uso dei dati.

OpenAI Python 1.x

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

OpenAI Python 0.28.1

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)

Correzione DALL-E

DALLE-Fix

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)

DALLE-Fix asincrona

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

Modifiche del nome

Nota

Tutti i metodi * sono stati rimossi; deve essere usato il client asincrono.

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

Rimosse

• 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 ora usa httpx)
• openai.aiosession (OpenAI ora usa httpx)
• openai.Deployment (Usato in precedenza per Azure OpenAI)
• openai.Engine
• openai.File.find_matching_files()