E, no entanto, por que o Posit é uma alternativa digna do IEEE 754

O mês de Posit em Habré foi declarado aberto, o que significa que não posso ignorar as críticas que caíram sobre eles. Nas séries anteriores:

Uma nova abordagem pode nos ajudar a nos livrar dos cálculos de ponto flutuante
Posit-aritmética: derrotar um ponto flutuante em seu próprio campo. Parte 1
Posit-aritmética: derrotar um ponto flutuante em seu próprio campo. Parte 2
Desafios para adultos

Penso que muitos de vocês se lembram imediatamente de pelo menos um caso histórico, quando idéias revolucionárias na época de sua formação foram rejeitadas por uma comunidade de especialistas. Como regra, a falha de tal comportamento é a vasta bagagem de conhecimento já acumulado que não permite olhar para o antigo problema sob uma nova luz. Assim, a nova idéia perde em termos de características para as abordagens estabelecidas, porque é avaliada apenas pelas métricas que foram consideradas importantes no estágio anterior de desenvolvimento.

Esse é precisamente o tipo de aversão que o formato Posit está enfrentando hoje: os críticos simplesmente “olham na direção errada” e até usam o Posit em seus experimentos da maneira errada. Neste artigo, tentarei explicar o porquê.

As vantagens do Posit já foram bastante comentadas: elegância matemática, alta precisão em valores exponenciais baixos, uma ampla gama de valores, apenas uma representação binária de NaN e zero, a ausência de valores subnormais, a luta contra o estouro / estouro. Os críticos foram expressos bastante: precisão inútil para valores muito grandes ou muito pequenos, um formato de representação binária complexo e, é claro, falta de suporte de hardware.

Não quero repetir os argumentos que já disse, mas tentarei focar no aspecto que, em regra, é negligenciado.

As regras do jogo foram alteradas


O padrão IEEE 754 descreve números de ponto flutuante implementados no Intel 8087 há quase 40 anos. Pelos padrões de nossa indústria, este é um momento incrível; tudo mudou desde então: desempenho do processador, custo de memória, volumes de dados e escala de cálculos. O formato Posit foi desenvolvido não apenas como a melhor versão do IEEE 754, mas como uma abordagem para trabalhar com números que atendem aos novos requisitos da época.

A tarefa de alto nível permaneceu a mesma - todos precisamos de cálculos efetivos no campo dos números racionais com perda mínima de precisão. Mas as condições sob as quais a tarefa está sendo resolvida são radicalmente alteradas.

Primeiro, as prioridades para otimização mudaram. Há 40 anos, o desempenho do computador era quase totalmente dependente do desempenho do processador. Hoje, o desempenho da maioria dos computadores está na memória. Para verificar isso, basta olhar para as principais áreas de desenvolvimento de processadores das últimas décadas: armazenamento em cache em três níveis, execução especulativa, pipeline de cálculos, previsão de ramificação. Todas essas abordagens têm como objetivo obter alto desempenho nas condições de computação rápida e acesso lento à memória.

imagem

Em segundo lugar, um novo requisito veio à tona - o consumo de energia efetivo. Nas últimas décadas, a tecnologia de escala horizontal da computação avançou tanto que começamos a nos preocupar não tanto com a velocidade desses cálculos, mas com a conta da eletricidade. Aqui, devo enfatizar uma parte importante para entender. Do ponto de vista da eficiência energética, os cálculos são baratos, porque os registros do processador estão muito próximos de seus computadores. Será muito mais caro pagar pela transferência de dados, entre o processador e a memória (x100), e por longas distâncias (x1000 ...).

imagem

Aqui está apenas um exemplo de um projeto de ciência que o Posit planeja usar:

imagem

Essa rede de telescópios gera 200 petabytes de dados por segundo, cujo processamento consome a energia de uma pequena usina - 10 megawatts . Obviamente, para esses projetos, a redução no consumo de dados e energia é crítica.

Até o começo


Então, o que o padrão Posit oferece? Para entender isso, você precisa retornar ao início da discussão e entender o que significa a precisão dos números de ponto flutuante.

Na verdade, existem dois aspectos diferentes relacionados à precisão. O primeiro aspecto é a precisão dos cálculos - quanto os resultados dos cálculos divergem durante várias operações. O segundo aspecto é a precisão da apresentação - quanto o valor original é distorcido no momento da conversão do campo de números racionais para o campo de números de ponto flutuante de um formato específico.

