Ajuste modelos de difusão estável de texto para imagem com Amazon SageMaker JumpStart

Republicado por Platão

seguidores: 0

Em novembro de 2022, anunciou que os clientes da AWS podem gerar imagens de texto com Difusão Estável modelos em JumpStart do Amazon SageMaker. Stable Diffusion é um modelo de aprendizado profundo que permite gerar imagens realistas de alta qualidade e arte impressionante em apenas alguns segundos. Embora a criação de imagens impressionantes possa ser usada em setores que variam de arte a NFTs e além, hoje também esperamos que a IA seja personalizável. Hoje, anunciamos que você pode personalizar o modelo de geração de imagem para seu caso de uso, ajustando-o em seu conjunto de dados personalizado em JumpStart do Amazon SageMaker. Isso pode ser útil ao criar arte, logotipos, designs personalizados, NFTs e assim por diante, ou coisas divertidas, como gerar imagens de IA personalizadas de seus animais de estimação ou avatares de você mesmo.

Nesta postagem, fornecemos uma visão geral de como ajustar o modelo Stable Diffusion de duas maneiras: programaticamente por meio de APIs JumpStart disponível no SDK Python do SageMaker, e a interface do usuário (IU) do JumpStart em Estúdio Amazon SageMaker. Também discutimos como fazer escolhas de design, incluindo qualidade do conjunto de dados, tamanho do conjunto de dados de treinamento, escolha de valores de hiperparâmetros e aplicabilidade a vários conjuntos de dados. Por fim, discutimos os mais de 80 modelos ajustados publicamente disponíveis com diferentes idiomas e estilos de entrada recentemente adicionados ao JumpStart.

Difusão estável e aprendizado de transferência

Stable Diffusion é um modelo de texto para imagem que permite criar imagens fotorrealistas a partir de apenas um prompt de texto. Um modelo de difusão treina aprendendo a remover o ruído que foi adicionado a uma imagem real. Este processo de redução de ruído gera uma imagem realista. Esses modelos também podem gerar imagens apenas a partir do texto, condicionando o processo de geração ao texto. Por exemplo, Stable Diffusion é uma difusão latente em que o modelo aprende a reconhecer formas em uma imagem de ruído puro e gradualmente coloca essas formas em foco se as formas corresponderem às palavras no texto de entrada. O texto deve primeiro ser inserido em um espaço latente usando um modelo de linguagem. Em seguida, uma série de operações de adição e remoção de ruído são realizadas no espaço latente com uma arquitetura U-Net. Finalmente, a saída sem ruído é decodificada no espaço do pixel.

Fonte: https://jalammar.github.io/illustrated-stable-diffusion/

No aprendizado de máquina (ML), a capacidade de transferir o conhecimento aprendido em um domínio para outro é chamada transferir aprendizado. Você pode usar o aprendizado de transferência para produzir modelos precisos em seus conjuntos de dados menores, com custos de treinamento muito mais baixos do que os envolvidos no treinamento do modelo original. Com o aprendizado de transferência, você pode ajustar o modelo de difusão estável em seu próprio conjunto de dados com apenas cinco imagens. Por exemplo, à esquerda estão as imagens de treinamento de um cachorro chamado Doppler usado para ajustar o modelo, no meio e à direita estão as imagens geradas pelo modelo ajustado quando solicitado a prever a imagem de Doppler na praia e um esboço a lápis.

À esquerda estão as imagens de uma cadeira branca usada para ajustar o modelo e uma imagem da cadeira em vermelho gerada pelo modelo ajustado. À direita estão as imagens de um pufe usado para ajustar o modelo e a imagem de um gato sentado em um pufe.

O ajuste fino de modelos grandes, como Stable Diffusion, geralmente exige que você forneça scripts de treinamento. Há uma série de problemas, incluindo problemas de falta de memória, problemas de tamanho de carga útil e muito mais. Além disso, você deve executar testes de ponta a ponta para garantir que o script, o modelo e a instância desejada funcionem juntos de maneira eficiente. O JumpStart simplifica esse processo fornecendo scripts prontos para uso que foram testados de forma robusta. O script de ajuste fino JumpStart para modelos de difusão estável baseia-se no script de ajuste fino de cabine de sonho. Você pode acessar esses scripts com um único clique por meio da interface do usuário do Studio ou com pouquíssimas linhas de código por meio do APIs JumpStart.

