Geração de vídeo com Sora 2 (versão prévia)

Pré-requisitos

• Uma assinatura Azure. Crie um gratuitamente.
• Python versão 3.8 ou posterior. É recomendável usar Python 3.10 ou posterior, mas ter pelo menos Python 3.8 é necessário. Se você não tiver uma versão adequada do Python instalada, poderá seguir as instruções no tutorial VS Code Python Tutorial para a maneira mais fácil de instalar Python em seu sistema operacional.
• Um recurso Azure OpenAI criado em uma das regiões com suporte. Para obter mais informações sobre a disponibilidade da região, consulte a documentação de modelos e versões.
• Em seguida, você precisa implantar um modelo sora (Sora 2) com seu recurso Azure OpenAI. Para obter mais informações, consulte Criar um recurso e implantar um modelo com Azure OpenAI.

Microsoft Entra ID pré-requisitos

Para a autenticação sem chave recomendada com Microsoft Entra ID, você precisa:

• Instale o CLI do Azure usado para autenticação sem chave com Microsoft Entra ID.
• Atribua a Cognitive Services User função à sua conta de usuário. Você pode atribuir funções no portal do Azure em Controle de Acesso (IAM)>Adicionar atribuição de função.

Configuração

1. Crie uma nova pasta video-generation-quickstart e vá para a pasta de início rápido com o seguinte comando:

   mkdir video-generation-quickstart && cd video-generation-quickstart
   

2. Crie um ambiente virtual. Se você já tiver Python 3.10 ou superior instalado, poderá criar um ambiente virtual usando os seguintes comandos:

   Windows

   py -3 -m venv .venv
   .venv\scripts\activate
   

   Linux

   python3 -m venv .venv
   source .venv/bin/activate
   

   Macos

   python3 -m venv .venv
   source .venv/bin/activate
   

   Ativar o ambiente de Python significa que, ao executar python ou pip da linha de comando, use o interpretador de Python contido na pasta .venv do aplicativo. Você pode usar o deactivate comando para sair do ambiente virtual do Python e, posteriormente, reativar quando necessário.

   Dica

   Recomendamos que você crie e ative um novo ambiente de Python a ser usado para instalar os pacotes necessários para este tutorial. Não instale pacotes na instalação global do Python. Você sempre deve usar um ambiente virtual ou conda ao instalar pacotes python, caso contrário, poderá interromper a instalação global de Python.

3. Instale os pacotes necessários.

   Microsoft Entra ID

   pip install requests azure-identity
   

   O pacote azure-identity fornece DefaultAzureCredential autenticação segura e sem chave.

   Chave de API

   pip install requests
   

   A biblioteca de solicitações manipula chamadas HTTP para a API REST.

Recuperar informações do recurso

Você precisa recuperar as seguintes informações para autenticar seu aplicativo com seu Azure recurso OpenAI:

Gerar vídeo com Sora 2

Você pode gerar um vídeo com o modelo Sora 2 criando um trabalho de geração de vídeo, verificando seu status e obtendo o vídeo gerado. O código a seguir mostra como fazer isso por meio da API REST usando Python.

Escolha seu tipo de entrada

O Sora 2 dá suporte a três modos de entrada:

Configurar a autenticação

1. Crie o sora-quickstart.py arquivo e adicione o seguinte código para autenticar seu recurso:

   Microsoft Entra ID

   import json
   import requests
   import time
   import os
   from azure.identity import DefaultAzureCredential
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ.get('AZURE_OPENAI_ENDPOINT')
   deployment_name = os.environ.get('AZURE_OPENAI_DEPLOYMENT_NAME')
   if not endpoint or not deployment_name:
       raise ValueError("Set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_DEPLOYMENT_NAME.")
   
   # Keyless authentication
   credential = DefaultAzureCredential()
   token = credential.get_token("https://ai.azure.com/.default")
   
   # Video generation uses 'preview' as the API version during the preview period
   api_version = 'preview'
   headers= { "Authorization": f"Bearer {token.token}", "Content-Type": "application/json" }
   

   Chave de API

   import json
   import requests
   import time
   import os
   
   # Set environment variables or edit the corresponding values here.
   endpoint = os.environ.get('AZURE_OPENAI_ENDPOINT')
   deployment_name = os.environ.get('AZURE_OPENAI_DEPLOYMENT_NAME')
   api_key = os.environ.get('AZURE_OPENAI_API_KEY')
   if not endpoint or not deployment_name or not api_key:
       raise ValueError(
           "Set AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_DEPLOYMENT_NAME, and AZURE_OPENAI_API_KEY."
       )
   
   # Video generation uses 'preview' as the API version during the preview period
   api_version = 'preview'
   headers= { "api-key": api_key, "Content-Type": "application/json" }
   

