Stack de computação de IA para treino e inferência | Dweve Core

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

Assistência de agente de codificação e operador. As métricas de demonstração são ilustrativas.

Terminal, pesquisa, lint, testes, git e mais.

Lembra-se da sua base de código e do contexto da equipa.

Agentes especializados colaboram em diferentes áreas.

Cada passo é registado com carimbos de data e hora.

Políticas, verificações e testes são sempre executados.

Revise diffs, peça alterações, aprovação final.

Repita qualquer sessão bit a bit quando algo precisar de revisão.

Agentes autónomos que escrevem código e mantêm registos

para lidar com timeouts de rede, respostas 5xx e condições seguras para idempotência. Helper puro, totalmente testado por unidades.

Capacidade e determinismo declarados por célula

Operação direta em infraestrutura controlada pelo cliente

Um modelo, vários caminhos detidos pelo fornecedor

a definição e a execução discordam lentamente

Funciona em computadores comuns, onde for suportado

Pode funcionar offline, onde for suportado.

As suas coisas podem ficar em casa, na Europa.

célula de execução e contrato de repetição registados

12 famílias de alvos, referência escalar

O formato de armazenamento não é do tipo acumulador

O Dweve Core é uma pilha de computação de IA completa para treino e inferência. A maioria das plataformas de IA cobre uma parte e entrega o resto a outros fornecedores. O Core mantém a criação de modelos, o treino, a inferência, os kernels, a distribuição e a implementação num sistema coerente. Em cargas de trabalho binárias suportadas, o Core utiliza 96% menos energia do que uma pilha com GPU.

25 famílias de formatos numéricos registados

Em cargas de trabalho binárias suportadas.

Os sistemas parciais criam dependência permanente

A definição e a execução discordam lentamente.

A compressão vive na ferramenta de outra pessoa.

Novo hardware, novo sistema de serviço, novo comportamento.

O roadmap do fornecedor torna-se o seu roadmap.

Nenhum sistema único consegue explicar o resultado.

A dependência persiste porque o espaço computacional subjacente está apenas parcialmente coberto.

O Core mantém alterações em largura numérica, empacotamento, hardware e implementação dentro de um único sistema de implementação. Um algoritmo não se torna um produto diferente por passar de um servidor x86 para ARM, GPU, browser ou um alvo especializado. A operação permanece nomeada, inspecionável e propriedade ao longo da mudança, e cada caminho é registado em vez de inferido a partir de um rótulo de formato.

O registo de implementações abrange mais de 2.900 operações, 76 categorias de operações e 25 famílias de formatos numéricos registadas. Cada caminho é determinado em nove dimensões: algoritmo, tipo de dados, largura, empacotamento, acumulador, backend, conjunto de instruções, política de despacho e modo de determinismo. O contrato de representação mantém essas escolhas numéricas e físicas ligadas à operação. O visual abaixo fixa a maioria dessas dimensões para que uma pequena fatia representativa permaneça legível. A contagem descreve um registo de células e contratos concretos, não uma afirmação de que um rótulo de formato ou um distintivo de capacidade genérico explica sozinho um caminho de execução.

Qual caminho é escolhido, sob que contrato.

A amostra é pequena porque o registo de implementações não é.

Um algoritmo sobrevive a todas as restrições

Chega uma nova largura, empacotamento, host ou contrato.

A máquina escolhe o caminho para a nova célula.

Qual código foi executado, em que máquina, declarado.

Mesmo ativo, mesmo proprietário, nova condição.

A primeira suposição herdada que o Core remove é que um único tipo de dados deve dominar tudo.

nenhum degrau é uma funcionalidade de investigação

O processador deve ser tão substituível quanto o tipo de dados.

O Core não trata um ecossistema de aceleradores como a definição de IA e tudo o resto como uma porta inferior. As suas operações têm implementações de referência escalares e caminhos específicos para cada alvo nos backends suportados de CPU, GPU, FPGA, navegador e implementação. O runtime seleciona uma implementação de acordo com a máquina disponível e a política associada ao trabalho.

Um processador x86 moderno pode usar as suas instruções vetoriais. ARM e Apple silicon podem usar os seus caminhos nativos. As GPUs NVIDIA, AMD e Apple podem usar os respetivos backends. A execução no navegador pode usar WebAssembly ou WebGPU quando apropriado. Os programas de implementação podem visar hardware especializado. O processador é um destino para a operação. Não é o dono do modelo.