Observe que, ao usar o modelo de difusão estável, você concorda com os Licença CreativeML Open RAIL++-M.

Use o JumpStart programaticamente com o SDK do SageMaker

Esta seção descreve como treinar e implantar o modelo com o SDK Python do SageMaker. Escolhemos um modelo pré-treinado apropriado no JumpStart, treinamos esse modelo com um trabalho de treinamento do SageMaker e implantamos o modelo treinado em um endpoint do SageMaker. Além disso, executamos inferência no endpoint implantado, tudo usando o SageMaker Python SDK. Os exemplos a seguir contêm trechos de código. Para obter o código completo com todas as etapas desta demonstração, consulte o Introdução ao JumpStart - Texto para Imagem caderno de exemplo.

Treine e ajuste o modelo de difusão estável

Cada modelo é identificado por um único model_id. O código a seguir mostra como ajustar um modelo base Stable Diffusion 2.1 identificado por model_id model-txt2img-stabilityai-stable-diffusion-v2-1-base em um conjunto de dados de treinamento personalizado. Para uma lista completa de model_id valores e quais modelos são ajustáveis, consulte Algoritmos integrados com tabela de modelo pré-treinada. Para cada model_id, para iniciar um trabalho de treinamento do SageMaker por meio do Estimador class do SageMaker Python SDK, você precisa buscar o URI da imagem do Docker, o URI do script de treinamento e o URI do modelo pré-treinado por meio das funções de utilitário fornecidas no SageMaker. O URI do script de treinamento contém todo o código necessário para processamento de dados, carregamento do modelo pré-treinado, treinamento do modelo e salvamento do modelo treinado para inferência. O URI do modelo pré-treinado contém a definição de arquitetura do modelo pré-treinado e os parâmetros do modelo. O URI do modelo pré-treinado é específico para o modelo específico. Os tarballs de modelos pré-treinados foram pré-baixados do Hugging Face e salvos com a assinatura de modelo apropriada em Serviço de armazenamento simples da Amazon (Amazon S3), de modo que o trabalho de treinamento seja executado em isolamento de rede. Veja o seguinte código:

from sagemaker import image_uris, model_uris, script_uris # Currently, not all the stable diffusion models in jumpstart support finetuning. Thus, we manually select a model
# which supports finetuning.
train_model_id, train_model_version, train_scope = ( "model-txt2img-stabilityai-stable-diffusion-v2-1-base", "*", "training",
) # Tested with ml.g4dn.2xlarge (16GB GPU memory) and ml.g5.2xlarge (24GB GPU memory) instances. Other instances may work as well.
# If ml.g5.2xlarge instance type is available, please change the following instance type to speed up training.
training_instance_type = "ml.g4dn.2xlarge" # Retrieve the docker image
train_image_uri = image_uris.retrieve(
region=None,
framework=None, # automatically inferred from model_id
model_id=train_model_id,
model_version=train_model_version,
image_scope=train_scope,
instance_type=training_instance_type,
) # Retrieve the training script. This contains all the necessary files including data processing, model training etc.
train_source_uri = script_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, script_scope=train_scope
) # Retrieve the pre-trained model tarball to further fine-tune
train_model_uri = model_uris.retrieve(
model_id=train_model_id, model_version=train_model_version, model_scope=train_scope
)

Com esses artefatos de treinamento específicos do modelo, você pode construir um objeto do Estimador classe:

# Create SageMaker Estimator instance
sd_estimator = Estimator( role=aws_role, image_uri=train_image_uri, source_dir=train_source_uri, model_uri=train_model_uri, entry_point="transfer_learning.py", # Entry-point file in source_dir and present in train_source_uri. instance_count=1, instance_type=training_instance_type, max_run=360000, hyperparameters=hyperparameters, output_path=s3_output_location, base_job_name=training_job_name,
) # Launch a SageMaker Training job by passing s3 path of the training data
sd_estimator.fit({"training": training_dataset_s3_path}, logs=True)

