Sussurro OpenAI é um modelo avançado de reconhecimento automático de fala (ASR) com licença do MIT. A tecnologia ASR é útil em serviços de transcrição, assistentes de voz e na melhoria da acessibilidade para indivíduos com deficiência auditiva. Este modelo de última geração é treinado em um vasto e diversificado conjunto de dados supervisionados multilíngues e multitarefa coletados da web. Sua alta precisão e adaptabilidade tornam-no um recurso valioso para uma ampla gama de tarefas relacionadas à voz.

No cenário em constante evolução do aprendizado de máquina e da inteligência artificial, Amazon Sage Maker fornece um ecossistema abrangente. O SageMaker capacita cientistas de dados, desenvolvedores e organizações a desenvolver, treinar, implantar e gerenciar modelos de aprendizado de máquina em escala. Oferecendo uma ampla gama de ferramentas e recursos, simplifica todo o fluxo de trabalho de aprendizado de máquina, desde o pré-processamento de dados e desenvolvimento de modelo até implantação e monitoramento sem esforço. A interface amigável do SageMaker torna-o uma plataforma fundamental para desbloquear todo o potencial da IA, estabelecendo-a como uma solução revolucionária no domínio da inteligência artificial.

Nesta postagem, embarcamos em uma exploração dos recursos do SageMaker, focando especificamente na hospedagem de modelos Whisper. Iremos nos aprofundar em dois métodos para fazer isso: um utilizando o modelo Whisper PyTorch e outro usando a implementação Hugging Face do modelo Whisper. Além disso, realizaremos um exame aprofundado das opções de inferência do SageMaker, comparando-as em parâmetros como velocidade, custo, tamanho da carga útil e escalabilidade. Esta análise permite que os usuários tomem decisões informadas ao integrar modelos Whisper em seus casos de uso e sistemas específicos.

Visão geral da solução

O diagrama a seguir mostra os principais componentes desta solução.

1. Para hospedar o modelo no Amazon SageMaker, a primeira etapa é salvar os artefatos do modelo. Esses artefatos referem-se aos componentes essenciais de um modelo de aprendizado de máquina necessário para vários aplicativos, incluindo implantação e retreinamento. Eles podem incluir parâmetros do modelo, arquivos de configuração, componentes de pré-processamento, bem como metadados, como detalhes da versão, autoria e quaisquer notas relacionadas ao seu desempenho. É importante observar que os modelos Whisper para implementações PyTorch e Hugging Face consistem em diferentes artefatos de modelo.
2. A seguir, criamos scripts de inferência personalizados. Dentro desses scripts, definimos como o modelo deve ser carregado e especificamos o processo de inferência. É aqui também que podemos incorporar parâmetros personalizados conforme necessário. Além disso, você pode listar os pacotes Python necessários em um requirements.txt arquivo. Durante a implantação do modelo, esses pacotes Python são instalados automaticamente na fase de inicialização.
3. Em seguida, selecionamos os contêineres de aprendizado profundo (DLC) PyTorch ou Hugging Face fornecidos e mantidos por AWS. Esses contêineres são imagens Docker pré-construídas com estruturas de aprendizado profundo e outros pacotes Python necessários. Para mais informações, você pode verificar isto link.
4. Com os artefatos do modelo, scripts de inferência personalizados e DLCs selecionados, criaremos modelos do Amazon SageMaker para PyTorch e Hugging Face, respectivamente.
5. Finalmente, os modelos podem ser implantados no SageMaker e usados ​​com as seguintes opções: endpoints de inferência em tempo real, trabalhos de transformação em lote e endpoints de inferência assíncronos. Iremos nos aprofundar nessas opções com mais detalhes posteriormente nesta postagem.

O notebook de exemplo e o código desta solução estão disponíveis neste Repositório GitHub.

Figura 1. Visão geral dos principais componentes da solução

Passo a passo

Hospedando o modelo Whisper no Amazon SageMaker

Nesta seção, explicaremos as etapas para hospedar o modelo Whisper no Amazon SageMaker, usando PyTorch e Hugging Face Frameworks, respectivamente. Para experimentar esta solução, você precisa de uma conta AWS e acesso ao serviço Amazon SageMaker.

Estrutura PyTorch

1. Salvar artefatos de modelo

