Generate high-definition long videos using EasyAnimate - Platform For AI: Central de Documentação do Alibaba Cloud

Soluções

Solução	Vantagens e casos de uso	Faturamento
Solution 1: Generate videos using DSW	Oferece um Ambiente de Desenvolvimento Integrado (IDE) baseado em cloud, com tutoriais e código integrados. Ideal para usuários que desejam explorar modelos em profundidade ou realizar desenvolvimento personalizado.	Este tutorial cria uma instância DSW que utiliza recursos públicos e é faturada no modelo pagamento conforme o uso. Para mais informações, consulte DSW Billing.
Solution 2: Generate videos using Model Gallery	Elimina a necessidade de configuração de ambiente. Permite implantar ou ajustar modelos com ações de um clique e chamá-los via WebUI ou API. Recomendado para validação rápida ou integração de aplicações.	Este tutorial cria um service EAS para implantação do modelo e um job DLC para ajuste fino do modelo. Ambos utilizam recursos públicos e são faturados no modelo pagamento conforme o uso. Para mais informações, consulte DLC Billing e EAS Billing.

Solução 1: Gerar vídeos usando o DSW

Etapa 1: Criar uma instância DSW

Acesse o PAI console e selecione uma região. No painel de navegação à esquerda, clique em Workspaces e localize e clique no nome do workspace desejado.
No painel de navegação à esquerda, clique em Model Training > Interactive Modeling (DSW) para acessar a página do DSW.

Clique em Create instance e configure os seguintes parâmetros principais. Mantenha os demais parâmetros com os valores padrão.

Parâmetro	Descrição
Instance Name	Exemplo: AIGC_test_01.
Resource Type	Selecione Public Resources.
Instance Type	Em GPU Specs, selecione `ecs.gn7i-c8g1.2xlarge` ou outro tipo de instância A10 ou GU100.
Image	Selecione Alibaba Cloud Image, pesquise e selecione `easyanimate:1.1.5-pytorch2.2.0-gpu-py310-cu118-ubuntu22.04`.

Clique em OK para criar a instância e aguarde até que o status da instância mude para Running.

Etapa 2: Baixar o tutorial e o modelo do EasyAnimate

Na coluna Actions da instância DSW desejada, clique em Open para entrar no ambiente de desenvolvimento.
Na aba Notebook, abra a página Launcher e clique em DSW Gallery.
No DSW Gallery, pesquise por AI Video Generation with EasyAnimate (V5). Clique em Open in DSW para baixar os recursos necessários para este tutorial na instância DSW.

O exemplo de geração de vídeo com IA para EasyAnimate está disponível em várias versões. Este tutorial utiliza a V5 como exemplo.
Baixe e instale o código e o modelo do EasyAnimate.

No arquivo do tutorial do EasyAnimate, clique em para executar sequencialmente as células intituladas Function Definition, Download Code e Download Model.

Etapa 3: Iniciar a WebUI e gerar um vídeo

Clique em para executar a célula intitulada Launch UI, que inicia o service da WebUI.

Clique no link gerado para abrir a WebUI.

!python app.py
/mnt/workspace/demos/easyanimate_v5_1/EasyAnimate/easyanimate/ui/ui.py:892: GradioUnusedKwargWarning: You have unused kwarg parameters in Video, please remove them: {'sources': 'upload'}
    control_video = gr.Video()
/usr/local/lib/python3.10/dist-packages/gradio/utils.py:842: UserWarning: Expected 2 arguments for function <function ui.<locals>.upload_generation_method at 0x7fe5b79b79a0>, received 1.
    warnings.warn()
/usr/local/lib/python3.10/dist-packages/gradio/utils.py:846: UserWarning: Expected at least 2 arguments for function ui.<locals>.upload_generation_method at 0x7fe5b79b79a0>, received 1.
    warnings.warn()
Running on local URL:  http://0.0.0.0:7860
IMPORTANT: You are using gradio version 3.41.2, however version 4.44.1 is available, please upgrade.
--------
To create a public link, set `share=True` in `launch()`.

Na WebUI, selecione o caminho do modelo pré-treinado e configure outros parâmetros conforme necessário.