Agora haverá um momento importante para a conscientização. Posit é principalmente um formato para representar números racionais, não uma maneira de executar operações neles. Em outras palavras, o Posit é um formato de compactação racional com perdas. Você pode ter ouvido a alegação de que o Posit de 32 bits é uma boa alternativa ao Float de 64 bits. Então, estamos falando sobre reduzir pela metade a quantidade necessária de dados para armazenar e transmitir o mesmo conjunto de números. Duas vezes menos memória - quase duas vezes menos consumo de energia e alto desempenho do processador devido às expectativas mais baixas de acesso à memória.

Segunda extremidade do manche


Aqui você deve ter uma pergunta lógica: qual é o sentido de representar eficientemente números racionais se não permitir que os cálculos sejam executados com alta precisão.

De fato, existe uma maneira de fazer cálculos exatos, e isso se chama Quire. Este é outro formato para representar números racionais, inextricavelmente vinculados ao Posit. Diferentemente do Posit, o formato Quire é projetado especificamente para cálculos e para armazenar valores intermediários em registradores, e não na memória principal.

imagem

Em resumo, o Quire nada mais é do que uma ampla bateria inteira (aritmética de ponto fixo). A unidade, como uma representação binária de Quire, corresponde ao valor positivo mínimo de Posit. O valor máximo do Quire corresponde ao valor máximo do Posit. Cada valor do Posit possui uma representação exclusiva no Quire sem perda de precisão, mas nem todo valor Quit pode ser representado no Posit sem perda de precisão.

Os benefícios do Quire são óbvios. Eles permitem que você execute operações com precisão incomparavelmente maior que o Float e, para operações de adição e multiplicação, não haverá perda de precisão. O preço que você deve pagar por isso é um amplo registro de processadores (o Posit de 32 bits com es = 2 corresponde ao Quire de 512 bits), mas esse não é um problema sério para os processadores modernos. E se há 40 anos a computação em números inteiros de 512 bits parecia um luxo inaceitável, hoje é uma alternativa adequada ao amplo acesso à memória.

Montando o quebra-cabeça


Assim, o Posit oferece não apenas um novo padrão na forma de uma alternativa ao Float / Double, mas uma nova abordagem para trabalhar com números. Ao contrário do Float - que é uma representação única tentando encontrar um compromisso entre precisão, eficiência de armazenamento e eficiência computacional, o Posit oferece dois formatos de apresentação diferentes, um para armazenar e transmitir números - o próprio Posit e o outro para cálculos e seus intermediários Valores - Quire.

Quando resolvemos problemas práticos usando números de ponto flutuante, do ponto de vista do processador, trabalhar com eles pode ser representado como um conjunto das seguintes ações:

  1. Leia os valores dos números da memória.
  2. Execute alguma sequência de operações. Às vezes, o número de operações é bastante grande. Nesse caso, todos os valores intermediários dos cálculos são armazenados nos registros.
  3. Escreva o resultado das operações na memória.


Com Float / Double, a precisão é perdida em todas as operações. Com o Posit + Quire, a perda de precisão durante o cálculo é insignificante. Ele é perdido apenas na última etapa, no momento da conversão do valor Quire em Posit. É por isso que a maioria dos problemas de "acumulação de erros" do Posit + Quire simplesmente não são relevantes.

Ao contrário de Float / Double, ao usar o Posit + Quire, geralmente podemos oferecer uma representação mais compacta dos números. Como resultado - acesso mais rápido aos dados da memória (melhor desempenho) e armazenamento e transmissão de informações mais eficientes.

Relação Mueller


Como demonstração visual, darei apenas um exemplo - a clássica relação de recorrência de Muller, inventada especificamente para demonstrar como o acúmulo de erros nos cálculos de ponto flutuante distorce radicalmente o resultado dos cálculos.

imagem

No caso de usar aritmética com precisão arbitrária, a sequência de recorrência deve ser reduzida ao valor de 5. No caso de aritmética de ponto flutuante, a questão é apenas em qual iteração os resultados do cálculo começarão a ter um desvio inadequadamente grande.

Realizei um experimento para o IEEE 754 com precisão simples e dupla, bem como para o Posit + Quire de 32 bits. Os cálculos foram realizados na aritmética de Quire, mas cada valor na tabela foi convertido em Posit.