A primeira opção para hospedar o modelo é usar o Pacote Python oficial do Whisper, que pode ser instalado usando pip install openai-whisper. Este pacote fornece um modelo PyTorch. Ao salvar artefatos do modelo no repositório local, a primeira etapa é salvar os parâmetros que podem ser aprendidos do modelo, como pesos do modelo e desvios de cada camada da rede neural, como um arquivo ‘pt’. Você pode escolher entre diferentes tamanhos de modelo, incluindo ‘minúsculo’, ‘básico’, ‘pequeno’, ‘médio’ e ‘grande’. Tamanhos de modelo maiores oferecem maior desempenho de precisão, mas têm o custo de uma latência de inferência mais longa. Além disso, você precisa salvar o dicionário de estado do modelo e o dicionário de dimensão, que contém um dicionário Python que mapeia cada camada ou parâmetro do modelo PyTorch para seus parâmetros que podem ser aprendidos correspondentes, junto com outros metadados e configurações personalizadas. O código abaixo mostra como salvar os artefatos do Whisper PyTorch.

### PyTorch
import whisper
# Load the PyTorch model and save it in the local repo
model = whisper.load_model("base")
torch.save(
    {
        'model_state_dict': model.state_dict(),
        'dims': model.dims.__dict__,
    },
    'base.pt'
)

2. Selecione DLC

A próxima etapa é selecionar o DLC pré-construído deste link. Tenha cuidado ao escolher a imagem correta, considerando as seguintes configurações: estrutura (PyTorch), versão da estrutura, tarefa (inferência), versão do Python e hardware (ou seja, GPU). Recomenda-se usar as versões mais recentes do framework e Python sempre que possível, pois isso resulta em melhor desempenho e resolve problemas e bugs conhecidos de versões anteriores.

3. Criar modelos do Amazon SageMaker

A seguir, utilizamos o SDK Python do SageMaker para criar modelos PyTorch. É importante lembrar de adicionar variáveis ​​de ambiente ao criar um modelo PyTorch. Por padrão, o TorchServe só pode processar arquivos de até 6 MB, independentemente do tipo de inferência usado.

# Create a PyTorchModel for deployment
from sagemaker.pytorch.model import PyTorchModel

whisper_pytorch_model = PyTorchModel(
    model_data=model_uri,
    image_uri=image,
    role=role,
    entry_point="inference.py",
    source_dir='code',
    name=model_name,
    env = {
        'TS_MAX_REQUEST_SIZE': '100000000',
        'TS_MAX_RESPONSE_SIZE': '100000000',
        'TS_DEFAULT_RESPONSE_TIMEOUT': '1000'
    }
)

A tabela a seguir mostra as configurações para diferentes versões do PyTorch:

4. Defina o método de carregamento do modelo em inference.py

no costume inference.py script, primeiro verificamos a disponibilidade de uma GPU compatível com CUDA. Se tal GPU estiver disponível, então atribuímos o 'cuda' dispositivo para o DEVICE variável; caso contrário, atribuímos o 'cpu' dispositivo. Esta etapa garante que o modelo seja colocado no hardware disponível para uma computação eficiente. Carregamos o modelo PyTorch usando o pacote Whisper Python.

### PyTorch
DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
def model_fn(model_dir):
    """
    Load and return the model
    """
    model = whisper.load_model(os.path.join(model_dir, 'base.pt'))
    model = model.to(DEVICE)
    return model

Abraçando a estrutura do rosto

1. Salvar artefatos de modelo

A segunda opção é usar Abraçando o sussurro do rosto implementação. O modelo pode ser carregado usando o AutoModelForSpeechSeq2Seq aula de transformadores. Os parâmetros que podem ser aprendidos são salvos em um arquivo binário (bin) usando o save_pretrained método. O tokenizer e o pré-processador também precisam ser salvos separadamente para garantir que o modelo Hugging Face funcione corretamente. Como alternativa, você pode implantar um modelo no Amazon SageMaker diretamente do Hugging Face Hub definindo duas variáveis ​​de ambiente: HF_MODEL_ID e HF_TASK. Para obter mais informações, consulte este página da web.

### Hugging Face
from transformers import WhisperTokenizer, WhisperProcessor, AutoModelForSpeechSeq2Seq

