A instância DL2q do Amazon EC2 para inferência de IA econômica e de alto desempenho já está disponível para todos | Amazon Web Services

Este é um post convidado de AK Roy da Qualcomm AI.

Amazon Elastic Compute Cloud (Amazon EC2) As instâncias DL2q, alimentadas por aceleradores Qualcomm AI 100 Standard, podem ser usadas para implantar cargas de trabalho de aprendizagem profunda (DL) de maneira econômica na nuvem. Eles também podem ser usados ​​para desenvolver e validar o desempenho e a precisão das cargas de trabalho de DL que serão implantadas em dispositivos Qualcomm. As instâncias DL2q são as primeiras a levar a tecnologia de inteligência artificial (IA) da Qualcomm para a nuvem.

Com oito aceleradores Qualcomm AI 100 Standard e 128 GiB de memória total do acelerador, os clientes também podem usar instâncias DL2q para executar aplicativos populares de IA generativos, como geração de conteúdo, resumo de texto e assistentes virtuais, bem como aplicativos clássicos de IA para processamento de linguagem natural. e visão computacional. Além disso, os aceleradores Qualcomm AI 100 apresentam a mesma tecnologia de IA usada em smartphones, direção autônoma, computadores pessoais e headsets de realidade estendida, para que as instâncias DL2q possam ser usadas para desenvolver e validar essas cargas de trabalho de IA antes da implantação.

Novos destaques da instância DL2q

Cada instância DL2q incorpora oito aceleradores Qualcomm Cloud AI100, com um desempenho agregado de mais de 2.8 PetaOps de desempenho de inferência Int8 e 1.4 PetaFlops de desempenho de inferência FP16. A instância tem um total de 112 núcleos de IA, capacidade de memória do acelerador de 128 GB e largura de banda de memória de 1.1 TB por segundo.

Cada instância DL2q possui 96 vCPUs, capacidade de memória do sistema de 768 GB e suporta largura de banda de rede de 100 Gbps, bem como Amazon Elastic Block Store (Amazon EBS) armazenamento de 19 Gbps.

Inovação do acelerador Qualcomm Cloud AI100

O acelerador System-on-chip (SoC) Cloud AI100 é uma arquitetura multinúcleo escalonável e desenvolvida especificamente, que oferece suporte a uma ampla variedade de casos de uso de aprendizagem profunda, abrangendo do datacenter até a borda. O SoC emprega núcleos de computação escalar, vetorial e tensor com capacidade SRAM on-die líder do setor de 126 MB. Os núcleos são interconectados com uma malha de rede no chip (NoC) de alta largura de banda e baixa latência.

O acelerador AI100 oferece suporte a uma ampla e abrangente gama de modelos e casos de uso. A tabela abaixo destaca a gama de suporte do modelo.

* A maioria das redes automotivas são redes compostas que consistem em uma fusão de redes individuais.

A grande SRAM on-die no acelerador DL2q permite a implementação eficiente de técnicas avançadas de desempenho, como a precisão do micro-expoente MX6 para armazenar os pesos e a precisão do micro-expoente MX9 para comunicação entre aceleradores. A tecnologia de micro-expoente é descrita no seguinte anúncio da indústria do Open Compute Project (OCP): AMD, Arm, Intel, Meta, Microsoft, NVIDIA e Qualcomm padronizam formatos de dados de precisão estreita de última geração para IA » Open Compute Project.

O usuário da instância pode usar a seguinte estratégia para maximizar o desempenho por custo:

• Armazene pesos usando a precisão do micro-expoente MX6 na memória DDR no acelerador. Usar a precisão do MX6 maximiza a utilização da capacidade de memória disponível e da largura de banda da memória para fornecer o melhor rendimento e latência da categoria.
• Calcule em FP16 para fornecer a precisão de caso de uso necessária, enquanto usa SRAM superior no chip e TOPs sobressalentes na placa, para implementar kernels MX6 a FP16 de alto desempenho e baixa latência.
• Use uma estratégia de lote otimizada e um tamanho de lote maior usando a grande SRAM no chip disponível para maximizar a reutilização de pesos, enquanto retém as ativações no chip ao máximo possível.

Pilha e conjunto de ferramentas DL2q AI

A instância DL2q é acompanhada pelo Qualcomm AI Stack, que oferece uma experiência consistente ao desenvolvedor em toda a Qualcomm AI na nuvem e em outros produtos da Qualcomm. A mesma pilha de IA da Qualcomm e a mesma tecnologia de IA básica são executadas nas instâncias DL2q e nos dispositivos de borda da Qualcomm, proporcionando aos clientes uma experiência de desenvolvedor consistente, com uma API unificada em seus ambientes de desenvolvimento de nuvem, automotivo, computador pessoal, realidade estendida e smartphones.

A cadeia de ferramentas permite que o usuário da instância integre rapidamente um modelo previamente treinado, compile e otimize o modelo para os recursos da instância e, posteriormente, implante os modelos compilados para casos de uso de inferência de produção em três etapas mostradas na figura a seguir.