Na lista suspensa Pretrained Model Path, selecione /mnt/workspace/demos/easyanimate_v5/EasyAnimate/models/Diffusion_Transformer/EasyAnimateV5-12b-zh-InP/.
Clique em Generate. Após cerca de 5 minutos, visualize ou baixe o vídeo gerado à direita.

Solução 2: Gerar vídeos usando o Model Gallery

Etapa 1: Implantar o modelo pré-treinado

Acesse o PAI console e selecione uma região. No painel de navegação à esquerda, clique em Workspaces e localize e clique no nome do workspace desejado.
No painel de navegação à esquerda, clique em Quick Start > Model Gallery. Pesquise por EasyAnimate HD Long Video Generation Model, clique em Deploy, utilize as configurações padrão e confirme a implantação. Quando o status do service mudar para Running, o modelo estará implantado com sucesso.

Etapa 2: Gerar vídeos usando a WebUI ou API

Após implantar o modelo, gere vídeos chamando o service via WebUI ou API.

Para visualizar detalhes da tarefa de implantação posteriormente, no painel de navegação à esquerda, clique em Model Gallery > Job Management > Deployment Jobs e, em seguida, clique no Service name .

WebUI

Na página Service details, clique em View Web App.
Na WebUI, selecione o caminho do modelo pré-treinado e configure outros parâmetros conforme necessário.

Por exemplo, na lista suspensa Pretrained Model Path, selecione /mnt/models/Diffusion_Transformer/EasyAnimateV3-XL-2-InP-512x512/.
Clique em Generate. Após cerca de 5 minutos, visualize ou baixe o vídeo gerado à direita.

Quando a geração for concluída, a área Generation Info no canto inferior direito exibirá Success, indicando que o vídeo foi gerado com sucesso.

API

Na página Service details, na seção Resource Details, clique em View Call Information para obter o endpoint e o token do service.

Chame o service para gerar um vídeo. O código Python a seguir fornece um exemplo de solicitação:

import os
import requests
import json
import base64
from typing import Dict, Any

class EasyAnimateClient:
    """
    API client for the EasyAnimate EAS service.
    """
    def __init__(self, service_url: str, token: str):
        if not service_url or not token:
            raise ValueError("The `service_url` and `token` parameters cannot be empty.")
        self.base_url = service_url.rstrip('/')
        self.headers = {
            'Content-Type': 'application/json',
            'Authorization': token
        }

    def update_model(self, model_path: str, edition: str = "v3", timeout: int = 300) -> Dict[str, Any]:
        """
        Updates and loads the specified model version and path.

        Args:
            model_path: The path to the model within the service, such as "/mnt/models/Diffusion_Transformer/EasyAnimateV3-XL-2-InP-512x512".
            edition: The model version. Defaults to "v3".
            timeout: The request timeout in seconds. A longer timeout is recommended as model loading can be slow.
        """
        # 1. Update the version.
        requests.post(
            f"{self.base_url}/easyanimate/update_edition",
            headers=self.headers,
            json={"edition": edition},
            timeout=timeout
        ).raise_for_status()

        # 2. Update the model path and wait for it to load.
        print(f"Sending request to load model: {model_path}")
        response = requests.post(
            f"{self.base_url}/easyanimate/update_diffusion_transformer",
            headers=self.headers,
            json={"diffusion_transformer_path": model_path},
            timeout=15000
        )
        response.raise_for_status()
        return response.json()

    def generate_video(self, prompt_textbox: str, **kwargs) -> bytes:
        """
        Generates a video based on a prompt.

        Args:
            prompt_textbox: The positive prompt in English.
            **kwargs: Other optional parameters. See the parameter description table below.

        Returns:
            The binary data of the video in MP4 format.
        """
        payload = {
            "prompt_textbox": prompt_textbox,
            "negative_prompt_textbox": kwargs.get("negative_prompt",
                                                  "The video is not of a high quality, it has a low resolution..."),
            "width_slider": kwargs.get("width_slider", 672),
            "height_slider": kwargs.get("height_slider", 384),
            "length_slider": kwargs.get("length_slider", 144),
            "sample_step_slider": kwargs.get("sample_step_slider", 30),
            "cfg_scale_slider": kwargs.get("cfg_scale_slider", 6.0),
            "seed_textbox": kwargs.get("seed_textbox", 43),
            "sampler_dropdown": kwargs.get("sampler_dropdown", "Euler"),
            "generation_method": "Video Generation",
            "is_image": False,
            "lora_alpha_slider": 0.55,
            "lora_model_path": "none",
            "base_model_path": "none",
            "motion_module_path": "none"
        }

        response = requests.post(
            f"{self.base_url}/easyanimate/infer_forward",
            headers=self.headers,
            json=payload,
            timeout=1500
        )
        response.raise_for_status()

        result = response.json()
        if "base64_encoding" not in result:
            raise ValueError(f"Invalid API response format: {result}")

        return base64.b64decode(result["base64_encoding"])