Criar a tarefa de geração de vídeo

1. Adicione o código para criar e monitorar o trabalho de geração de vídeo. Escolha o tipo de entrada que corresponde ao seu caso de uso.

   Prompt de texto

   # 1. Create a video generation job
   create_url = f"{endpoint}/openai/v1/video/generations/jobs?api-version={api_version}"
   body = {
       "prompt": "A cat playing piano in a jazz bar.",
       "width": 480,
       "height": 480,
       "n_seconds": 5,
       "model": deployment_name
   }
   response = requests.post(create_url, headers=headers, json=body)
   response.raise_for_status()
   print("Full response JSON:", response.json())
   job_id = response.json()["id"]
   print(f"Job created: {job_id}")
   
   # 2. Poll for job status
   status_url = f"{endpoint}/openai/v1/video/generations/jobs/{job_id}?api-version={api_version}"
   status=None
   while status not in ("succeeded", "failed", "cancelled"):
       time.sleep(5)  # Wait before polling again
       status_response = requests.get(status_url, headers=headers).json()
       status = status_response.get("status")
       print(f"Job status: {status}")
   
   # 3. Retrieve generated video 
   if status == "succeeded":
       generations = status_response.get("generations", [])
       if generations:
           print(f"✅ Video generation succeeded.")
           generation_id = generations[0].get("id")
           video_url = f"{endpoint}/openai/v1/video/generations/{generation_id}/content/video?api-version={api_version}"
           video_response = requests.get(video_url, headers=headers)
           if video_response.ok:
               output_filename = "output.mp4"
               with open(output_filename, "wb") as file:
                   file.write(video_response.content)
                   print(f'Generated video saved as "{output_filename}"')
       else:
           raise Exception("No generations found in job result.")
   else:
       raise Exception(f"Job didn't succeed. Status: {status}")
   

   Prompt de imagem

   Substitua o campo "file_name" no "inpaint_items" pelo nome do arquivo de imagem de entrada. Substitua também a construção da files matriz, que associa o caminho ao arquivo real com o nome de arquivo que a API usa.

   Use os "crop_bounds" dados (distâncias de corte de imagem, de cada direção, como uma fração do total de dimensões de imagem) para especificar qual parte da imagem deve ser usada na geração de vídeo.

   Opcionalmente, você pode definir o valor de "frame_index" para o quadro no vídeo gerado onde sua imagem deve aparecer (o padrão é 0, que representa o início do vídeo).

   O "n_variants" parâmetro especifica quantas variações de vídeo diferentes gerar do mesmo prompt (1 a 4). Cada variante fornece uma interpretação exclusiva da sua entrada.

   # 1. Create a video generation job with image inpainting (multipart upload)
   create_url = f"{endpoint}/openai/v1/video/generations/jobs?api-version={api_version}"
   
   # Flatten the body for multipart/form-data
   data = {
       "prompt": "A serene forest scene transitioning into autumn",
       "height": str(1080),
       "width": str(1920),
       "n_seconds": str(10),
       "n_variants": str(1),
       "model": deployment_name,
       # inpaint_items must be JSON string
       "inpaint_items": json.dumps([
           {
               "frame_index": 0,
               "type": "image",
               "file_name": "dog_swimming.jpg",
               "crop_bounds": {
                   "left_fraction": 0.1,
                   "top_fraction": 0.1,
                   "right_fraction": 0.9,
                   "bottom_fraction": 0.9
               }
           }
       ])
   }
   
   # Replace with your own image file path
   with open("dog_swimming.jpg", "rb") as image_file:
       files = [
           ("files", ("dog_swimming.jpg", image_file, "image/jpeg"))
       ]
       multipart_headers = {k: v for k, v in headers.items() if k.lower() != "content-type"}
       response = requests.post(
           create_url,
           headers=multipart_headers,
           data=data,
           files=files
       )
   
   if not response.ok:
       print("Error response:", response.status_code, response.text)
       response.raise_for_status()
   print("Full response JSON:", response.json())
   job_id = response.json()["id"]
   print(f"Job created: {job_id}")
   
   # 2. Poll for job status
   status_url = f"{endpoint}/openai/v1/video/generations/jobs/{job_id}?api-version={api_version}"
   status = None
   while status not in ("succeeded", "failed", "cancelled"):
       time.sleep(5)
       status_response = requests.get(status_url, headers=headers).json()
       status = status_response.get("status")
       print(f"Job status: {status}")
   
   # 3. Retrieve generated video
   if status == "succeeded":
       generations = status_response.get("generations", [])
       if generations:
           generation_id = generations[0].get("id")
           video_url = f"{endpoint}/openai/v1/video/generations/{generation_id}/content/video?api-version={api_version}"
           video_response = requests.get(video_url, headers=headers)
           if video_response.ok:
               output_filename = "output.mp4"
               with open(output_filename, "wb") as file:
                   file.write(video_response.content)
                   print(f'✅ Generated video saved as "{output_filename}"')
       else:
           raise Exception("No generations found in job result.")
   else:
       raise Exception(f"Job didn't succeed. Status: {status}")
   

   Prompt de vídeo

   Substitua o campo "file_name" em "inpaint_items" pelo nome do arquivo de vídeo de entrada. Substitua também a construção da files matriz, que associa o caminho ao arquivo real com o nome de arquivo que a API usa.

   Use os "crop_bounds" dados (distâncias de corte de imagem, de cada direção, como uma fração das dimensões totais do quadro) para especificar qual parte do quadro de vídeo deve ser utilizada na geração de vídeo.

   Opcionalmente, você pode definir o quadro "frame_index" no vídeo gerado onde o vídeo de entrada deve começar (o padrão é 0, o início).

   # 1. Create a video generation job with video inpainting (multipart upload)
   create_url = f"{endpoint}/openai/v1/video/generations/jobs?api-version={api_version}"
   
   # Flatten the body for multipart/form-data
   data = {
       "prompt": "A serene forest scene transitioning into autumn",
       "height": str(1080),
       "width": str(1920),
       "n_seconds": str(10),
       "n_variants": str(1),
       "model": deployment_name,
       # inpaint_items must be JSON string
       "inpaint_items": json.dumps([
           {
               "frame_index": 0,
               "type": "video",
               "file_name": "dog_swimming.mp4",
               "crop_bounds": {
                   "left_fraction": 0.1,
                   "top_fraction": 0.1,
                   "right_fraction": 0.9,
                   "bottom_fraction": 0.9
               }
           }
       ])
   }
   
   # Replace with your own video file path
   with open("dog_swimming.mp4", "rb") as video_file:
       files = [
           ("files", ("dog_swimming.mp4", video_file, "video/mp4"))
       ]
       multipart_headers = {k: v for k, v in headers.items() if k.lower() != "content-type"}
       response = requests.post(
           create_url,
           headers=multipart_headers,
           data=data,
           files=files
       )
   
   if not response.ok:
       print("Error response:", response.status_code, response.text)
       response.raise_for_status()
   print("Full response JSON:", response.json())
   job_id = response.json()["id"]
   print(f"Job created: {job_id}")
   
   # 2. Poll for job status
   status_url = f"{endpoint}/openai/v1/video/generations/jobs/{job_id}?api-version={api_version}"
   status = None
   while status not in ("succeeded", "failed", "cancelled"):
       time.sleep(5)
       status_response = requests.get(status_url, headers=headers).json()
       status = status_response.get("status")
       print(f"Job status: {status}")
   
   # 3. Retrieve generated video
   if status == "succeeded":
       generations = status_response.get("generations", [])
       if generations:
           generation_id = generations[0].get("id")
           video_url = f"{endpoint}/openai/v1/video/generations/{generation_id}/content/video?api-version={api_version}"
           video_response = requests.get(video_url, headers=headers)
           if video_response.ok:
               output_filename = "output.mp4"
               with open(output_filename, "wb") as file:
                   file.write(video_response.content)
                   print(f'✅ Generated video saved as "{output_filename}"')
       else:
           raise Exception("No generations found in job result.")
   else:
       raise Exception(f"Job didn't succeed. Status: {status}")
   

