Ao implantar modelos de Deep Learning em escala, é crucial utilizar efetivamente o hardware subjacente para maximizar o desempenho e os benefícios de custo. Para cargas de trabalho de produção que exigem alto rendimento e baixa latência, a seleção do Amazon Elastic Compute Nuvem (EC2), pilha de serviço de modelo e arquitetura de implantação são muito importantes. Uma arquitetura ineficiente pode levar a uma utilização abaixo do ideal dos aceleradores e a custos de produção desnecessariamente elevados.
Nesta postagem, orientamos você no processo de implantação de servidores modelo FastAPI em dispositivos AWS Inferentia (encontrados no Amazon EC2 Inf1 e Amazon CE Inf2 instâncias). Também demonstramos a hospedagem de um modelo de amostra que é implantado em paralelo em todos os NeuronCores para máxima utilização de hardware.
Visão geral da solução
FastAPI é uma estrutura web de código aberto para atender aplicativos Python que é muito mais rápida do que estruturas tradicionais como Flask e Django. Ele utiliza um Interface de gateway de servidor assíncrono (ASGI) em vez do amplamente utilizado Interface de gateway do servidor da Web (WSGI). ASGI processa solicitações recebidas de forma assíncrona, em oposição ao WSGI, que processa solicitações sequencialmente. Isso torna o FastAPI a escolha ideal para lidar com solicitações sensíveis à latência. Você pode usar FastAPI para implantar um servidor que hospeda um endpoint em instâncias do Inferentia (Inf1/Inf2) que escuta solicitações do cliente por meio de uma porta designada.
Nosso objetivo é alcançar o mais alto desempenho com o menor custo através da utilização máxima do hardware. Isso nos permite lidar com mais solicitações de inferência com menos aceleradores. Cada dispositivo AWS Inferentia1 contém quatro NeuronCores-v1 e cada dispositivo AWS Inferentia2 contém dois NeuronCores-v2. O Neurônio AWS O SDK nos permite utilizar cada um dos NeuronCores em paralelo, o que nos dá mais controle no carregamento e inferência de quatro ou mais modelos em paralelo sem sacrificar o rendimento.
Com FastAPI, você pode escolher o servidor web Python (gunicórnio, Uvicórnio, Hipercórnio, Ninfa). Esses servidores da web fornecem uma camada de abstração sobre o modelo subjacente de aprendizado de máquina (ML). O cliente solicitante tem a vantagem de não ter conhecimento do modelo hospedado. Um cliente não precisa saber o nome ou a versão do modelo que foi implantado no servidor; o nome do endpoint agora é apenas um proxy para uma função que carrega e executa o modelo. Por outro lado, em uma ferramenta de serviço específica da estrutura, como o TensorFlow Serving, o nome e a versão do modelo fazem parte do nome do endpoint. Se o modelo mudar no lado do servidor, o cliente deverá saber e alterar sua chamada de API para o novo endpoint de acordo. Portanto, se você estiver evoluindo continuamente os modelos de versão, como no caso de testes A/B, usar um servidor web Python genérico com FastAPI é uma maneira conveniente de servir modelos, porque o nome do endpoint é estático.
A função de um servidor ASGI é gerar um número específico de trabalhadores que escutam as solicitações do cliente e executam o código de inferência. Uma capacidade importante do servidor é garantir que o número solicitado de trabalhadores esteja disponível e ativo. Caso um trabalhador seja eliminado, o servidor deverá lançar um novo trabalhador. Neste contexto, o servidor e os trabalhadores podem ser identificados pelo seu ID de processo Unix (PID). Para esta postagem, usamos um Hipercórnio server, que é uma escolha popular para servidores web Python.
Nesta postagem, compartilhamos as melhores práticas para implantar modelos de aprendizagem profunda com FastAPI no AWS Inferentia NeuronCores. Mostramos que você pode implantar vários modelos em NeuronCores separados que podem ser chamados simultaneamente. Essa configuração aumenta o rendimento porque vários modelos podem ser inferidos simultaneamente e a utilização do NeuronCore é totalmente otimizada. O código pode ser encontrado no GitHub repo. A figura a seguir mostra a arquitetura de como configurar a solução em uma instância EC2 Inf2.
A mesma arquitetura se aplica a um tipo de instância EC2 Inf1, exceto que possui quatro núcleos. Então isso muda um pouco o diagrama da arquitetura.
AWS Inferentia NeuronCores
Vamos nos aprofundar um pouco mais nas ferramentas fornecidas pelo AWS Neuron para interagir com o NeuronCores. As tabelas a seguir mostram o número de NeuronCores em cada tipo de instância Inf1 e Inf2. As vCPUs host e a memória do sistema são compartilhadas entre todos os NeuronCores disponíveis.
Tamanho da instância | # Aceleradores Inferentia | # NeuronCores-v1 | vCPUs | Memória (GiB) |
Inf1.xgrande | 1 | 4 | 4 | 8 |
Inf1.2xgrande | 1 | 4 | 8 | 16 |
Inf1.6xgrande | 4 | 16 | 24 | 48 |
Inf1.24xgrande | 16 | 64 | 96 | 192 |
Tamanho da instância | # Aceleradores Inferentia | # NeuronCores-v2 | vCPUs | Memória (GiB) |
Inf2.xgrande | 1 | 2 | 4 | 32 |
Inf2.8xgrande | 1 | 2 | 32 | 32 |
Inf2.24xgrande | 6 | 12 | 96 | 192 |
Inf2.48xgrande | 12 | 24 | 192 | 384 |
As instâncias Inf2 contêm o novo NeuronCores-v2 em comparação com o NeuronCore-v1 nas instâncias Inf1. Apesar de menos núcleos, eles são capazes de oferecer taxa de transferência 4x maior e latência 10x menor do que as instâncias Inf1. As instâncias Inf2 são ideais para cargas de trabalho de Deep Learning, como IA generativa, Large Language Models (LLM) na família OPT/GPT e transformadores de visão como Stable Diffusion.
O Neuron Runtime é responsável por executar modelos em dispositivos Neuron. O Neuron Runtime determina qual NeuronCore executará qual modelo e como executá-lo. A configuração do Neuron Runtime é controlada pelo uso de variáveis ambientais no nível do processo. Por padrão, as extensões da estrutura do Neuron cuidarão da configuração do Neuron Runtime em nome do usuário; entretanto, configurações explícitas também são possíveis para obter um comportamento mais otimizado.
Duas variáveis de ambiente populares são NEURON_RT_NUM_CORES
e NEURON_RT_VISIBLE_CORES
. Com essas variáveis de ambiente, os processos Python podem ser vinculados a um NeuronCore. Com NEURON_RT_NUM_CORES
, um número especificado de núcleos pode ser reservado para um processo, e com NEURON_RT_VISIBLE_CORES
, uma variedade de NeuronCores pode ser reservada. Por exemplo, NEURON_RT_NUM_CORES=2 myapp.py
reservará dois núcleos e NEURON_RT_VISIBLE_CORES=’0-2’ myapp.py
reservará zero, um e dois núcleos para myapp.py
. Você também pode reservar NeuronCores entre dispositivos (chips AWS Inferentia). Então, NEURON_RT_VISIBLE_CORES=’0-5’ myapp.py
reservará os primeiros quatro núcleos em device1
e um núcleo em device2
em um tipo de instância Ec2 Inf1. Da mesma forma, em um tipo de instância EC2 Inf2, esta configuração reservará dois núcleos em device1
e device2
e um núcleo em device3
. A tabela a seguir resume a configuração dessas variáveis.
Nome | Descrição | Formato | Valores Esperados | Valor padrão | Versão RT |
NEURON_RT_VISIBLE_CORES |
Gama de NeuronCores específicos necessários ao processo | Intervalo inteiro (como 1-3) | Qualquer valor ou intervalo entre 0 e Max NeuronCore no sistema | nenhum | 2.0+ |
NEURON_RT_NUM_CORES |
Número de NeuronCores exigidos pelo processo | Número inteiro | Um valor de 1 a Max NeuronCore no sistema | 0, que é interpretado como “todos” | 2.0+ |
Para obter uma lista de todas as variáveis de ambiente, consulte Configuração do tempo de execução do Neuron.
Por padrão, ao carregar modelos, os modelos são carregados no NeuronCore 0 e depois no NeuronCore 1, a menos que seja explicitamente declarado pelas variáveis de ambiente anteriores. Conforme especificado anteriormente, os NeuronCores compartilham as vCPUs de host disponíveis e a memória do sistema. Portanto, os modelos implantados em cada NeuronCore competirão pelos recursos disponíveis. Isso não será um problema se o modelo estiver utilizando amplamente os NeuronCores. Mas se um modelo estiver sendo executado apenas parcialmente nos NeuronCores e o restante nas vCPUs host, considerar a disponibilidade da CPU por NeuronCore torna-se importante. Isso também afeta a escolha da instância.
A tabela a seguir mostra o número de vCPUs de host e a memória do sistema disponível por modelo se um modelo tiver sido implantado em cada NeuronCore. Dependendo do uso do NeuronCore, da vCPU e do uso de memória do seu aplicativo, é recomendável executar testes para descobrir qual configuração tem melhor desempenho para o seu aplicativo. O Ferramenta Neuron Top pode ajudar na visualização da utilização do núcleo e da utilização da memória do dispositivo e do host. Com base nessas métricas, uma decisão informada pode ser tomada. Demonstramos o uso do Neuron Top no final deste blog.
Tamanho da instância | # Aceleradores Inferentia | # Modelos | vCPUs/modelo | Memória/Modelo (GiB) |
Inf1.xgrande | 1 | 4 | 1 | 2 |
Inf1.2xgrande | 1 | 4 | 2 | 4 |
Inf1.6xgrande | 4 | 16 | 1.5 | 3 |
Inf1.24xgrande | 16 | 64 | 1.5 | 3 |
Tamanho da instância | # Aceleradores Inferentia | # Modelos | vCPUs/modelo | Memória/Modelo (GiB) |
Inf2.xgrande | 1 | 2 | 2 | 8 |
Inf2.8xgrande | 1 | 2 | 16 | 64 |
Inf2.24xgrande | 6 | 12 | 8 | 32 |
Inf2.48xgrande | 12 | 24 | 8 | 32 |
Para testar os recursos do Neuron SDK por conta própria, verifique as últimas Capacidades de neurônios para PyTorch.
Configuração do sistema
A seguir está a configuração do sistema usada para esta solução:
Configure a solução
Há algumas coisas que precisamos fazer para configurar a solução. Comece criando uma função IAM que sua instância do EC2 assumirá e que permitirá fazer push e pull de Registro do Amazon Elastic Container.
Etapa 1: configurar a função do IAM
- Comece fazendo login no console e acessando IAM > Roles > Create Role
- Selecione o tipo de entidade confiável
AWS Service
- Selecione EC2 como o serviço no caso de uso
- Clique Próximo e você poderá ver todas as políticas disponíveis
- Para efeitos desta solução, daremos à nossa instância EC2 acesso total ao ECR. Filtrar por AmazonEC2ContainerRegistryFullAccess e selecione-o.
- Pressione próximo e nomeie a função
inf-ecr-access
Observação: a política que anexamos dá à instância do EC2 acesso total ao Amazon ECR. Recomendamos fortemente seguir as princípio do menor privilégio para cargas de trabalho de produção.
Etapa 2: configurar AWS CLI
Se você estiver usando o Deep Learning AMI prescrito listado acima, ele vem com o AWS CLI instalado. Se você estiver usando uma AMI diferente (Amazon Linux 2023, Base Ubuntu etc.), instale as ferramentas CLI seguindo este guia.
Depois de instalar as ferramentas CLI, configure a CLI usando o comando aws configure
. Se você tiver chaves de acesso, poderá adicioná-las aqui, mas não necessariamente precisará delas para interagir com os serviços da AWS. Contamos com funções do IAM para fazer isso.
Note: Precisamos inserir pelo menos um valor (região padrão ou formato padrão) para criar o perfil padrão. Para este exemplo, vamos com us-east-2
como a região e json
como saída padrão.
Clone o repositório do Github
A GitHub repo fornece todos os scripts necessários para implantar modelos usando FastAPI em NeuronCores em instâncias AWS Inferentia. Este exemplo usa contêineres Docker para garantir que possamos criar soluções reutilizáveis. Incluído neste exemplo está o seguinte config.properties arquivo para os usuários fornecerem entradas.
O arquivo de configuração precisa de prefixos de nome definidos pelo usuário para a imagem do Docker e os contêineres do Docker. O build.sh
script no fastapi
e trace-model
pastas usam isso para criar imagens Docker.
Compile um modelo no AWS Inferentia
Começaremos traçando o modelo e produzindo um arquivo PyTorch Torchscript .pt. Comece acessando trace-model
diretório e modificando o arquivo .env. Dependendo do tipo de instância que você escolheu, modifique o CHIP_TYPE
dentro do .env
arquivo. Como exemplo, escolheremos Inf2 como guia. As mesmas etapas se aplicam ao processo de implantação do Inf1.
Em seguida, defina a região padrão no mesmo arquivo. Esta região será usada para criar um repositório ECR e as imagens Docker serão enviadas para este repositório. Também nesta pasta disponibilizamos todos os scripts necessários para rastrear um bert-base-uncased
modelo no AWS Inferentia. Este script pode ser usado para a maioria dos modelos disponíveis em Abraçando o rosto. O dockerfile tem todas as dependências para executar modelos com Neuron e executa o trace-model.py código como ponto de entrada.
Compilação de neurônios explicada
A API do Neuron SDK se assemelha muito à API PyTorch Python. O torch.jit.trace()
do PyTorch usa o modelo e o tensor de entrada de amostra como argumentos. As entradas de amostra são alimentadas no modelo e as operações que são invocadas à medida que essa entrada percorre as camadas do modelo são registradas como TorchScriptName. Para saber mais sobre o rastreamento JIT no PyTorch, consulte o seguinte documentação.
Assim como torch.jit.trace()
, você pode verificar se seu modelo pode ser compilado no AWS Inferentia com o código a seguir para instâncias inf1.
Para inf2, a biblioteca é chamada torch_neuronx
. Veja como você pode testar a compilação do seu modelo em instâncias inf2.
Depois de criar a instância de rastreamento, podemos passar a entrada do tensor de exemplo assim:
E, finalmente, salve a saída resultante do TorchScript no disco local
Conforme mostrado no código anterior, você pode usar compiler_args
e optimizations
para otimizar a implantação. Para uma lista detalhada de argumentos para o torch.neuron.trace
API, consulte API python de rastreamento PyTorch-Neuron.
Tenha em mente os seguintes pontos importantes:
- O Neuron SDK não oferece suporte a formas de tensor dinâmico no momento em que este livro foi escrito. Portanto, um modelo deverá ser compilado separadamente para diferentes formatos de entrada. Para obter mais informações sobre como executar inferência em formas de entrada variáveis com bucketing, consulte Executando inferência em formas de entrada variáveis com bucketing.
- Se você enfrentar problemas de falta de memória ao compilar um modelo, tente compilar o modelo em uma instância do AWS Inferentia com mais vCPUs ou memória, ou até mesmo em uma instância grande c6i ou r6i, pois a compilação usa apenas CPUs. Depois de compilado, o modelo rastreado provavelmente poderá ser executado em instâncias menores do AWS Inferentia.
Explicação do processo de construção
Agora vamos construir este contêiner executando construir.sh. O arquivo de script de construção simplesmente cria a imagem Docker puxando uma imagem base do Deep Learning Container e instalando o HuggingFace transformers
pacote. Com base no CHIP_TYPE
especificado no .env
arquivo, o docker.properties
arquivo decide o apropriado BASE_IMAGE
. Este BASE_IMAGE
aponta para uma imagem de contêiner de aprendizado profundo para Neuron Runtime fornecida pela AWS.
Está disponível através de um repositório ECR privado. Antes de podermos extrair a imagem, precisamos fazer login e obter credenciais temporárias da AWS.
Note: precisamos substituir a região listada no comando especificado pelo sinalizador de região e dentro do URI do repositório pela região que colocamos no .env arquivo.
Para facilitar esse processo, podemos usar o fetch-credentials.sh
arquivo. A região será retirada do arquivo .env automaticamente.
A seguir, enviaremos a imagem usando o script empurrar.sh. O script push cria um repositório no Amazon ECR para você e envia a imagem do contêiner.
Finalmente, quando a imagem é construída e enviada por push, podemos executá-la como um contêiner executando correr.sh e registros de execução final com logs.sh. Nos logs do compilador (veja a captura de tela a seguir), você verá a porcentagem de operadores aritméticos compilados no Neuron e a porcentagem de subgráficos do modelo compilados com sucesso no Neuron. A captura de tela mostra os logs do compilador para o bert-base-uncased-squad2
modelo. Os logs mostram que 95.64% dos operadores aritméticos foram compilados e também fornecem uma lista dos operadores que foram compilados no Neuron e daqueles que não são suportados.
Aqui está uma lista de todos os operadores suportados no pacote PyTorch Neuron mais recente. De forma similar, aqui está a lista de todos os operadores suportados no pacote PyTorch Neuronx mais recente.
Implantar modelos com FastAPI
Depois que os modelos forem compilados, o modelo rastreado estará presente no trace-model
pasta. Neste exemplo, colocamos o modelo rastreado para um tamanho de lote 1. Consideramos um tamanho de lote 1 aqui para levar em conta os casos de uso em que um tamanho de lote maior não é viável ou necessário. Para casos de uso em que são necessários tamanhos de lote maiores, o tocha.neuron.DataParallel (para Inf1) ou tocha.neuronx.DataParallel (para Inf2) API também pode ser útil.
A API rápida pasta fornece todos os scripts necessários para implantar modelos com FastAPI. Para implantar os modelos sem nenhuma alteração, basta executar o implantar.sh script e criará uma imagem de contêiner FastAPI, executará contêineres no número especificado de núcleos e implantará o número especificado de modelos por servidor em cada servidor de modelo FastAPI. Esta pasta também contém um .env
arquivo, modifique-o para refletir o correto CHIP_TYPE
e AWS_DEFAULT_REGION
.
Note: os scripts FastAPI dependem das mesmas variáveis de ambiente usadas para criar, enviar por push e executar as imagens como contêineres. Os scripts de implantação FastAPI usarão os últimos valores conhecidos dessas variáveis. Portanto, se você rastreou o modelo para o tipo de instância Inf1 por último, esse modelo será implantado por meio desses scripts.
A fastapi-server.py arquivo responsável por hospedar o servidor e enviar as solicitações ao modelo faz o seguinte:
- Lê o número de modelos por servidor e a localização do modelo compilado no arquivo de propriedades
- Define NeuronCores visíveis como variáveis de ambiente para o contêiner Docker e lê as variáveis de ambiente para especificar quais NeuronCores usar
- Fornece uma API de inferência para o
bert-base-uncased-squad2
modelo - Com o
jit.load()
, carrega o número de modelos por servidor conforme especificado na configuração e armazena os modelos e os tokenizers necessários em dicionários globais
Com esta configuração, seria relativamente fácil configurar APIs que listem quais modelos e quantos modelos estão armazenados em cada NeuronCore. Da mesma forma, APIs poderiam ser escritas para excluir modelos de NeuronCores específicos.
A dockerfile para construir contêineres FastAPI é construído na imagem Docker que construímos para rastrear os modelos. É por isso que docker.properties file especifica o caminho ECR para a imagem Docker para rastrear os modelos. Em nossa configuração, os contêineres Docker em todos os NeuronCores são semelhantes, portanto, podemos construir uma imagem e executar vários contêineres a partir de uma imagem. Para evitar erros de ponto de entrada, especificamos ENTRYPOINT ["/usr/bin/env"]
no Dockerfile antes de executar o startup.sh
roteiro, que parece hypercorn fastapi-server:app -b 0.0.0.0:8080
. Este script de inicialização é o mesmo para todos os contêineres. Se você estiver usando a mesma imagem base dos modelos de rastreamento, poderá criar esse contêiner simplesmente executando o script build.sh. O push.sh
O script permanece o mesmo de antes para modelos de rastreamento. A imagem modificada do Docker e o nome do contêiner são fornecidos pelo docker.properties
arquivo.
A run.sh file
faz o seguinte:
- Lê a imagem do Docker e o nome do contêiner do Propriedades arquivo, que por sua vez lê o
config.properties
arquivo, que possui umnum_cores
configuração do usuário - Inicia um loop de 0 a
num_cores
e para cada núcleo:- Define o número da porta e o número do dispositivo
- Define o
NEURON_RT_VISIBLE_CORES
variável de ambiente - Especifica a montagem do volume
- Executa um contêiner Docker
Para maior clareza, o comando de execução do Docker para implantação no NeuronCore 0 para Inf1 seria semelhante ao seguinte código:
O comando run para implantação no NeuronCore 5 seria semelhante ao seguinte código:
Depois que os contêineres são implantados, usamos o run_apis.py script, que chama as APIs em threads paralelos. O código está configurado para chamar seis modelos implantados, um em cada NeuronCore, mas pode ser facilmente alterado para uma configuração diferente. Chamamos as APIs do lado do cliente da seguinte forma:
Monitorar NeuronCore
Após a implantação dos servidores modelo, para monitorar a utilização do NeuronCore, podemos usar neuron-top
observar em tempo real o percentual de utilização de cada NeuronCore. topo do neurônio é uma ferramenta CLI no Neuron SDK para fornecer informações como NeuronCore, vCPU e utilização de memória. Em um terminal separado, digite o seguinte comando:
Sua saída deve ser semelhante à figura a seguir. Neste cenário, especificamos o uso de dois NeuronCores e dois modelos por servidor em uma instância Inf2.xlarge. A captura de tela a seguir mostra que dois modelos de tamanho 287.8 MB cada são carregados em dois NeuronCores. Com um total de 4 modelos carregados, você pode ver que a memória do dispositivo usada é de 1.3 GB. Use as teclas de seta para navegar entre os NeuronCores em diferentes dispositivos
Da mesma forma, em um tipo de instância Inf1.16xlarge, vemos um total de 12 modelos (2 modelos por núcleo em 6 núcleos) carregados. Uma memória total de 2.1 GB é consumida e cada modelo tem 177.2 MB de tamanho.
Depois de executar o run_apis.py script, você pode ver a porcentagem de utilização de cada um dos seis NeuronCores (veja a captura de tela a seguir). Você também pode ver o uso de vCPU do sistema e o uso de vCPU em tempo de execução.
A captura de tela a seguir mostra a porcentagem de uso do núcleo da instância Inf2.
Da mesma forma, esta captura de tela mostra a utilização principal em um tipo de instância inf1.6xlarge.
limpar
Para limpar todos os contêineres Docker que você criou, fornecemos um limpeza.sh script que remove todos os contêineres em execução e parados. Este script removerá todos os contêineres, portanto, não o use se quiser manter alguns contêineres em execução.
Conclusão
As cargas de trabalho de produção geralmente têm requisitos de alto rendimento, baixa latência e custos. Arquiteturas ineficientes que utilizam aceleradores de maneira inadequada podem levar a custos de produção desnecessariamente altos. Nesta postagem, mostramos como utilizar NeuronCores com FastAPI de maneira ideal para maximizar o rendimento com latência mínima. Publicamos as instruções em nosso GitHub repo. Com esta arquitetura de solução, você pode implantar vários modelos em cada NeuronCore e operar vários modelos em paralelo em diferentes NeuronCores sem perder desempenho. Para obter mais informações sobre como implantar modelos em escala com serviços como Serviço Amazon Elastic Kubernetes (Amazon EKS), consulte Ofereça 3,000 modelos de aprendizado profundo no Amazon EKS com AWS Inferentia por menos de US $ 50 a hora.
Sobre os autores
Ankur Srivastava é um arquiteto de soluções sênior na equipe de frameworks de ML. Ele se concentra em ajudar os clientes com treinamento distribuído autogerenciado e inferência em escala na AWS. Sua experiência inclui manutenção preditiva industrial, gêmeos digitais, otimização de projeto probabilístico e concluiu seus estudos de doutorado em Engenharia Mecânica na Rice University e pesquisa de pós-doutorado no Massachusetts Institute of Technology.
KC Tung é Arquiteto de Soluções Sênior no AWS Annapurna Labs. Ele é especialista em treinamento e implantação de grandes modelos de deep learning em escala na nuvem. Ele tem um Ph.D. em biofísica molecular pela University of Texas Southwestern Medical Center, em Dallas. Ele falou em AWS Summits e AWS Reinvent. Hoje ele ajuda os clientes a treinar e implantar grandes modelos PyTorch e TensorFlow na nuvem AWS. É autor de dois livros: Conheça o TensorFlow Enterprise e Referência de bolso do TensorFlow 2.
Pronoy Chopra é arquiteto de soluções sênior da equipe de IA generativa de startups da AWS. Ele é especialista em arquitetar e desenvolver soluções de IoT e Machine Learning. Ele foi cofundador de duas startups no passado e gosta de trabalhar ativamente com projetos nas áreas de IoT, AI/ML e Serverless.
- 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. Automotivo / EVs, Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
- BlockOffsets. Modernizando a Propriedade de Compensação Ambiental. Acesse aqui.
- Fonte: https://aws.amazon.com/blogs/machine-learning/optimize-aws-inferentia-utilization-with-fastapi-and-pytorch-models-on-amazon-ec2-inf1-inf2-instances/
- :tem
- :é
- :não
- :onde
- $UP
- 000
- 1
- 1.3
- 10
- 100
- 12
- 13
- 15%
- 2023
- 7
- 8
- 91
- a
- Capaz
- Sobre
- acima
- abstração
- aceleradores
- Acesso
- acessando
- conformemente
- Conta
- Alcançar
- em
- ativo
- adicionar
- contra
- AI
- AI / ML
- Todos os Produtos
- permitir
- permite
- tb
- Amazon
- Amazon EC2
- Amazon Web Services
- an
- e
- qualquer
- api
- APIs
- app
- Aplicação
- aplicações
- Aplicar
- apropriado
- arquitetura
- SOMOS
- argumentos
- AS
- assumir
- At
- autor
- automaticamente
- disponibilidade
- disponível
- evitar
- AWS
- Inferência da AWS
- base
- baseado
- BE
- Porque
- tornam-se
- sido
- antes
- lado
- comportamento
- ser
- beneficiar
- Benefícios
- MELHOR
- melhores práticas
- entre
- Biofísica
- Pouco
- Blog
- Livros
- construir
- Prédio
- construído
- mas a
- by
- chamada
- chamado
- chamadas
- CAN
- capacidades
- capacidade
- Cuidado
- casas
- casos
- Centralização de
- alterar
- mudado
- Alterações
- verificar
- Chips
- escolha
- Escolha
- escolheu
- clareza
- cliente
- de perto
- Na nuvem
- código
- vem
- comparação
- competir
- Efetuado
- Computar
- Configuração
- Considerar
- considerando
- cônsul
- consumida
- não contenho
- Recipiente
- Containers
- contém
- contexto
- continuamente
- contraste
- ao controle
- controlado
- Conveniente
- núcleo
- correta
- Custo
- custos
- poderia
- Casal
- crio
- criado
- cria
- Criar
- Credenciais
- crucial
- Clientes
- Dallas
- decisão
- profundo
- deep learning
- mais profunda
- Padrão
- demonstrar
- Dependendo
- implantar
- implantado
- Implantação
- desenvolvimento
- Design
- designado
- Apesar de
- detalhado
- determina
- em desenvolvimento
- dispositivo
- Dispositivos/Instrumentos
- diferente
- Distribuição
- DIG
- digital
- Gêmeos digitais
- distribuído
- treinamento distribuído
- Django
- do
- Estivador
- parece
- Não faz
- domínio
- não
- dinâmico
- cada
- Mais cedo
- mais fácil
- facilmente
- fácil
- EC
- efetivamente
- final
- Ponto final
- engajar
- Engenharia
- garantir
- Entrar
- entidade
- entrada
- Meio Ambiente
- erros
- etc.
- Mesmo
- Cada
- evolução
- exemplo
- Exceto
- vasta experiência
- extensões
- Rosto
- família
- mais rápido
- factível
- Funcionalidades
- Alimentado
- menos
- Figura
- Envie o
- filtro
- Finalmente
- Encontre
- Primeiro nome
- concentra-se
- seguinte
- segue
- Escolha
- formato
- encontrado
- quatro
- Quadro
- enquadramentos
- da
- cheio
- totalmente
- função
- porta de entrada
- generativo
- IA generativa
- ter
- GitHub
- OFERTE
- dá
- Global
- vai
- guia
- manipular
- mãos em
- Hardware
- Ter
- he
- ajudar
- ajuda
- ajuda
- SUA PARTICIPAÇÃO FAZ A DIFERENÇA
- Alta
- superior
- mais
- sua
- hospedeiro
- hospedado
- hospedagem
- anfitriões
- Como funciona o dobrador de carta de canal
- Como Negociar
- Contudo
- HTML
- http
- HTTPS
- Abraçando o Rosto
- ID
- ideal
- identificado
- if
- imagem
- imagens
- importar
- importante
- in
- incluído
- inclui
- Entrada
- Aumenta
- industrial
- ineficiente
- INFORMAÇÕES
- informado
- entrada
- inputs
- instalar
- instalado
- instalando
- instância
- em vez disso
- Instituto
- instruções
- interagir
- para dentro
- invocado
- iot
- emitem
- questões
- IT
- ESTÁ
- JIT
- jpg
- apenas por
- Guarda
- chaves
- Saber
- conhecido
- Laboratório
- língua
- grande
- Sobrenome
- Latência
- mais recente
- lançamento
- camada
- camadas
- conduzir
- APRENDER
- aprendizagem
- Nível
- Biblioteca
- como
- linux
- Lista
- Listado
- pequeno
- um pouco mais profundo
- LLM
- carregamento
- cargas
- local
- localização
- logging
- entrar
- olhar
- parece
- OLHARES
- perder
- Baixo
- diminuir
- menor
- máquina
- aprendizado de máquina
- moldadas
- manutenção
- fazer
- FAZ
- Fazendo
- muitos
- massachusetts
- Instituto de Tecnologia de Massachusetts
- max
- Maximizar
- máximo
- Posso..
- mecânico
- médico
- Memória
- Métrica
- mente
- mínimo
- ML
- modelo
- modelos
- modificada
- modificar
- molecular
- Monitore
- mais
- a maioria
- mover
- muito
- múltiplo
- devo
- nome
- necessariamente
- necessário
- você merece...
- necessário
- Cria
- Novo
- Próximo
- agora
- número
- objetivo
- observar
- of
- oferecer
- frequentemente
- on
- uma vez
- ONE
- só
- para
- open source
- operar
- Operações
- operadores
- contrário
- otimização
- Otimize
- otimizado
- or
- A Nossa
- Fora
- saída
- Acima de
- pacote
- Paralelo
- parte
- passar
- passado
- caminho
- para
- percentagem
- atuação
- platão
- Inteligência de Dados Platão
- PlatãoData
- ponto
- pontos
- políticas
- Privacidade
- Popular
- possível
- Publique
- práticas
- presente
- privado
- provavelmente
- processo
- processos
- produtor
- Produção
- Perfil
- projetos
- Propriedades
- fornecer
- fornecido
- fornece
- procuração
- publicado
- puxando
- propósito
- Empurrar
- empurrado
- empurra
- colocar
- Python
- pytorch
- alcance
- reais
- em tempo real
- recomendar
- Recomenda
- gravado
- refletir
- região
- relativamente
- depender
- contando
- permanece
- remover
- substituir
- repositório
- pedidos
- requeridos
- Requisitos
- pesquisa
- se assemelha
- Reservar
- reservado
- Recursos
- resposta
- responsável
- DESCANSO
- resultando
- reutilizável
- arroz
- Tipo
- papéis
- Execute
- corrida
- é executado
- sacrificando
- mesmo
- Salvar
- Escala
- cenário
- Scripts
- Sdk
- Vejo
- doadores,
- envio
- senior
- sensível
- separado
- Serverless
- Servidores
- serviço
- Serviços
- de servir
- conjunto
- contexto
- instalação
- formas
- Partilhar
- compartilhado
- rede de apoio social
- mostrar
- mostrou
- mostrando
- Shows
- lado
- semelhante
- Similarmente
- simplesmente
- SIX
- Tamanho
- tamanhos
- menor
- So
- solução
- Soluções
- alguns
- especializada
- específico
- especificada
- falado
- estável
- pilha
- começo
- inicialização
- Startups
- estabelecido
- Passos
- parou
- armazenadas
- lojas
- discordaram
- caso
- entraram com sucesso
- tal
- Cúpulas
- ajuda
- Suportado
- certo
- .
- mesa
- Tire
- tomado
- toma
- Profissionais
- Tecnologia
- temporário
- fluxo tensor
- terminal
- teste
- ensaio
- testes
- texas
- do que
- que
- A
- deles
- Eles
- então
- assim sendo
- Este
- deles
- coisas
- isto
- aqueles
- Através da
- Taxa de transferência
- Amarrado
- tempo
- para
- hoje
- ferramenta
- ferramentas
- topo
- tocha
- Total
- Traçar
- Traçado
- tradicional
- Trem
- Training
- transformadores
- confiável
- tentar
- VIRAR
- Twins
- dois
- tipo
- Ubuntu
- para
- subjacente
- universidade
- unix
- desnecessariamente
- sobre
- us
- Uso
- usar
- usava
- Utilizador
- usuários
- usos
- utilização
- utilizar
- utiliza
- Utilizando
- valor
- Valores
- versão
- muito
- visível
- visão
- volume
- queremos
- foi
- Caminho..
- we
- web
- servidor web
- serviços web
- BEM
- foram
- quando
- qual
- porque
- largamente
- precisarão
- de
- dentro
- sem
- trabalhador
- trabalhadores
- seria
- escrita
- escrito
- Vocês
- investimentos
- você mesmo
- zefirnet
- zero