Para saber mais sobre como ajustar o desempenho de um modelo, consulte o Parâmetros principais de desempenho do Cloud AI 100 Documentação.

Comece a usar instâncias DL2q

Neste exemplo, você compila e implanta um aplicativo pré-treinado Modelo BERT da Abraçando o rosto em uma instância DL2q do EC2 usando uma AMI DL2q disponível pré-construída, em quatro etapas.

Você pode usar um pré-construído DLAMI da Qualcomm na instância ou comece com uma Amazon Linux2 AMI e crie sua própria AMI DL2q com a plataforma Cloud AI 100 e o SDK de aplicativos disponíveis neste Serviço de armazenamento simples da Amazon (Amazon S3) balde: s3://ec2-linux-qualcomm-ai100-sdks/latest/.

As etapas a seguir usam a AMI DL2q pré-construída, Base AL2 DLAMI da Qualcomm.

Use SSH para acessar sua instância DL2q com o Qualcomm Base AL2 DLAMI AMI e siga as etapas 1 a 4.

Etapa 1. Configure o ambiente e instale os pacotes necessários

1. Instale o Python 3.8.

   sudo amazon-linux-extras install python3.8

2. Configure o ambiente virtual do Python 3.8.

   python3.8 -m venv /home/ec2-user/userA/pyenv

3. Ative o ambiente virtual Python 3.8.

   source /home/ec2-user/userA/pyenv/bin/activate

4. Instale os pacotes necessários, mostrados na documento requisitos.txt disponível no site público da Qualcomm no Github.

   pip3 install -r requirements.txt

5. Importe as bibliotecas necessárias.

   import transformers from transformers import AutoTokenizer, AutoModelForMaskedLM
   import sys
   import qaic
   import os
   import torch
   import onnx
   from onnxsim import simplify
   import argparse
   import numpy as np

Passo 2. Importe o modelo

1. Importe e tokenize o modelo.

   model_card = 'bert-base-cased'
   model = AutoModelForMaskedLM.from_pretrained(model_card)
   tokenizer = AutoTokenizer.from_pretrained(model_card)

2. Defina uma entrada de amostra e extraia o inputIds e attentionMask.

   sentence = "The dog [MASK] on the mat."
   encodings = tokenizer(sentence, max_length=128, truncation=True, padding="max_length", return_tensors='pt')
   inputIds = encodings["input_ids"]
   attentionMask = encodings["attention_mask"]

3. Converta o modelo em ONNX, que pode então ser passado para o compilador.

   # Set dynamic dims and axes.
   dynamic_dims = {0: 'batch', 1 : 'sequence'}
   dynamic_axes = { "input_ids" : dynamic_dims, "attention_mask" : dynamic_dims, "logits" : dynamic_dims
   }
   input_names = ["input_ids", "attention_mask"]
   inputList = [inputIds, attentionMask] torch.onnx.export( model, args=tuple(inputList), f=f"{gen_models_path}/{model_base_name}.onnx", verbose=False, input_names=input_names, output_names=["logits"], dynamic_axes=dynamic_axes, opset_version=11,
   )

4. Você executará o modelo com precisão FP16. Portanto, você precisa verificar se o modelo contém alguma constante além da faixa FP16. Passe o modelo para o fix_onnx_fp16 função para gerar o novo arquivo ONNX com as correções necessárias.

   from onnx import numpy_helper def fix_onnx_fp16( gen_models_path: str, model_base_name: str,
   ) -> str: finfo = np.finfo(np.float16) fp16_max = finfo.max fp16_min = finfo.min model = onnx.load(f"{gen_models_path}/{model_base_name}.onnx") fp16_fix = False for tensor in onnx.external_data_helper._get_all_tensors(model): nptensor = numpy_helper.to_array(tensor, gen_models_path) if nptensor.dtype == np.float32 and ( np.any(nptensor > fp16_max) or np.any(nptensor < fp16_min) ): # print(f'tensor value : {nptensor} above {fp16_max} or below {fp16_min}') nptensor = np.clip(nptensor, fp16_min, fp16_max) new_tensor = numpy_helper.from_array(nptensor, tensor.name) tensor.CopyFrom(new_tensor) fp16_fix = True if fp16_fix: # Save FP16 model print("Found constants out of FP16 range, clipped to FP16 range") model_base_name += "_fix_outofrange_fp16" onnx.save(model, f=f"{gen_models_path}/{model_base_name}.onnx") print(f"Saving modified onnx file at {gen_models_path}/{model_base_name}.onnx") return model_base_name fp16_model_name = fix_onnx_fp16(gen_models_path=gen_models_path, model_base_name=model_base_name)

Passo 3. Compilar o modelo

A qaic-exec A ferramenta de compilação da interface de linha de comando (CLI) é usada para compilar o modelo. A entrada para este compilador é o arquivo ONNX gerado na etapa 2. O compilador produz um arquivo binário (chamado QPC, Por Contêiner do programa Qualcomm) no caminho definido por -aic-binary-dir argumento.

No comando de compilação abaixo, você usa quatro núcleos de computação de IA e um tamanho de lote de um para compilar o modelo.

