Apesar das melhorias significativas no rendimento, os aceleradores de IA na borda (Unidades de Processamento Neural, ou NPUs) ainda são frequentemente subutilizados. A gestão ineficiente de pesos e ativações leva a menos núcleos disponíveis sendo usados para operações de multiplicação-acumulação (MAC). As aplicações de IA na borda frequentemente precisam rodar em dispositivos pequenos e de baixo consumo de energia, limitando o espaço e a energia disponíveis para memória e processamento. A baixa utilização, frequentemente chamada de “silício escuro”, significa que os recursos de processamento que poderiam ser usados para rodar suas aplicações de forma mais eficiente estão, em vez disso, ociosos, desperdiçando energia e espaço em seus projetos.
Uma maneira de aumentar a utilização da NPU é otimizando o cálculo das ativações durante a inferência. O cálculo das ativações camada por camada é ineficiente, pois exige o armazenamento de todas as ativações das camadas ainda não utilizadas da rede neural (NN) antes de prosseguir para a próxima camada. Uma alternativa é entender as dependências detalhadas na rede e criar uma ordem de cálculo baseada em objetivos de alto nível. Isso é feito dividindo cada camada em “pacotes” que contêm os metadados necessários para propagar as ativações pelas camadas.
Nesse “traversal” baseado em pacotes na rede, uma ativação é removida da memória após não ser mais necessária. Isso diminui o número de ciclos necessários para transferir ativações de e para a memória externa (DDR). Com memória suficiente no chip, essa abordagem elimina totalmente as transferências de ativações para a memória externa.
Otimizar a travessia da rede por pacotes aumenta a utilização de MAC ao permitir cálculos paralelos e acesso paralelo à memória. Em outras palavras, a NPU entrega mais operações por segundo para uma determinada frequência e número de núcleos MAC. Isso, por sua vez, aumenta o rendimento sem adicionar mais largura de banda ou processamento.
Otimização baseada em pacotes
Otimizar uma rede usando pacotes ocorre em duas etapas: (1) convertendo a NN em pacotes e (2) agendando os pacotes para criar um fluxo de pacotes. Na primeira etapa, cada camada é dividida em blocos contínuos de metadados (pacotes). O processo pelo qual as camadas são transformadas em pacotes depende do tipo de camada e dos requisitos básicos de hardware. Por exemplo, a maneira pela qual uma camada convolucional é dividida em pacotes pode não ser ideal para uma cabeça de atenção ou bloco LSTM.
Pacotes que são ótimos para processamento serial e acesso direto à memória (DMA) serial podem não ser os melhores para processamento paralelo e DMA paralelo. Da mesma forma, NPUs multicore podem ter diferentes requisitos de pacotes em comparação com NPUs single-core. Os recursos disponíveis na NPU e na memória externa também afetam a criação e o agendamento dos pacotes.
Depois que as camadas são divididas em pacotes, esses pacotes são então agendados para rodar na NPU. Em vez de serem particionados por camada, uma rede é dividida em partições determinadas pela memória disponível na NPU e pela largura de banda da memória externa. Dentro de cada partição, os pacotes são agendados de forma determinística, com troca de contexto eficiente. Como os pacotes contêm apenas as informações necessárias para calcular o conjunto de operações em cada partição, eles adicionam muito pouco overhead de memória (na ordem de dezenas de kilobytes).
Particionamento por camada versus particionamento baseado em pacotes: YOLOv3
YOLO (You Only Look Once) é uma família popular de arquiteturas de rede para detecção de objetos de baixa latência. As operações no YOLOv3 são principalmente convoluções 1×1 e 3×3, conectadas por funções de ativação ReLU com fuga e conexões de desvio. Considere o exemplo do YOLOv3 com entradas RGB de 608×608 e um tamanho de lote de duas imagens. O modelo contém 63 milhões de pesos, dos quais 4,3 milhões estão na maior camada, e 235 milhões de ativações, das quais 24 milhões estão na maior camada. No total, 280 bilhões de operações são necessárias para calcular a saída deste modelo.
Agora, considere rodar o YOLOv3 em uma NPU com 4 MB de memória disponível no chip. Uma NPU típica com particionamento por camada exigiria a transferência de centenas de milhões de pesos e ativações para e da memória externa. Pense na camada com 24 milhões de ativações: apenas um sexto dessa camada pode ser armazenada no chip, e isso sem contar os milhões de pesos necessários para calcular essas ativações.
No entanto, ao agendar e executar pacotes de forma inteligente, é possível particionar o YOLOv3 para reduzir as transferências de DDR em mais de 80%, como mostrado na figura 1.
Figura 1: Necessidades de memória baseadas em camada vs. pacote.
Reduzir o movimento intermediário de tensores não só aumenta o rendimento do modelo; também diminui a energia, memória e largura de banda DDR necessárias para atingir uma latência alvo. Isso, por sua vez, diminui o espaço e o custo necessários para a NPU e a memória externa. Além disso, grandes transferências DDR são frequentemente necessárias para algumas camadas, mas não para outras. Com o particionamento baseado em pacotes, é possível reduzir não só a largura de banda da memória externa necessária, mas também a variação na largura de banda ao longo da rede. Isso leva a menores variações na utilização, latência, energia e rendimento — fatores importantes para aplicações que rodam em dispositivos de borda.
Hardware inteligente para IA na borda
As vantagens dos pacotes para reduzir o armazenamento e a transferência de dados e aumentar o desempenho do modelo são evidentes nos exemplos acima e não se limitam ao YOLO ou redes de detecção de objetos. Qualquer rede neural pode se beneficiar do particionamento baseado em pacotes, como autoencoders, transformers de visão, transformers de linguagem e redes de difusão — todas as quais são suportadas atualmente pela arquitetura da Expedera. O particionamento baseado em pacotes também ajuda a executar modelos de precisão mista, bem como redes com conectividade de camadas complexas.
No entanto, arquiteturas de hardware tradicionais não são bem adaptadas para gerenciar o agendamento e a execução de pacotes. Arquiteturas baseadas em instruções tendem a ter alto overhead ao escalar para múltiplos núcleos. Arquiteturas baseadas em camadas exigem uma quantidade substancial de memória, como mostrado no exemplo de particionamento do YOLOv3.
O diagrama a seguir mostra a arquitetura baseada em pacotes da Expedera, comprovada em silício e implantada em mais de 10 milhões de dispositivos. Ao contrário das abstrações baseadas em instruções ou camadas, a arquitetura baseada em pacotes da Expedera contém lógica para executar os pacotes nativamente e reordenar esses pacotes sem penalidade (troca de contexto sem custo). A arquitetura é flexível, escalando de 3,2 GOPS a 128 TOPS em um único núcleo, independentemente da memória.
Figura 2: Processo de camada para pacote.
Implantar soluções de IA em dispositivos embarcados exige hardware que não seja apenas rápido, mas eficiente. Como ilustrado aqui, otimizar o fluxo de ativações por uma rede pode reduzir significativamente as transferências de dados e o overhead de memória. O melhor hardware para tarefas de IA na borda não deve apenas ser mais rápido, mas também mais inteligente, utilizando efetivamente os recursos disponíveis por meio do agendamento e execução inteligente das operações.