# --- Example Usage ---
if __name__ == "__main__":
    try:
        # 1. Configure the service information. Replace the placeholders with your actual service endpoint and token. We recommend setting them as environment variables.
        EAS_URL = "<eas-service-url>"
        EAS_TOKEN = "<eas-service-token>"

        # 2. Create the client.
        client = EasyAnimateClient(service_url=EAS_URL, token=EAS_TOKEN)

        # 3. Load the model. By default, no model is loaded after service deployment. You must call `update_model` at least once to specify the model to use before sending a generation request. To switch models later, call this method again.
        client.update_model(model_path="/mnt/models/Diffusion_Transformer/EasyAnimateV3-XL-2-InP-512x512")

        # 4. Generate the video.
        video_bytes = client.generate_video(
            prompt_textbox="A beautiful cat playing in a sunny garden, high quality, detailed",
            width_slider=672,
            height_slider=384,
            length_slider=72,
            sample_step_slider=20
        )

        # 5. Save the video file.
        with open("api_generated_video.mp4", "wb") as f:
            f.write(video_bytes)
        print("Video saved successfully as api_generated_video.mp4")

    except requests.RequestException as e:
        print(f"Network request error: {e}")
    except (ValueError, KeyError) as e:
        print(f"Data or parameter error: {e}")
    except Exception as e:
        print(f"An unknown error occurred: {e}")

Descrição dos parâmetros da API

Parâmetro	Descrição	Tipo	Padrão
prompt_textbox	Um prompt positivo que descreve o conteúdo desejado do vídeo.	string	Obrigatório. Sem valor padrão.
negative_prompt_textbox	Um prompt negativo que especifica o que excluir do vídeo.	string	"The video is not of a high quality, it has a low resolution, and the audio quality is not clear. Strange motion trajectory, a poor composition and deformed video, low resolution, duplicate and ugly, strange body structure, long and strange neck, bad teeth, bad eyes, bad limbs, bad hands, rotating camera, blurry camera, shaking camera. Deformation, low-resolution, blurry, ugly, distortion."
sample_step_slider	O número de etapas de amostragem para o processo de remoção de ruído do modelo de difusão. Mais etapas podem produzir detalhes mais ricos, mas aumentam o tempo de geração.	int	30
cfg_scale_slider	A escala de orientação do prompt. Valores mais altos aumentam o alinhamento com o prompt, mas podem reduzir a diversidade.	float	6
sampler_dropdown	O algoritmo de amostragem a ser usado. Valores válidos: Euler, EulerA, DPM++, PNDM, DDIM	string	Euler
width_slider	A largura do vídeo gerado.	int	672
height_slider	A altura do vídeo gerado.	int	384
length_slider	O número de quadros de vídeo a serem gerados.	int	144
is_image	Especifica se a entrada é uma imagem.	bool	False
lora_alpha_slider	O peso dos parâmetros do modelo de adaptação de baixo posto (LoRA).	float	0,55
seed_textbox	A semente aleatória.	int	43
lora_model_path	O caminho para um modelo LoRA adicional. Se especificado, o modelo LoRA é carregado para a solicitação atual e removido após a conclusão da solicitação.	string	none
base_model_path	O caminho do modelo transformer a ser atualizado.	string	none
motion_module_path	O caminho do modelo motion_module a ser atualizado.	string	none
generation_method	O tipo de geração. Valores válidos: Video Generation, Image Generation.	string	none

Etapa 3: (Opcional) Ajustar finamente o modelo