Vetores x86, caminhos nativos ARM e Apple silicon.

GPUs NVIDIA, AMD e Apple nos seus próprios backends.

WebAssembly ou WebGPU quando apropriado.

Hardware especializado para programas de implementação.

Rótulos de alvo amplos são baratos. Possuir o caminho real é mais difícil.

O tipo de dados não era suportado, o hardware alvo mudou e o quantizador precisava de outro runtime.

A pilha de serviço não conseguia reproduzir o resultado. As compras abriram outra revisão de fornecedor.

O quantizador precisava de outro runtime

Não adicionou uma funcionalidade. Expôs outro buraco na máquina.

Ajustado à mão significa que alguém é dono do resultado

Uma API ampla é fácil de anunciar. A posse ampla ao nível da máquina é muito mais difícil. O Core não conta uma operação como coberta apenas porque uma implementação genérica compila noutro alvo. Os caminhos suportados são implementados e ajustados para a sua combinação real de operação, representação, empacotamento, backend e conjunto de instruções.

A multiplicação de matrizes binárias em AVX-512 não é tratada como multiplicação de matrizes de vírgula flutuante com valores mais pequenos. As operações de bits empacotados usam as instruções de bits disponíveis na máquina. As operações de inteiros e ponto fixo usam o acumulador correto e o comportamento de overflow. Os caminhos de GPU usam a estrutura de execução do alvo. As implementações escalares permanecem presentes como referência e piso universal. Isso cria uma resposta responsável a uma pergunta simples: que código executou realmente esta operação nesta máquina? O Core pode nomear o caminho.

Escrita para o que é realmente calculado.

Instruções de bits para bits, não floats escalados.

Comportamento de overflow correto, por design.

Kernels NEON escritos para a própria arquitetura vetorial da ARM.

Essa posse deve continuar para além do kernel e ao longo de todo o ciclo de vida do modelo.

Treinado para a representação que vai usar.

Encaminhado para o caminho ajustado ao anfitrião.

Avaliado e reproduzido na mesma máquina.

Quando o ciclo de vida é coerente, a variação pode tornar-se um contrato em vez de um acidente.

O Core declara o contrato do caminho que realmente correu. Os caminhos binários, ternários, de inteiros com e sem sinal, de ponto fixo, adaptativos e exatos do Core Native são puramente determinísticos onde cobertos, sem semente. Os caminhos de flutuante, bfloat, escala por blocos e microescala do Core Native usam reprodução com semente. O Core opcional em Kera torna os caminhos suportados dessas famílias de flutuante também puramente determinísticos.

Um fluxo de trabalho regulado de baixo bit, formato Q ou adaptativo pode exigir reprodução bit a bit idêntica do Core Native. Um fluxo de trabalho de família flutuante pode usar uma semente fixa e um registo completo sob Core Native. A amostragem criativa continua a ser uma escolha de geração separada. Uma implementação que exija execução de flutuante, bfloat, escala por blocos, microescala ou flutuante convencional puramente determinística pode usar Core em Kera e remover a semente. Estes são contratos declarados diferentes para a célula selecionada, não nomes de marketing intercambiáveis para cada resposta repetida.

o caminho selecionado indica qual se aplica

Caminhos binários, inteiros, Q, adaptativos e exatos. Sem semente.

Reprodução de flutuante, bfloat, escala por blocos e microescala.

Caminhos suportados de família flutuante, sem semente necessária.

Quando o comportamento muda, um sistema deve continuar a ser dono da explicação.

Quando um resultado de produção muda numa stack fragmentada, a responsabilidade fica distribuída. O framework culpa o exportador. O exportador culpa o runtime. O runtime culpa o kernel. O kernel culpa o driver. O driver culpa o hardware. O Core traz essas responsabilidades para dentro de um sistema.

A definição do modelo, as escolhas numéricas, o backend selecionado, o caminho de despacho, o modo de determinismo e o registo de execução resultante podem ser examinados em conjunto. Isso não significa que todas as dependências externas desaparecem. Fontes de dados, aplicações, sistemas operativos e hardware continuam a existir. Significa que a máquina de IA em si tem uma fronteira responsável. Uma revisão pode perguntar qual implementação correu, em que alvo suportado e sob que contrato de reprodução, sem ter de coser a resposta a partir dos sistemas internos de vários fornecedores.

examinado em conjunto, não entre fornecedores

A definição e as suas escolhas numéricas.