Conjunto de dados de treinamento

A seguir estão as instruções de como os dados de treinamento devem ser formatados:

Entrada – Um diretório contendo as imagens da instância, dataset_info.json, com a seguinte configuração:
- As imagens podem estar no formato .png, .jpg ou .jpeg
- A dataset_info.json o arquivo deve estar no formato {'instance_prompt':<<instance_prompt>>}
saída – Um modelo treinado que pode ser implantado para inferência

O caminho S3 deve se parecer com s3://bucket_name/input_directory/. Observe o rastro / É necessário.

Veja a seguir um exemplo de formato dos dados de treinamento:

input_directory |---instance_image_1.png |---instance_image_2.png |---instance_image_3.png |---instance_image_4.png |---instance_image_5.png |---dataset_info.json

Para obter instruções sobre como formatar os dados durante a preservação anterior, consulte a seção Preservação Prévia neste post.

Fornecemos um conjunto de dados padrão de imagens de gatos. Consiste em oito imagens (imagens de instância correspondentes ao prompt de instância) de um único gato sem imagens de classe. Ele pode ser baixado de GitHub. Se estiver usando o conjunto de dados padrão, tente o prompt “a photo of a riobugger cat” ao fazer inferência no notebook de demonstração.

Licença: MIT.

Hiperparâmetros

Em seguida, para aprendizado de transferência em seu conjunto de dados personalizado, talvez seja necessário alterar os valores padrão dos hiperparâmetros de treinamento. Você pode buscar um dicionário Python desses hiperparâmetros com seus valores padrão chamando hyperparameters.retrieve_default, atualize-os conforme necessário e, em seguida, passe-os para a classe Estimator. Veja o seguinte código:

from sagemaker import hyperparameters
# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
model_id=train_model_id, model_version=train_model_version
) # [Optional] Override default hyperparameters with custom values
hyperparameters["max_steps"] = "400"

Os seguintes hiperparâmetros são suportados pelo algoritmo de ajuste fino:

with_prior_preservation – Sinalize para adicionar perda de preservação anterior. A preservação prévia é um regularizador que evita o overfitting. (Escolhas: [“True”,“False”], padrão: “False”.)
num_class_images – As imagens de classe mínima para perda de preservação anterior. Se with_prior_preservation = True e não há imagens suficientes já presentes em class_data_dir, imagens adicionais serão amostradas com class_prompt. (Valores: número inteiro positivo, padrão: 100.)
Épocas – O número de passagens que o algoritmo de ajuste fino leva através do conjunto de dados de treinamento. (Valores: número inteiro positivo, padrão: 20.)
Máx_passos – O número total de etapas de treinamento a serem executadas. Se não None, substitui as épocas. (Valores: “None” ou uma string de número inteiro, padrão: “None”.)
Tamanho do batch –: O número de exemplos de treinamento que são trabalhados antes que os pesos do modelo sejam atualizados. Igual ao tamanho do lote durante a geração de imagens de classe se with_prior_preservation = True. (Valores: número inteiro positivo, padrão: 1.)
taxa de Aprendizagem – A taxa na qual os pesos do modelo são atualizados depois de trabalhar em cada lote de exemplos de treinamento. (Valores: flutuação positiva, padrão: 2e-06.)
anterior_perda_peso – O peso da perda de preservação anterior. (Valores: flutuação positiva, padrão: 1.0.)
centro_crop – Cortar ou não as imagens antes de redimensioná-las para a resolução desejada. (Escolhas: [“True”/“False”], padrão: “False”.)
lr_scheduler – O tipo de escalonador de taxa de aprendizado. (Escolhas: ["linear", "cosine", "cosine_with_restarts", "polynomial", "constant", "constant_with_warmup"], padrão: "constant".) Para mais informações, veja Agendadores de Taxa de Aprendizagem.
adam_weight_decay – O decaimento do peso a ser aplicado (se não for zero) a todas as camadas, exceto todos os bias e LayerNorm pesos em AdamW otimizador. (Valor: flutuante, padrão: 1e-2.)
adam_beta1 – O hiperparâmetro beta1 (taxa de decaimento exponencial para as estimativas do primeiro momento) para o AdamW otimizador. (Valor: flutuante, padrão: 0.9.)
adam_beta2 – O hiperparâmetro beta2 (taxa de decaimento exponencial para as estimativas do primeiro momento) para o AdamW otimizador. (Valor: flutuante, padrão: 0.999.)
adam_épsilon - A epsilon hiperparâmetro para o AdamW otimizador. Geralmente é definido como um valor pequeno para evitar a divisão por 0. (Valor: flutuante, padrão: 1e-8.)
gradiente_acumulação_passos – O número de etapas de atualização a serem acumuladas antes de executar uma passagem de atualização/retrocesso. (Valor: inteiro, padrão: 1.)
max_grad_norm – A norma de gradiente máximo (para corte de gradiente). (Valor: flutuante, padrão: 1.0.)
semente – Corrija o estado aleatório para obter resultados reprodutíveis no treinamento. (Valor: inteiro, padrão: 0.)

