Execute a geração de texto com modelos GPT e Bloom no Amazon SageMaker JumpStart

Em dezembro de 2020, AWS anunciou a disponibilidade geral de JumpStart do Amazon SageMaker, uma capacidade de Amazon Sage Maker que ajuda você a começar de maneira rápida e fácil com o aprendizado de máquina (ML). O JumpStart fornece ajuste fino e implantação com um clique de uma ampla variedade de modelos pré-treinados em tarefas populares de ML, bem como uma seleção de soluções de ponta a ponta que resolvem problemas comuns de negócios. Esses recursos eliminam o trabalho pesado de cada etapa do processo de ML, facilitando o desenvolvimento de modelos de alta qualidade e reduzindo o tempo de implantação.

Esta postagem é a quarta de uma série sobre como usar o JumpStart para tarefas específicas de ML. No primeira postagem, mostramos como executar casos de uso de classificação de imagens no JumpStart. No segundo post, demonstramos como executar casos de uso de classificação de texto. No terceiro post, executamos casos de uso de segmentação de imagens.

Nesta postagem, fornecemos um passo a passo sobre como implantar modelos de geração de texto pré-treinados. Exploramos duas formas de obter o mesmo resultado: através da interface gráfica do JumpStart no Estúdio Amazon SageMaker, e programaticamente por meio de APIs JumpStart.

Se quiser ir direto para o código da API JumpStart que abordamos nesta postagem, você pode consultar o seguinte exemplo de notebook Jupyter: Introdução ao JumpStart – Geração de Texto.

Visão geral do JumpStart

JumpStart ajuda você a começar a usar modelos de ML para uma variedade de tarefas sem escrever uma única linha de código. Atualmente, o JumpStart permite que você faça o seguinte:

• Implante modelos pré-treinados para tarefas comuns de ML – O JumpStart permite que você resolva tarefas comuns de ML sem nenhum esforço de desenvolvimento, fornecendo fácil implantação de modelos pré-treinados em grandes conjuntos de dados disponíveis publicamente. A comunidade de pesquisa de ML se esforçou muito para disponibilizar publicamente para uso a maioria dos modelos recentemente desenvolvidos. JumpStart hospeda uma coleção de mais de 300 modelos, abrangendo as 15 tarefas de ML mais populares, como detecção de objetos, classificação de texto e geração de texto, facilitando seu uso para iniciantes. Esses modelos são extraídos de hubs de modelos populares, como TensorFlow, PyTorch, Hugging Face e MXNet.
• Ajustar modelos pré-treinados – JumpStart permite ajustar modelos pré-treinados sem a necessidade de escrever seu próprio algoritmo de treinamento. Em ML, a capacidade de transferir o conhecimento aprendido em um domínio para outro domínio é chamada transferir aprendizado. Você pode usar a aprendizagem por transferência para produzir modelos precisos em conjuntos de dados menores, com custos de treinamento muito mais baixos do que aqueles envolvidos no treinamento do modelo original. JumpStart também inclui algoritmos de treinamento populares baseados em LightGBM, CatBoost, XGBoost e Scikit-learn, que você pode treinar do zero para regressão e classificação tabular.
• Use soluções pré-construídas – JumpStart fornece um conjunto de 17 soluções para casos de uso comuns de ML, como previsão de demanda e aplicações industriais e financeiras, que você pode implantar com apenas alguns cliques. As soluções são aplicativos de ML completos que reúnem vários serviços da AWS para resolver um caso de uso de negócios específico. Eles usam Formação da Nuvem AWS modelos e arquiteturas de referência para implantação rápida, o que significa que são totalmente personalizáveis.
• Consulte exemplos de notebook para algoritmos SageMaker – O SageMaker fornece um conjunto de algoritmos integrados para ajudar cientistas de dados e profissionais de ML a começar a treinar e implantar modelos de ML rapidamente. JumpStart fornece blocos de anotações de amostra que você pode usar para usar rapidamente esses algoritmos.
• Revise vídeos de treinamento e blogs – O JumpStart também fornece várias postagens de blog e vídeos que ensinam como usar diferentes funcionalidades do SageMaker.

