min dalle

min (dall · e)

YouTube Walk-through by the Ai Epifany

Esta é uma porta rápida e mínima do Dall · E mini de Boris Dayma (com mega pesos). Foi retirado para inferência e convertido em Pytorch. As únicas dependências de terceiros são Numpy, solicitações, travesseiros e tocha.

Para gerar uma grade 3x3 de Dall · E mega imagens necessárias:

• 55 seg com um T4 em Colab
• 33 seg com um P100 em Colab
• 15 segundos com um A10G em abraçar o rosto

Aqui está uma quebra mais detalhada do desempenho em uma A100. Crédito para @Technobird22 e seu Bot Neogen Discord pelo gráfico.

O modelo e o código de linho para convertê -lo em tocha podem ser encontrados aqui.

Instalar

$ pip install min-dalle

Uso

Carregue os parâmetros do modelo uma vez e reutilize o modelo para gerar várias imagens.

 from min_dalle import MinDalle

model = MinDalle (
    models_root = './pretrained' ,
    dtype = torch . float32 ,
    device = 'cuda' ,
    is_mega = True , 
    is_reusable = True
)

Os modelos necessários serão baixados para models_root se ainda não estiverem lá. Defina o dtype como torch.float16 para salvar a memória da GPU. Se você possui uma GPU de arquitetura de ampere, pode usar torch.bfloat16 . Defina o device como "CUDA" ou "CPU". Depois que tudo terminar de inicializar, a chamada generate_image com algum texto quantas vezes quiser. Use uma seed positiva para obter resultados reprodutíveis. Valores mais altos para supercondition_factor resultam em melhor concordância com o texto, mas uma variedade mais estreita de imagens geradas. Cada token de imagem é amostrado dos tokens mais top_k . O maior logit é subtraído dos logits para evitar o INFS. As logits são então divididas pela temperature . Se is_seamless for verdadeiro, a grade da imagem será azuleada no espaço do token, não no espaço de pixels.

 image = model . generate_image (
    text = 'Nuclear explosion broccoli' ,
    seed = - 1 ,
    grid_size = 4 ,
    is_seamless = False ,
    temperature = 1 ,
    top_k = 256 ,
    supercondition_factor = 32 ,
    is_verbose = False
)

display ( image )

Crédito a @hardmaru pelo exemplo

Salvando imagens individuais

As imagens também podem ser geradas como um FloatTensor , caso você queira processá -las manualmente.

 images = model . generate_images (
    text = 'Nuclear explosion broccoli' ,
    seed = - 1 ,
    grid_size = 3 ,
    is_seamless = False ,
    temperature = 1 ,
    top_k = 256 ,
    supercondition_factor = 16 ,
    is_verbose = False
)

Para obter uma imagem no formato PIL, você precisará primeiro mover as imagens para a CPU e converter o tensor em uma matriz Numpy.

 images = images . to ( 'cpu' ). numpy ()

Então imagem $ i $ pode ser coberto para um pil.image e salvo

 image = Image . fromarray ( images [ i ])
image . save ( 'image_{}.png' . format ( i ))

Saídas progressivas

Se o modelo estiver sendo usado de forma interativa (por exemplo, em um notebook) generate_image_stream , poderá ser usado para gerar um fluxo de imagens à medida que o modelo está decodificando. O detokenizador adiciona um pequeno atraso para cada imagem. Defina progressive_outputs como True para ativar isso. Um exemplo é implementado no COLAB.

 image_stream = model . generate_image_stream (
    text = 'Dali painting of WALL·E' ,
    seed = - 1 ,
    grid_size = 3 ,
    progressive_outputs = True ,
    is_seamless = False ,
    temperature = 1 ,
    top_k = 256 ,
    supercondition_factor = 16 ,
    is_verbose = False
)

for image in image_stream :
    display ( image )

Linha de comando

Use image_from_text.py para gerar imagens na linha de comando.

$ python image_from_text.py --text= ' artificial intelligence ' --no-mega