Implante o modelo bem treinado

Após a conclusão do treinamento do modelo, você pode implantar o modelo diretamente em um endpoint persistente em tempo real. Buscamos os URIs de imagem do Docker necessários e os URIs de script e implantamos o modelo. Veja o seguinte código:

inference_instance_type = "ml.g4dn.2xlarge" # 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=train_model_id, model_version=train_model_version, instance_type=inference_instance_type,
) # Retrieve the inference script uri. This includes scripts for model loading, inference handling etc.
deploy_source_uri = script_uris.retrieve( model_id=train_model_id, model_version=train_model_version, script_scope="inference"
) # Use the estimator from the previous step to deploy to a SageMaker endpoint
finetuned_predictor = sd_estimator.deploy( initial_instance_count=1, instance_type=inference_instance_type, entry_point="inference.py", # entry point file in source_dir and present in deploy_source_uri image_uri=deploy_image_uri, source_dir=deploy_source_uri, endpoint_name=endpoint_name,
)

À esquerda estão as imagens de treinamento de um gato chamado riobugger usado para ajustar o modelo (parâmetros padrão, exceto max_steps = 400). No meio e à direita estão as imagens geradas pelo modelo ajustado quando solicitado a prever a imagem do riobugger na praia e um esboço a lápis.

Para obter mais detalhes sobre inferência, incluindo parâmetros suportados, formato de resposta e assim por diante, consulte Gere imagens de texto com o modelo de difusão estável no Amazon SageMaker JumpStart.

Acesse o JumpStart pela interface do Studio

Nesta seção, demonstramos como treinar e implantar modelos JumpStart por meio da interface do usuário do Studio. O vídeo a seguir mostra como encontrar o modelo Stable Diffusion pré-treinado no JumpStart, treiná-lo e, em seguida, implantá-lo. A página do modelo contém informações valiosas sobre o modelo e como usá-lo. Depois de configurar a instância de treinamento do SageMaker, escolha Trem. Depois que o modelo for treinado, você poderá implantar o modelo treinado escolhendo Implantação. Depois que o endpoint estiver no estágio “em serviço”, ele estará pronto para responder às solicitações de inferência.

Para acelerar o tempo de inferência, o JumpStart fornece um notebook de amostra que mostra como executar a inferência no endpoint recém-criado. Para acessar o notebook no Studio, escolha Abra o Notebook no Usar endpoint do Studio seção da página de terminal do modelo.

O JumpStart também fornece um notebook simples que você pode usar para ajustar o modelo de difusão estável e implantar o modelo ajustado resultante. Você pode usá-lo para gerar imagens divertidas do seu cachorro. Para acessar o notebook, procure por “Gerar imagens divertidas do seu cachorro” na barra de pesquisa do JumpStart. Para executar o notebook, você pode usar apenas cinco imagens de treinamento e fazer o upload para a pasta local do estúdio. Se você tiver mais de cinco imagens, também poderá carregá-las. O Notebook carrega as imagens de treinamento para o S3, treina o modelo em seu conjunto de dados e implanta o modelo resultante. O treinamento pode levar 20 minutos para terminar. Você pode alterar o número de etapas para acelerar o treinamento. O Notebook fornece alguns prompts de amostra para tentar com o modelo implantado, mas você pode tentar qualquer prompt que desejar. Você também pode adaptar o notebook para criar avatares seus ou de seus animais de estimação. Por exemplo, em vez de seu cachorro, você pode carregar imagens de seu gato na primeira etapa e, em seguida, alterar os prompts de cachorros para gatos e o modelo gerará imagens de seu gato.