É possível ajustar finamente o modelo em um conjunto de dados personalizado para gerar vídeos com estilos ou conteúdos específicos. Siga estas etapas:

Acesse o PAI console. No painel de navegação à esquerda, clique em Workspaces e localize e clique no nome do workspace desejado.
No painel de navegação à esquerda, clique em Quick Start > Model Gallery.
No Model Gallery, pesquise por EasyAnimate HD Long Video Generation Model e clique em Fine-tune para abrir a página de configuração.
Defina Source como Public Resources. Para Instance type, selecione uma instância com GPU A10 ou superior. Configure os hiperparâmetros conforme necessário e mantenha os valores padrão para os outros parâmetros.

Para ajustar finamente o modelo com um conjunto de dados personalizado, utilize as orientações a seguir:
Conjunto de dados personalizado
1. Prepare uma pasta de dados e um arquivo meta. A pasta de dados contém as imagens e vídeos para treinamento. O arquivo meta está no formato JSON, onde cada entrada consiste em um caminho de arquivo, descrição de texto e tipo de dados, representados pelos campos file_path, text e type, respectivamente. Por exemplo:
  [ { "file_path": "00031-3640797216.png", "text": "1girl, black_hair", "type": "image" }, { "file_path": "00032-3838108680.png", "text": "1girl, black_hair", "type": "image" } ]
  Para dados de vídeo, defina type como video. Para dados de imagem, defina type como image.
2. Na página de configuração de treinamento, clique em Select OSS File or Directory e, em seguida, faça upload e selecione a pasta de dados e o arquivo meta.
Clique em Train > Confirm para criar a tarefa de treinamento. Com a configuração deste tutorial, o processo de treinamento leva cerca de 40 minutos. Quando o status da tarefa mudar para Successful, o treinamento do modelo estará concluído.

Para visualizar detalhes da tarefa de treinamento posteriormente, no painel de navegação à esquerda, clique em Model Gallery > Job Management > Training Jobs e, em seguida, clique no nome da tarefa.
No canto superior direito, clique em Deploy para implantar o modelo ajustado. Quando o status mudar para Running, a implantação estará concluída.
Na página Service details, clique em View WEB Application na parte superior da página.

Para visualizar detalhes do service posteriormente, no painel de navegação à esquerda, clique em Model Gallery > Job Management > Deployment Jobs e, em seguida, clique no Service name .
Na WebUI, selecione o modelo LoRA treinado para gerar vídeos. Para uso da API, consulte Step 2.

Na seção Model checkpoints, selecione o modelo LoRA na lista suspensa Select LoRA model e defina seu peso usando o controle deslizante LoRA alpha.

Recomendações para produção

Interrompa instâncias ou serviços para economizar custos: Este tutorial cria instâncias DSW e serviços de modelo EAS utilizando recursos públicos. Para evitar cobranças adicionais, pare ou exclua essas instâncias e serviços quando não forem mais necessários.
- Na página Interactive Modeling (DSW), localize a instância desejada. Na coluna Actions, clique em Stop para parar uma instância em execução ou clique em Delete para excluir uma instância parada.
- Na página Model Gallery, clique na aba Task Management e, em seguida, clique na subaba Deployment Tasks. Localize o service desejado e clique em Stop ou Delete na coluna Actions.
Utilize o EAS para implantação em produção: Para ambientes de produção, use a Solução 2 para implantação do modelo no EAS com um clique. Se você utilizou a Solução 1, implante o modelo no EAS criando uma imagem de runtime personalizada. Para mais informações, consulte Deploy models as online services.

O EAS oferece os seguintes recursos para cargas de trabalho de produção:
- Use o recurso stress testing do EAS para testar o nível de concorrência que o endpoint do service suporta.
- Utilize o recurso auto scaling do EAS para dimensionar instâncias automaticamente, lidando com picos e quedas de tráfego e garantindo a operação estável do service.
- Aproveite o recurso log monitoring and alerting do EAS para monitorar a integridade do service em tempo real, melhorando a estabilidade e a segurança do sistema.

Referências

O EAS fornece um método de implantação baseado em cenários para implantação com um clique de serviços de geração de vídeo com IA baseados em modelos ComfyUI e Stable Video Diffusion. Para mais informações, consulte AI Video Generation - ComfyUI Deployment.