Resultados da Experiência
 
  # flutuador (32) duplo (64) positivo (32)
 ------------------------------------------------
  0 4.000000 4.000000 4
  1 4.250000 4.250000 4.25
  2 4.470589 4.470588 4.470588237047195
  3 4.644745 4.644737 4.644736856222153
  4 4.770706 4.770538 4.770538240671158
  5 4.859215 4.855701 4.855700701475143
  6 4.983124 4.910847 4.91084748506546
  7 6.395432 4.945537 4.94553741812706
  8 27.632629 4.966962 4.966962575912476
  9 86.993759 4.980042 4.980045706033707
 10 99.255508 4.987909 4.98797944188118
 11 99.962585 4.991363 4.992770284414291
 12 99.998131 4.967455 4.99565589427948
 13 99.999908 4.429690 4.997391253709793
 14 100.000000 -7.817237 4.998433947563171
 15 100.000000 168.939168 4.9990600645542145
 16 100.000000 102.039963 4.999435931444168
 17 100.000000 100.099948 4.999661535024643
 18 100.000000 100.004992 4.999796897172928
 19 100.000000 100.000250 4.999878138303757
 20 100.000000 100.000012 4.999926865100861
 21 100.000000 100.000001 4.999956130981445
 22 100.000000 100.000000 4.999973684549332
 23 100.000000 100.000000 4.9999842047691345
 24 100.000000 100.000000 4.999990522861481
 25 100.000000 100.000000 4.999994307756424
 26 100.000000 100.000000 4.999996602535248
 27 100.000000 100.000000 4.999997943639755
 28 100.000000 100.000000 4.999998778104782
 29 100.000000 100.000000 4.99999925494194
 30 100.000000 100.000000 4.999999552965164
 31 100.000000 100.000000 4.9999997317790985
 32 100.000000 100.000000 4.999999850988388
 33 100.000000 100.000000 4.999999910593033
 34 100.000000 100.000000 4.999999940395355
 35 100.000000 100.000000 4.999999970197678
 36 100.000000 100.000000 4.999999970197678
 37 100.000000 100.000000 5
 38 100.000000 100.000000 5
 39 100.000000 100.000000 5
 40 100,000000 100,000000 5
 41 100.000000 100.000000 5
 42 100.000000 100.000000 5
 43 100.000000 100.000000 5
 44 100.000000 100.000000 5
 45 100,000000 100,000000 5
 46 100.000000 100.000000 5
 47 100.000000 100.000000 5
 48 100.000000 100.000000 5
 49 100.000000 100.000000 5
 50 100.000000 100.000000 5
 51 100.000000 100.000000 5
 52 100.000000 100.000000 5.000000059604645
 53 100.000000 100.000000 5.000000983476639
 54 100.000000 100.000000 5.000019758939743
 55 100.000000 100.000000 5.000394910573959
 56 100.000000 100.000000 5.007897764444351
 57 100.000000 100.000000 5.157705932855606
 58 100.000000 100.000000 8.057676136493683
 59 100.000000 100.000000 42.94736957550049
 60 100.000000 100.000000 93.35784339904785
 61 100.000000 100.000000 99.64426326751709
 62 100.000000 100.000000 99.98215007781982
 63 100.000000 100.000000 99.99910736083984
 64 100.000000 100.000000 99.99995517730713
 65 100.000000 100.000000 99.99999809265137
 66 100.000000 100.000000 100
 67 100.000000 100.000000 100
 68 100.000000 100.000000 100
 69 100.000000 100.000000 100
 70 100,000000 100,000000 100


Como você pode ver na tabela, o Float de 32 bits já se rende no sétimo valor e o Float de 64 bits durou até a 14ª iteração. Ao mesmo tempo, os cálculos do Posit usando Quire retornam um resultado estável até 58 iterações!

Moral


Em muitos casos práticos e quando usado corretamente, o formato Posit realmente permite economizar memória, por um lado, compactando números melhor do que o Float e, por outro lado, para fornecer uma melhor precisão de cálculo graças ao Quire.

Mas isso é apenas uma teoria! Quando se trata de precisão ou desempenho, sempre faça testes antes de confiar cegamente em uma abordagem ou outra. De fato, na prática, seu caso particular será excepcional com muito mais frequência do que na teoria.

Bem, não se esqueça da primeira lei de Clark (interpretação livre): quando um especialista respeitado e experiente afirma que uma nova idéia funcionará, ele quase certamente está certo. Quando ele afirma que a nova idéia não vai funcionar, é muito provável que ele esteja enganado. Não me considero um especialista experiente para permitir que você confie na minha opinião, mas peço que seja cauteloso em criticar até mesmo pessoas experientes e respeitadas. Afinal, o diabo está nos detalhes, e até pessoas experientes podem sentir falta deles.

Source: https://habr.com/ru/post/pt467933/


All Articles