# Load the pre-trained model
model_name = "openai/whisper-base"
model = AutoModelForSpeechSeq2Seq.from_pretrained(model_name)
tokenizer = WhisperTokenizer.from_pretrained(model_name)
processor = WhisperProcessor.from_pretrained(model_name)

# Define a directory where you want to save the model
save_directory = "./model"

# Save the model to the specified directory
model.save_pretrained(save_directory)
tokenizer.save_pretrained(save_directory)
processor.save_pretrained(save_directory)

2. Selecione DLC

Semelhante à estrutura PyTorch, você pode escolher um DLC Hugging Face pré-construído do mesmo link. Certifique-se de selecionar um DLC que suporte os mais recentes transformadores Hugging Face e inclua suporte para GPU.

3. Criar modelos do Amazon SageMaker

Da mesma forma, utilizamos o SDK Python do SageMaker para criar modelos de Hugging Face. O modelo Hugging Face Whisper tem uma limitação padrão onde só pode processar segmentos de áudio de até 30 segundos. Para resolver essa limitação, você pode incluir o chunk_length_s parâmetro na variável de ambiente ao criar o modelo Hugging Face e, posteriormente, passar esse parâmetro para o script de inferência personalizado ao carregar o modelo. Por último, defina as variáveis ​​de ambiente para aumentar o tamanho da carga útil e o tempo limite de resposta para o contêiner Hugging Face.

# Create a HuggingFaceModel for deployment
from sagemaker.huggingface.model import HuggingFaceModel

whisper_hf_model = HuggingFaceModel(
    model_data=model_uri,
    role=role, 
    image_uri = image,
    entry_point="inference.py",
    source_dir='code',
    name=model_name,
    env = {
        "chunk_length_s":"30",
        'MMS_MAX_REQUEST_SIZE': '2000000000',
        'MMS_MAX_RESPONSE_SIZE': '2000000000',
        'MMS_DEFAULT_RESPONSE_TIMEOUT': '900'
    }
)

4. Defina o método de carregamento do modelo em inference.py

Ao criar um script de inferência personalizado para o modelo Hugging Face, utilizamos um pipeline, que nos permite passar o chunk_length_s como parâmetro. Este parâmetro permite que o modelo processe com eficiência arquivos de áudio longos durante a inferência.

### Hugging Face
DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
chunk_length_s = int(os.environ.get('chunk_length_s'))
def model_fn(model_dir):
    """
    Load and return the model
    """
    model = pipeline(
        "automatic-speech-recognition",
        model=model_dir,
        chunk_length_s=chunk_length_s,
        device=DEVICE,
        )
    return model

Explorando diferentes opções de inferência no Amazon SageMaker

As etapas para selecionar opções de inferência são as mesmas para os modelos PyTorch e Hugging Face, portanto, não diferenciaremos entre eles abaixo. No entanto, é importante notar que, no momento em que escrevo este post, o inferência sem servidor A opção do SageMaker não oferece suporte a GPUs e, como resultado, excluímos esta opção para este caso de uso.

1. Inferência em tempo real

Podemos implantar o modelo como um endpoint em tempo real, fornecendo respostas em milissegundos. No entanto, é importante observar que esta opção está limitada ao processamento de entradas com menos de 6 MB. Definimos o serializador como um serializador de áudio, responsável por converter os dados de entrada em um formato adequado para o modelo implantado. Utilizamos uma instância de GPU para inferência, permitindo o processamento acelerado de arquivos de áudio. A entrada de inferência é um arquivo de áudio proveniente do repositório local.

from sagemaker.serializers import DataSerializer
from sagemaker.deserializers import JSONDeserializer

# Define serializers and deserializer
audio_serializer = DataSerializer(content_type="audio/x-audio")
deserializer = JSONDeserializer()

# Deploy the model for real-time inference
endpoint_name = f'whisper-real-time-endpoint-{id}'

real_time_predictor = whisper_model.deploy(
    initial_instance_count=1,
    instance_type="ml.g4dn.xlarge",
    endpoint_name = endpoint_name,
    serializer=audio_serializer,
    deserializer = deserializer
    )

# Perform real-time inference
audio_path = "sample_audio.wav" 
response = real_time_predictor.predict(data=audio_path)

2. Trabalho de transformação em lote