Considerações de ajuste fino

Os modelos de difusão estável de treinamento tendem a se ajustar rapidamente. Para obter imagens de boa qualidade, devemos encontrar um bom equilíbrio entre os hiperparâmetros de treinamento disponíveis, como número de etapas de treinamento e taxa de aprendizado. Nesta seção, mostramos alguns resultados experimentais e fornecemos orientação sobre como definir esses parâmetros.

Recomendações

Considere as seguintes recomendações:

Comece com imagens de treinamento de boa qualidade (4–20). Se treinar em rostos humanos, você pode precisar de mais imagens.
Treine de 200 a 400 passos ao treinar cães ou gatos e outros assuntos não humanos. Se treinar em rostos humanos, você pode precisar de mais etapas. Se ocorrer overfitting, reduza o número de etapas. Se ocorrer um ajuste insuficiente (o modelo com ajuste fino não pode gerar a imagem do sujeito de destino), aumente o número de etapas.
Se estiver treinando em rostos não humanos, você pode definir with_prior_preservation = False porque não afeta significativamente o desempenho. Em rostos humanos, pode ser necessário definir with_prior_preservation=True.
Se definir with_prior_preservation=True, use o tipo de instância ml.g5.2xlarge.
Ao treinar vários assuntos sequencialmente, se os assuntos forem muito semelhantes (por exemplo, todos os cães), o modelo retém o último assunto e esquece os assuntos anteriores. Se os sujeitos forem diferentes (por exemplo, primeiro um gato e depois um cachorro), o modelo retém os dois sujeitos.
Recomendamos usar uma taxa de aprendizado baixa e aumentar progressivamente o número de etapas até que os resultados sejam satisfatórios.

Conjunto de dados de treinamento

A qualidade do modelo ajustado é diretamente afetada pela qualidade das imagens de treinamento. Portanto, você precisa coletar imagens de alta qualidade para obter bons resultados. Imagens borradas ou de baixa resolução afetarão a qualidade do modelo ajustado. Tenha em mente os seguintes parâmetros adicionais:

Número de imagens de treinamento – Você pode ajustar o modelo em até quatro imagens de treinamento. Experimentamos conjuntos de dados de treinamento com tamanho mínimo de 4 imagens e até 16 imagens. Em ambos os casos, o ajuste fino foi capaz de adaptar o modelo ao sujeito.
Formatos de conjunto de dados – Testamos o algoritmo de ajuste fino em imagens de formato .png, .jpg e .jpeg. Outros formatos também podem funcionar.
Resolução de imagem – As imagens de treinamento podem ter qualquer resolução. O algoritmo de ajuste fino redimensionará todas as imagens de treinamento antes de iniciar o ajuste fino. Dito isto, se você quiser ter mais controle sobre o corte e redimensionamento das imagens de treinamento, recomendamos redimensionar as imagens você mesmo para a resolução básica do modelo (neste exemplo, 512 × 512 pixels).

Configurações do experimento

No experimento desta postagem, durante o ajuste fino, usamos os valores padrão dos hiperparâmetros, a menos que seja especificado. Além disso, usamos um dos quatro conjuntos de dados:

Cachorro1-8 – Cachorro 1 com 8 imagens
Cachorro1-16 – Cachorro 1 com 16 imagens
Cachorro2-4 – Cachorro 2 com quatro imagens
Gato-8 – Gato com 8 imagens

Para reduzir a confusão, mostramos apenas uma imagem representativa do conjunto de dados em cada seção junto com o nome do conjunto de dados. Você pode encontrar o conjunto de treinamento completo na seção Conjuntos de dados de experimentação neste post.

Overfitting