O JumpStart aceita configurações personalizadas de VPC e Serviço de gerenciamento de chaves AWS (AWS KMS) para que você possa usar os modelos e soluções disponíveis com segurança em seu ambiente empresarial. Você pode passar suas configurações de segurança para o JumpStart no Studio ou por meio do SageMaker Python SDK.

Geração de texto, GPT-2 e Bloom

A geração de texto é a tarefa de gerar um texto fluente e que pareça indistinguível do texto escrito por humanos. Também é conhecido como geração de linguagem natural.

GPT-2 é um modelo popular de geração de texto baseado em transformador. Ele é pré-treinado em um grande corpus de texto bruto em inglês, sem rotulagem humana. É treinado na tarefa em que, dada uma sequência parcial (frase ou trecho de texto), o modelo precisa prever a próxima palavra ou token da sequência.

Bloom também é um modelo de geração de texto baseado em transformador e treinado de forma semelhante ao GPT-2. No entanto, Bloom é pré-treinado em 46 linguagens diferentes e 13 linguagens de programação. A seguir está um exemplo de execução de geração de texto com o modelo Bloom:

Input: "Some people like dogs, some people like cats"
Output: "Some people like dogs, some people like cats some people like birds, some people like fish,"

Visão geral da solução

As seções a seguir fornecem uma demonstração passo a passo para realizar inferências, tanto por meio da UI do Studio quanto por meio de APIs JumpStart. Seguimos as seguintes etapas:

1. Acesse o JumpStart por meio da UI do Studio para implantar e executar inferência no modelo pré-treinado.
2. Use JumpStart programaticamente com o SageMaker Python SDK para implantar o modelo pré-treinado e executar inferência.

Acesse o JumpStart por meio da UI do Studio e execute inferência com um modelo pré-treinado

Nesta seção, demonstramos como treinar e implantar modelos JumpStart por meio da UI do Studio.

O vídeo a seguir mostra como encontrar um modelo de geração de texto pré-treinado no JumpStart e implantá-lo. A página do modelo contém informações valiosas sobre o modelo e como usá-lo. Você pode implantar qualquer um dos modelos pré-treinados disponíveis no JumpStart. Para inferência, escolhemos o tipo de instância ml.p3.2xlarge, porque ele fornece a aceleração de GPU necessária para baixa latência de inferência a um preço baixo. Depois de configurar a instância de hospedagem do SageMaker, escolha Implantação. Pode levar de 20 a 25 minutos até que seu endpoint persistente esteja funcionando.

Assim que seu endpoint estiver operacional, ele estará pronto para responder às solicitações de inferência!

Para acelerar o tempo de inferência, o JumpStart fornece um bloco de anotações de exemplo que mostra como executar a inferência em seu endpoint recém-implantado. Escolher Abra o Notebook para Usar endpoint do Studio.

Use o JumpStart programaticamente com o SDK do SageMaker

Na seção anterior, mostramos como você pode usar a UI JumpStart para implantar um modelo pré-treinado de forma interativa, com apenas alguns cliques. No entanto, você também pode usar os modelos do JumpStart programaticamente usando APIs integradas ao SDK do SageMaker.

Nesta seção, examinamos um exemplo rápido de como você pode replicar o processo anterior com o SageMaker SDK. Escolhemos um modelo pré-treinado apropriado no JumpStart, implantamos esse modelo em um endpoint SageMaker e executamos inferência no endpoint implantado. Todas as etapas desta demonstração estão disponíveis no caderno que acompanha Introdução ao JumpStart – Geração de Texto.

Implante o modelo pré-treinado

SageMaker é uma plataforma que faz uso extensivo de contêineres Docker para tarefas de construção e tempo de execução. JumpStart usa o framework específico disponível Contêineres de aprendizado profundo do SageMaker (DLC). Primeiro buscamos quaisquer pacotes adicionais, bem como scripts para lidar com treinamento e inferência para a tarefa selecionada. Finalmente, os artefatos do modelo pré-treinado são buscados separadamente com model_uris, o que proporciona flexibilidade à plataforma. Você pode usar qualquer número de modelos pré-treinados na mesma tarefa com um único script de inferência. Veja o seguinte código:

model_id, model_version = "huggingface-textgeneration-bloom-560m", "*"