/opt/qti-aic/exec/qaic-exec -m=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16.onnx -aic-num-cores=4 -convert-to-fp16 -onnx-define-symbol=batch,1 -onnx-define-symbol=sequence,128 -aic-binary-dir=bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc -aic-hw -aic-hw-version=2.0 -compile-only

O QPC é gerado no bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc pasta.

Passo 4. Execute o modelo

Configure uma sessão para executar a inferência em um acelerador Cloud AI100 Qualcomm na instância DL2q.

A biblioteca Qaic Python da Qualcomm é um conjunto de APIs que fornece suporte para execução de inferência no acelerador Cloud AI100.

1. Use a chamada da API Session para criar uma instância de sessão. A chamada da API Session é o ponto de entrada para usar a biblioteca qaic Python.

   qpcPath = 'bert-base-cased/generatedModels/bert-base-cased_fix_outofrange_fp16_qpc' bert_sess = qaic.Session(model_path= qpcPath+'/programqpc.bin', num_activations=1) bert_sess.setup() # Loads the network to the device. # Here we are reading out all the input and output shapes/types
   input_shape, input_type = bert_sess.model_input_shape_dict['input_ids']
   attn_shape, attn_type = bert_sess.model_input_shape_dict['attention_mask']
   output_shape, output_type = bert_sess.model_output_shape_dict['logits'] #create the input dictionary for given input sentence
   input_dict = {"input_ids": inputIds.numpy().astype(input_type), "attention_mask" : attentionMask.numpy().astype(attn_type)} #run inference on Cloud AI 100
   output = bert_sess.run(input_dict)

2. Reestruture os dados do buffer de saída com output_shape e output_type.

   token_logits = np.frombuffer(output['logits'], dtype=output_type).reshape(output_shape)

3. Decodifique a saída produzida.

   mask_token_logits = torch.from_numpy(token_logits[0, mask_token_index, :]).unsqueeze(0)
   top_5_results = torch.topk(mask_token_logits, 5, dim=1)
   print("Model output (top5) from Qualcomm Cloud AI 100:")
   for i in range(5): idx = top_5_results.indices[0].tolist()[i] val = top_5_results.values[0].tolist()[i] word = tokenizer.decode([idx]) print(f"{i+1} :(word={word}, index={idx}, logit={round(val,2)})")

Aqui estão os resultados para a frase de entrada “O cachorro [MÁSCARA] no tapete”.

1 :(word=sat, index=2068, logit=11.46)
2 :(word=landed, index=4860, logit=11.11)
3 :(word=spat, index=15732, logit=10.95)
4 :(word=settled, index=3035, logit=10.84)
5 :(word=was, index=1108, logit=10.75)

É isso. Com apenas algumas etapas, você compilou e executou um modelo PyTorch em uma instância DL2q do Amazon EC2. Para saber mais sobre integração e compilação de modelos na instância DL2q, consulte o Documentação do tutorial do Cloud AI100.

Para saber mais sobre quais arquiteturas de modelo DL são adequadas para instâncias AWS DL2q e a matriz de suporte de modelo atual, consulte o Documentação do Qualcomm Cloud AI100.

Disponível agora

Você pode executar instâncias DL2q hoje mesmo nas regiões da AWS Oeste dos EUA (Oregon) e Europa (Frankfurt) como Sob demanda, Reservado e Instâncias Spot, ou como parte de um Plano de Poupança. Como de costume no Amazon EC2, você paga apenas pelo que usa. Para mais informações, veja Preços do Amazon EC2.

As instâncias DL2q podem ser implementadas usando AMIs de aprendizado profundo da AWS (DLAMI)e as imagens de contêiner estão disponíveis por meio de serviços gerenciados, como Amazon Sage Maker, Serviço Amazon Elastic Kubernetes (Amazon EKS), Amazon Elastic Container Service (Amazon ECS) e AWS ParallelCluster.

Para saber mais, visite o Instância DL2q do Amazon EC2 página e envie comentários para AWS re:Post para EC2 ou por meio de seus contatos habituais do AWS Support.

Sobre os autores

AK Roy é diretor de gerenciamento de produtos da Qualcomm, para produtos e soluções de IA em nuvem e datacenter. Ele tem mais de 20 anos de experiência em estratégia e desenvolvimento de produtos, com o foco atual no melhor desempenho e desempenho/$ soluções ponta a ponta para inferência de IA na nuvem, para uma ampla gama de casos de uso, incluindo GenAI, LLMs, IA automática e híbrida.

Jianying Lang é arquiteto de soluções principal na AWS Worldwide Specialist Organization (WWSO). Ela tem mais de 15 anos de experiência profissional na área de HPC e IA. Na AWS, ela se concentra em ajudar os clientes a implantar, otimizar e dimensionar suas cargas de trabalho de IA/ML em instâncias de computação aceleradas. Ela é apaixonada por combinar técnicas nas áreas de HPC e IA. Jianying possui doutorado em Física Computacional pela Universidade do Colorado em Boulder.

• 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/amazon-ec2-dl2q-instance-for-cost-efficient-high-performance-ai-inference-is-now-generally-available/