2. Execute o arquivo Python.

   python sora-quickstart.py
   

   A geração de vídeo normalmente leva de 1 a 5 minutos , dependendo da resolução e da duração. Você deverá ver atualizações de status em seu terminal à medida que o trabalho progride por queued, , preprocessing, runninge processingpor fim succeeded.

Saída

A saída mostrará o JSON completo da resposta à solicitação de criação do trabalho de geração de vídeo, incluindo a ID e o status do trabalho.

{
    "object": "video.generation.job",
    "id": "task_01jwcet0eje35tc5jy54yjax5q",
    "status": "queued",
    "created_at": 1748469875,
    "finished_at": null,
    "expires_at": null,
    "generations": [],
    "prompt": "A cat playing piano in a jazz bar.",
    "model": "<your-deployment-name>",
    "n_variants": 1,
    "n_seconds": 5,
    "height": 480,
    "width": 480,
    "failure_reason": null
}

O vídeo gerado será salvo como output.mp4 no diretório atual.

Job created: task_01jwcet0eje35tc5jy54yjax5q
Job status: preprocessing
Job status: running
Job status: processing
Job status: succeeded
✅ Video generation succeeded.
Generated video saved as "output.mp4"

Solucionando problemas

Se você encontrar problemas, verifique os seguintes problemas e soluções comuns:

