OpenAI Python API kitaplığı 1.x'e geçiş

Makale
10/16/2024

OpenAI, OpenAI Python API kitaplığının yeni bir sürümünü yayımladı. Bu kılavuz, OpenAI'nin geçiş kılavuzuna ek niteliğindedir ve Azure OpenAI'ye özgü değişiklikleri hızlandırmanıza yardımcı olur.

Güncelleştirmeler

Bu, OpenAI Python API kitaplığının yeni bir sürümüdür.
6 Kasım 2023 pip install openai pip install openai --upgrade tarihinden itibaren OpenAI Python kitaplığını yükleyecektir version 1.x .
sürümüne version 0.28.1 version 1.x yükseltme işlemi hataya neden olan bir değişikliktir. Kodunuzu test etmeniz ve güncelleştirmeniz gerekir.
Hata varsa geri alma ile otomatik yeniden deneme
Uygun türler (mypy/pyright/editors için)
Artık genel bir varsayılan kullanmak yerine istemci örneği oluşturabilirsiniz.
Açık istemci örneği oluşturma işlemine geçme
Ad değişiklikleri

Bilinen sorunlar

DALL-E3 en son 1.x sürümüyle tam olarak desteklenir.DALL-E2 kodunuzda aşağıdaki değişiklikler yapılarak 1.x ile kullanılabilir.
embeddings_utils.pyanlamsal metin araması için kosinüs benzerliği gibi işlevler sağlamak için kullanılan bu özellik artık OpenAI Python API kitaplığının bir parçası değildir.
OpenAI Python kitaplığı için etkin GitHub Sorunlarını da denetlemeniz gerekir.

Geçirmeden önce test edin

Önemli

kullanarak openai migrate kodunuzun otomatik geçişi Azure OpenAI ile desteklenmez.

Bu, kitaplığın hataya neden olan yeni bir sürümü olduğundan, herhangi bir üretim uygulamasını sürüm 1.x'e güvenmek üzere geçirmeden önce kodunuzu yeni sürüme karşı kapsamlı bir şekilde test etmelisiniz. Ayrıca en iyi yöntemleri izlediğinizden ve üretim kodunuzu yalnızca tam olarak test ettiğiniz sürümlere sabitlediğinizden emin olmak için kodunuzu ve iç süreçlerinizi gözden geçirmeniz gerekir.

Geçiş işlemini kolaylaştırmak için Python belgelerimizdeki mevcut kod örneklerini sekmeli bir deneyime güncelleştiriyoruz:

OpenAI Python 1.x
OpenAI Python 0.28.1

pip install openai --upgrade

pip install openai==0.28.1

Bu, değişenler için bağlam sağlar ve sürümü 0.28.1için destek sağlamaya devam ederken yeni kitaplığı paralel olarak test etmenizi sağlar. sürümüne 1.x yükseltip geçici olarak önceki sürüme geri dönmeniz gerektiğini fark ederseniz, ile pip install openai==0.28.1hedeflenen 0.28.1 öğesini istediğiniz zaman pip uninstall openai yeniden yükleyebilirsiniz.

DEĞIŞKENI GPT-3.5-Turbo veya GPT-4 modellerini dağıtırken seçtiğiniz dağıtım adına ayarlamanız model gerekir. Temel alınan model adıyla aynı olan bir dağıtım adı seçmediğiniz sürece model adının girilmesi hatayla sonuçlanır.

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)

Ayrıntılı Sohbet Tamamlama makalemizde ek örnekler bulabilirsiniz.

DEĞIŞKENI GPT-3.5-Turbo veya GPT-4 modellerini dağıtırken seçtiğiniz dağıtım adına ayarlamanız engine gerekir. Temel alınan model adıyla aynı olan bir dağıtım adı seçmediğiniz sürece model adının girilmesi hataya neden olur.

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

Tamamlama

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)

Eklemeler

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

Anlamsal metin aramasını olmadan embeddings_utils.py işleme dahil olmak üzere ek örnekler eklemeler öğreticimizde bulunabilir.

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)

Zaman Uyumsuz

OpenAI, modül düzeyi istemcide zaman uyumsuz yöntemleri çağırmayı desteklemez, bunun yerine zaman uyumsuz bir istemci örneği oluşturmanız gerekir.

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

Kimlik Doğrulaması

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

Verilerinizi kullanma

Bu kod örneklerinin çalışması için gereken tüm yapılandırma adımları için verilerinizi kullanma hızlı başlangıcına bakın.

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 düzeltmesi

DALLE-Düzeltme
DALLE-Düzeltme Zaman Uyumsuz

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

Ad değişiklikleri

Not

Tüm a* yöntemleri kaldırıldı; bunun yerine zaman uyumsuz istemci kullanılmalıdır.

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`

Kaldırıldı

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 artık kullanıyor httpx)
openai.aiosession (OpenAI artık kullanıyor httpx)
openai.Deployment (Daha önce Azure OpenAI için kullanılır)
openai.Engine
openai.File.find_matching_files()

Aracılığıyla paylaş