Os modelos de Difusão Estável tendem a se sobreajustar durante o ajuste fino em algumas imagens. Portanto, você precisa selecionar os parâmetros, como epochs, max_epochs, e taxa de aprendizagem com cuidado. Nesta seção, usamos o conjunto de dados Dog1-16.

Para avaliar o desempenho do modelo, avaliamos o modelo ajustado para quatro tarefas:

O modelo ajustado pode gerar imagens do sujeito (cão Doppler) no mesmo cenário em que foi treinado?
- Observação - Sim pode. Vale a pena notar que o desempenho do modelo aumenta com o número de etapas de treinamento.
O modelo ajustado pode gerar imagens do sujeito em um ambiente diferente daquele em que foi treinado? Por exemplo, pode gerar imagens de Doppler em uma praia?
- Observação - Sim pode. Vale a pena notar que o desempenho do modelo aumenta com o número de etapas de treinamento até certo ponto. No entanto, se o modelo estiver sendo treinado por muito tempo, o desempenho do modelo será prejudicado, pois o modelo tende a se ajustar demais.
O modelo ajustado pode gerar imagens de uma turma à qual pertence o sujeito do treinamento? Por exemplo, pode gerar uma imagem de um cachorro genérico?
- Observação – À medida que aumentamos o número de etapas de treinamento, o modelo começa a sofrer overfit. Com isso, esquece a classe genérica de cachorro e só produzirá imagens relacionadas ao assunto.
O modelo ajustado pode gerar imagens de uma aula ou assunto que não esteja no conjunto de dados de treinamento? Por exemplo, pode gerar a imagem de um gato?
- Observação – À medida que aumentamos o número de etapas de treinamento, o modelo começa a sofrer overfit. Como resultado, produzirá apenas imagens relacionadas ao assunto, independentemente da classe especificada.