A segunda opção de inferência é o trabalho de transformação em lote, que é capaz de processar cargas de entrada de até 100 MB. No entanto, esse método pode levar alguns minutos de latência. Cada instância pode lidar com apenas uma solicitação em lote por vez, e o início e o encerramento da instância também requerem alguns minutos. Os resultados da inferência são salvos em um Amazon Simple Storage Service (Amazon S3) após a conclusão do trabalho de transformação em lote.

Ao configurar o transformador em lote, certifique-se de incluir max_payload = 100 para lidar com cargas maiores de forma eficaz. A entrada de inferência deve ser o caminho do Amazon S3 para um arquivo de áudio ou uma pasta do Amazon S3 Bucket contendo uma lista de arquivos de áudio, cada um com tamanho menor que 100 MB.

O Batch Transform particiona os objetos do Amazon S3 na entrada por chave e mapeia objetos do Amazon S3 para instâncias. Por exemplo, quando você tem vários arquivos de áudio, uma instância pode processar input1.wav e outra instância pode processar o arquivo denominado input2.wav para aprimorar a escalabilidade. A transformação em lote permite configurar max_concurrent_transforms para aumentar o número de solicitações HTTP feitas para cada contêiner de transformador individual. No entanto, é importante notar que o valor de (max_concurrent_transforms* max_payload) não deve exceder 100 MB.

# Create a transformer
whisper_transformer = whisper_model.transformer(
    instance_count = 1,
    instance_type = "ml.g4dn.xlarge", 
    output_path="s3://{}/{}/batch-transform/".format(bucket, prefix),
    max_payload = 100
)
# Start batch transform job
whisper_transformer.transform(data = data, job_name= job_name, wait = False)

3. Inferência assíncrona

Por fim, o Amazon SageMaker Asynchronous Inference é ideal para processar diversas solicitações simultaneamente, oferecendo latência moderada e suportando cargas de entrada de até 1 GB. Esta opção oferece excelente escalabilidade, permitindo a configuração de um grupo de escalonamento automático para o endpoint. Quando ocorre um aumento repentino de solicitações, ele aumenta automaticamente para lidar com o tráfego e, depois que todas as solicitações são processadas, o endpoint reduz para 0 para economizar custos.

Usando inferência assíncrona, os resultados são salvos automaticamente em um bucket do Amazon S3. No AsyncInferenceConfig, você poderá configurar notificações para conclusões bem-sucedidas ou com falha. O caminho de entrada aponta para um local do arquivo de áudio no Amazon S3. Para obter detalhes adicionais, consulte o código em GitHub.

from sagemaker.async_inference import AsyncInferenceConfig

# Create an AsyncInferenceConfig object
async_config = AsyncInferenceConfig(
    output_path=f"s3://{bucket}/{prefix}/output", 
    max_concurrent_invocations_per_instance = 4,
    # notification_config = {
            #   "SuccessTopic": "arn:aws:sns:us-east-2:123456789012:MyTopic",
            #   "ErrorTopic": "arn:aws:sns:us-east-2:123456789012:MyTopic",
    #}, #  Notification configuration 
)

# Deploy the model for async inference
endpoint_name = f'whisper-async-endpoint-{id}'
async_predictor = whisper_model.deploy(
    async_inference_config=async_config,
    initial_instance_count=1, 
    instance_type ='ml.g4dn.xlarge',
    endpoint_name = endpoint_name
)

# Perform async inference
initial_args = {'ContentType':"audio/x-audio"}
response = async_predictor.predict_async(initial_args = initial_args, input_path=input_path)

Opcional: Conforme mencionado anteriormente, temos a opção de configurar um grupo de escalonamento automático para o endpoint de inferência assíncrona, o que permite lidar com um aumento repentino nas solicitações de inferência. Um exemplo de código é fornecido neste Repositório GitHub. No diagrama a seguir, você pode observar um gráfico de linhas exibindo duas métricas de Amazon CloudWatch: ApproximateBacklogSize e ApproximateBacklogSizePerInstance. Inicialmente, quando 1000 solicitações foram acionadas, apenas uma instância estava disponível para tratar a inferência. Durante três minutos, o tamanho do backlog excedeu consistentemente três (observe que esses números podem ser configurados), e o grupo de escalonamento automático respondeu ativando instâncias adicionais para limpar o backlog com eficiência. Isto resultou numa diminuição significativa do ApproximateBacklogSizePerInstance, permitindo que as solicitações de backlog sejam processadas muito mais rapidamente do que durante a fase inicial.