# Retrieve the inference docker container uri
deploy_image_uri = image_uris.retrieve(
    region=None,
    framework=None,  # automatically inferred from model_id
    image_scope="inference",
    model_id=model_id,
    model_version=model_version,
    instance_type=inference_instance_type,
)

# Retrieve the inference script uri
deploy_source_uri = script_uris.retrieve(model_id=model_id, model_version=model_version, script_scope="inference")

base_model_uri = model_uris.retrieve(model_id=model_id, model_version=model_version, model_scope="inference")

Bloom é um modelo muito grande e pode levar de 20 a 25 minutos para ser implantado. Você também pode usar um modelo menor, como o GPT-2. Para implantar um modelo GPT-2 pré-treinado, você pode definir model_id = huggingface-textgeneration-gpt2. Para obter uma lista de outros modelos disponíveis no JumpStart, consulte Tabela de modelos disponíveis do JumpStart.

Em seguida, alimentamos os recursos em um Modelo do SageMaker instância e implante um endpoint:

# Create the SageMaker model instance
model = Model(
    image_uri=deploy_image_uri,
    source_dir=deploy_source_uri,
    model_data=base_model_uri,
    entry_point="inference.py",  # entry point file in source_dir and present in deploy_source_uri
    role=aws_role,
    predictor_cls=Predictor,
    name=endpoint_name,
)

# deploy the Model. Note that we need to pass Predictor class when we deploy model through Model class,
# for being able to run inference through the sagemaker API.
base_model_predictor = model.deploy(
    initial_instance_count=1,
    instance_type=inference_instance_type,
    predictor_cls=Predictor,
    endpoint_name=endpoint_name,
)

Depois que nosso modelo é implantado, podemos obter previsões em tempo real!

Executar inferência

O trecho de código a seguir dá uma ideia da aparência das saídas. Para enviar solicitações para um modelo implantado, o texto de entrada precisa ser fornecido em um formato utf-8 formato codificado.

def query(model_predictor, text):
    """Query the model predictor."""

    encoded_text = json.dumps(text).encode("utf-8")

    query_response = model_predictor.predict(
        encoded_text,
        {
            "ContentType": "application/x-text",
            "Accept": "application/json",
        },
    )
    return query_response

A resposta do endpoint é um objeto JSON que contém o texto de entrada seguido pelo texto gerado:

def parse_response(query_response):
    """Parse response and return the generated text."""

    model_predictions = json.loads(query_response)
    generated_text = model_predictions["generated_text"]
    return generated_text
    
text = "Some people like dogs, some people like cats"
query_response = query(model_predictor, text)
parse_response(query_response)

Nossa saída é a seguinte:

"Some people like dogs, some people like cats some people like birds, some people like fish,"

Conclusão

Neste post, mostramos como implantar um modelo de geração de texto pré-treinado usando JumpStart. Você pode fazer isso sem precisar escrever código. Experimente a solução você mesmo e envie-nos seus comentários. Para saber mais sobre o JumpStart e como você pode usar modelos pré-treinados de código aberto para uma variedade de outras tarefas de ML, confira o seguinte Vídeo AWS re:Invent 2020.

Sobre os autores

Vivek Madan é um cientista aplicado da equipe Amazon SageMaker JumpStart. Ele obteve seu doutorado na Universidade de Illinois em Urbana-Champaign e foi pesquisador de pós-doutorado na Georgia Tech. Ele é um pesquisador ativo em aprendizado de máquina e design de algoritmos e publicou artigos em conferências EMNLP, ICLR, COLT, FOCS e SODA.

Santosh Kulkarni é um arquiteto de soluções corporativas da Amazon Web Services que trabalha com clientes de esportes na Austrália. Ele é apaixonado por criar aplicativos distribuídos em larga escala para resolver problemas de negócios usando seu conhecimento em IA/ML, big data e desenvolvimento de software.

Dr. é um cientista aplicado sênior com algoritmos integrados do Amazon SageMaker e ajuda a desenvolver algoritmos de aprendizado de máquina. Ele obteve seu PhD pela University of Illinois Urbana Champaign. Ele é um pesquisador ativo em aprendizado de máquina e inferência estatística e publicou muitos artigos em conferências NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.