# Test endpoint connectivity
test_url = f"{endpoint}/openai/deployments?api-version=2024-02-01"
response = requests.get(test_url, headers=headers)
print(response.status_code, response.text)

Pré-requisitos

• Uma assinatura Azure. Crie um gratuitamente.
• Um recurso OpenAI Azure criado em uma região suportada. Consulte a disponibilidade da região. Para obter mais informações, consulte Criar um recurso e implantar um modelo com Azure OpenAI.

Ir para o portal do Microsoft Foundry

Navegue até o portal Foundry e entre com as credenciais associadas ao recurso Azure OpenAI. Durante ou após o fluxo de trabalho de entrada, selecione o diretório apropriado, a assinatura do Azure e o recurso Azure OpenAI.

Na página inicial do Foundry, crie ou selecione um novo projeto. Navegue até a página Modelos + pontos de extremidade na navegação à esquerda. Selecione Implantar modelo e escolha o modelo de geração de vídeo sora 2 na lista. Conclua o processo de implantação.

Na página do modelo, selecione Abrir no playground.

Experimentar a geração de vídeo

Comece a explorar a geração de vídeo do Sora 2 com uma abordagem sem código por meio do playground de vídeo. Insira o prompt na caixa de texto e selecione Gerar. Normalmente, a geração de vídeo leva de 1 a 5 minutos , dependendo das configurações. Quando o vídeo gerado por IA estiver pronto, ele será exibido na página.

No playground Video, você também pode exibir exemplos de código Python e cURL, que são pré-preenchidos de acordo com suas configurações. Selecione o botão de código na parte superior do painel de reprodução de vídeo. Você pode usar esse código para escrever um aplicativo que conclua a mesma tarefa.