Figura 2. Gráfico de linhas ilustrando as mudanças temporais nas métricas do Amazon CloudWatch

Análise comparativa para as opções de inferência

As comparações para diferentes opções de inferência são baseadas em casos de uso comuns de processamento de áudio. A inferência em tempo real oferece a velocidade de inferência mais rápida, mas restringe o tamanho da carga útil a 6 MB. Este tipo de inferência é adequado para sistemas de comando de áudio, onde os usuários controlam ou interagem com dispositivos ou software usando comandos de voz ou instruções faladas. Os comandos de voz geralmente são pequenos e a baixa latência de inferência é crucial para garantir que os comandos transcritos possam acionar prontamente ações subsequentes. O Batch Transform é ideal para tarefas off-line agendadas, quando o tamanho de cada arquivo de áudio é inferior a 100 MB e não há requisitos específicos para tempos de resposta de inferência rápidos. A inferência assíncrona permite uploads de até 1 GB e oferece latência de inferência moderada. Esse tipo de inferência é adequado para transcrever filmes, séries de TV e conferências gravadas onde arquivos de áudio maiores precisam ser processados.

As opções de inferência em tempo real e assíncrona fornecem recursos de escalonamento automático, permitindo que as instâncias de endpoint aumentem ou diminuam automaticamente com base no volume de solicitações. Em casos sem solicitações, o escalonamento automático remove instâncias desnecessárias, ajudando a evitar custos associados a instâncias provisionadas que não estão em uso ativo. No entanto, para inferência em tempo real, pelo menos uma instância persistente deve ser retida, o que poderia levar a custos mais elevados se o terminal operasse continuamente. Por outro lado, a inferência assíncrona permite que o volume da instância seja reduzido a 0 quando não estiver em uso. Ao configurar um trabalho de transformação em lote, é possível usar várias instâncias para processar o trabalho e ajustar max_concurrent_transforms para permitir que uma instância lide com várias solicitações. Portanto, todas as três opções de inferência oferecem grande escalabilidade.

Limpando

Depois de concluir a utilização da solução, certifique-se de remover os endpoints do SageMaker para evitar incorrer em custos adicionais. Você pode usar o código fornecido para excluir pontos de extremidade de inferência em tempo real e assíncronos, respectivamente.

# Delete real-time inference endpoint
real_time_predictor.delete_endpoint()

# Delete asynchronous inference endpoint
async_predictor.delete_endpoint()

Conclusão

Neste post, mostramos como a implantação de modelos de aprendizado de máquina para processamento de áudio tem se tornado cada vez mais essencial em diversos setores. Tomando o modelo Whisper como exemplo, demonstramos como hospedar modelos ASR de código aberto no Amazon SageMaker usando abordagens PyTorch ou Hugging Face. A exploração abrangeu diversas opções de inferência no Amazon SageMaker, oferecendo insights sobre como lidar com dados de áudio de maneira eficiente, fazer previsões e gerenciar custos de maneira eficaz. Esta postagem tem como objetivo fornecer conhecimento para pesquisadores, desenvolvedores e cientistas de dados interessados ​​em aproveitar o modelo Whisper para tarefas relacionadas a áudio e tomar decisões informadas sobre estratégias de inferência.

Para obter informações mais detalhadas sobre a implantação de modelos no SageMaker, consulte este Guia do desenvolvedor. Além disso, o modelo Whisper pode ser implantado usando o SageMaker JumpStart. Para detalhes adicionais, por favor verifique o Modelos Whisper para reconhecimento automático de fala agora disponíveis no Amazon SageMaker JumpStart postar.

Sinta-se à vontade para verificar o notebook e o código deste projeto em GitHub e compartilhe seu comentário conosco.

Sobre o autor

Ying Hou, PhD, é arquiteto de prototipagem de aprendizado de máquina na AWS. Suas principais áreas de interesse abrangem Deep Learning, com foco em GenAI, Visão Computacional, PNL e previsão de dados de séries temporais. Nas horas vagas, ela adora passar momentos de qualidade com a família, mergulhando em romances e fazendo caminhadas nos parques nacionais do Reino Unido.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/host-the-whisper-model-on-amazon-sagemaker-exploring-inference-options/