Ajustamos o modelo para um número diferente de etapas (configurando max_steps hiperparâmetros) e para cada modelo ajustado, geramos imagens em cada um dos quatro prompts a seguir (mostrados nos seguintes exemplos da esquerda para a direita:

“Uma foto de um cão Doppler”
“Uma foto de um cachorro Doppler em uma praia”
“Uma foto de um cão”
“Uma foto de um gato”

As imagens a seguir são do modelo treinado com 50 etapas.

O modelo a seguir foi treinado com 100 passos.

Treinamos o seguinte modelo com 200 passos.

As imagens a seguir são de um modelo treinado com 400 etapas.

Por fim, as imagens a seguir são o resultado de 800 etapas.

Treine em vários conjuntos de dados

Durante o ajuste fino, você pode querer ajustar vários assuntos e fazer com que o modelo ajustado seja capaz de gerar imagens de todos os assuntos. Infelizmente, o JumpStart está atualmente limitado ao treinamento em um único assunto. Você não pode ajustar o modelo em vários assuntos ao mesmo tempo. Além disso, o ajuste fino do modelo para diferentes assuntos sequencialmente resulta no modelo esquecendo o primeiro assunto se os assuntos forem semelhantes.

Consideramos a seguinte experimentação nesta seção:

Ajuste o modelo para o Sujeito A.
Ajuste o modelo resultante da Etapa 1 para o Assunto B.
Gere imagens do Sujeito A e do Sujeito B usando o modelo de saída da Etapa 2.

Nos experimentos a seguir, observamos que:

Se A for o cachorro 1 e B for o cachorro 2, todas as imagens geradas na Etapa 3 serão semelhantes ao cachorro 2
Se A for o cachorro 2 e B for o cachorro 1, todas as imagens geradas na Etapa 3 serão semelhantes ao cachorro 1
Se A for o cachorro 1 e B for o gato, as imagens geradas com prompts de cachorro se assemelham ao cachorro 1 e as imagens geradas com prompts de gato se assemelham ao gato

Treine no cachorro 1 e depois no cachorro 2

Na Etapa 1, ajustamos o modelo para 200 etapas em oito imagens do cachorro 1. Na Etapa 2, ajustamos ainda mais o modelo para 200 etapas em quatro imagens do cachorro 2.

A seguir estão as imagens geradas pelo modelo ajustado no final da Etapa 2 para diferentes prompts.

Treine no cachorro 2 e depois no cachorro 1

Na Etapa 1, ajustamos o modelo para 200 etapas em quatro imagens do cachorro 2. Na Etapa 2, ajustamos ainda mais o modelo para 200 etapas em oito imagens do cachorro 1.

A seguir estão as imagens geradas pelo modelo ajustado no final da Etapa 2 com diferentes prompts.

Treine em cães e gatos

Na Etapa 1, ajustamos o modelo para 200 etapas em oito imagens de um gato. Em seguida, ajustamos o modelo ainda mais para 200 etapas em oito imagens do cachorro 1.

A seguir estão as imagens geradas pelo modelo de ajuste fino no final da Etapa 2. Etapa 1 do ajuste fino.

preservação prévia

A preservação prévia é uma técnica que usa imagens adicionais da mesma classe que estamos tentando treinar. Por exemplo, se os dados de treinamento consistem em imagens de um determinado cão, com preservação prévia, incorporamos imagens de classe de cães genéricos. Ele tenta evitar o overfitting mostrando imagens de diferentes cães enquanto treina para um determinado cão. Uma tag indicando o cachorro específico presente no prompt da instância está ausente no prompt da classe. Por exemplo, o prompt de instância pode ser “uma foto de um gato riobugger” e o prompt de classe pode ser “uma foto de um gato”. Você pode ativar a preservação anterior definindo o hiperparâmetro with_prior_preservation = True. Se definir with_prior_preservation = True, você deve incluir class_prompt in dataset_info.json e pode incluir qualquer imagem de classe disponível para você. O seguinte é o formato do conjunto de dados de treinamento ao definir with_prior_preservation = True:

Entrada – Um diretório contendo as imagens da instância, dataset_info.json e (opcional) diretório class_data_dir. Observe o seguinte:
- As imagens podem ser nos formatos .png, .jpg, .jpeg.
- A dataset_info.json o arquivo deve estar no formato {'instance_prompt':<<instance_prompt>>,'class_prompt':<<class_prompt>>}.
- A class_data_dir diretório deve ter imagens de classe. Se class_data_dir não está presente ou não há imagens suficientes já presentes em class_data_dir, imagens adicionais serão amostradas com class_prompt.

Para conjuntos de dados como cães e gatos, a preservação anterior não afeta significativamente o desempenho do modelo ajustado e, portanto, pode ser evitada. No entanto, ao treinar rostos, isso é necessário. Para mais informações, consulte Treinamento de difusão estável com Dreambooth usando difusores.

Tipos de instância

Os modelos de difusão estável de ajuste fino exigem computação acelerada fornecida por instâncias com suporte de GPU. Experimentamos nosso ajuste fino com as instâncias ml.g4dn.2xlarge (16 GB de memória CUDA, 1 GPU) e ml.g5.2xlarge (24 GB de memória CUDA, 1 GPU). O requisito de memória é maior ao gerar imagens de classe. Portanto, se definir with_prior_preservation=True, use o tipo de instância ml.g5.2xlarge, porque o treinamento é executado no problema de falta de memória CUDA na instância ml.g4dn.2xlarge. O script de ajuste fino do JumpStart atualmente utiliza uma única GPU e, portanto, o ajuste fino em instâncias de várias GPUs não produzirá ganho de desempenho. Para obter mais informações sobre diferentes tipos de instância, consulte Tipos de instância do Amazon EC2.

Limitações e viés

Embora a difusão estável tenha um desempenho impressionante na geração de imagens, ela sofre de várias limitações e vieses. Estes incluem, mas não estão limitados a:

O modelo pode não gerar rostos ou membros precisos porque os dados de treinamento não incluem imagens suficientes com esses recursos
O modelo foi treinado no Conjunto de dados LAION-5B, que tem conteúdo adulto e pode não ser adequado para uso do produto sem maiores considerações
O modelo pode não funcionar bem com idiomas diferentes do inglês porque o modelo foi treinado em texto em inglês
O modelo não pode gerar um bom texto nas imagens

Para obter mais informações sobre limitações e tendências, consulte Placa modelo de difusão estável v2-1-base. Essas limitações para o modelo pré-treinado também podem ser transferidas para os modelos ajustados.

limpar

Depois de concluir a execução do notebook, certifique-se de excluir todos os recursos criados no processo para garantir que a cobrança seja interrompida. O código para limpar o endpoint é fornecido no arquivo associado Introdução ao JumpStart - Texto para Imagem caderno de exemplo.

Modelos ajustados publicamente disponíveis no JumpStart

Embora os modelos de difusão estável lançados por Estabilidade IA têm um desempenho impressionante, eles têm limitações em termos de idioma ou domínio em que foram treinados. Por exemplo, os modelos Stable Diffusion foram treinados em texto em inglês, mas pode ser necessário gerar imagens de texto em outro idioma. Como alternativa, os modelos de difusão estável foram treinados para gerar imagens fotorrealistas, mas pode ser necessário gerar imagens animadas ou artísticas.

O JumpStart fornece mais de 80 modelos disponíveis publicamente com vários idiomas e temas. Esses modelos geralmente são versões ajustadas dos modelos Stable Diffusion lançados pela StabilityAI. Se seu caso de uso corresponder a um dos modelos ajustados, você não precisará coletar seu próprio conjunto de dados e ajustá-lo. Você pode simplesmente implantar um desses modelos por meio da interface do usuário do Studio ou usando APIs JumpStart fáceis de usar. Para implantar um modelo Stable Diffusion pré-treinado no JumpStart, consulte Gere imagens de texto com o modelo de difusão estável no Amazon SageMaker JumpStart.

A seguir estão alguns dos exemplos de imagens geradas pelos diferentes modelos disponíveis no JumpStart.

Observe que esses modelos não são ajustados usando scripts JumpStart ou scripts DreamBooth. Você pode baixar a lista completa de modelos ajustados publicamente disponíveis com prompts de exemplo em SUA PARTICIPAÇÃO FAZ A DIFERENÇA.

Para obter mais exemplos de imagens geradas a partir desses modelos, consulte a seção Modelos ajustados de código aberto no apêndice.

Conclusão

Nesta postagem, mostramos como ajustar o modelo Stable Diffusion para conversão de texto em imagem e, em seguida, implantá-lo usando o JumpStart. Além disso, discutimos algumas das considerações que você deve fazer ao ajustar o modelo e como isso pode afetar o desempenho do modelo ajustado. Também discutimos os mais de 80 modelos ajustados prontos para uso disponíveis no JumpStart. Mostramos trechos de código nesta postagem - para obter o código completo com todas as etapas desta demonstração, consulte o Introdução ao JumpStart - Texto para Imagem caderno de exemplo. Experimente a solução por conta própria e envie-nos seus comentários.

Para saber mais sobre o modelo e o ajuste fino do DreamBooth, consulte os seguintes recursos:

Para saber mais sobre o JumpStart, confira as seguintes postagens do blog:

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.

Heiko Hotz é Arquiteto de Soluções Sênior para IA e Machine Learning com foco especial em processamento de linguagem natural (NLP), modelos de linguagem ampla (LLMs) e IA generativa. Antes dessa função, ele foi chefe de ciência de dados para o atendimento ao cliente da Amazon na UE. Heiko ajuda nossos clientes a serem bem-sucedidos em suas jornadas de IA/ML na AWS e trabalhou com organizações em vários setores, incluindo seguros, serviços financeiros, mídia e entretenimento, saúde, serviços públicos e manufatura. Em seu tempo livre, Heiko viaja tanto quanto possível.

Apêndice: conjuntos de dados de experimentos

Esta seção contém os conjuntos de dados usados nos experimentos deste post.

Cachorro1-8

Cachorro1-16

Cachorro2-4

Cachorro3-8

Apêndice: Modelos ajustados de código aberto

A seguir estão alguns dos exemplos de imagens geradas pelos diferentes modelos disponíveis no JumpStart. Cada imagem é legendada com um model_id começando com um prefixo huggingface-txt2img- seguido pelo prompt usado para gerar a imagem na próxima linha.