O ponto flutuante de precisão única é tão ruim?

Eu estive olhando alguns dos pacotes da alta perf tarefa vista lidar com cálculos GPU, e dado que a maioria GPU parece ser uma ordem de magnitude mais forte na execução de aritmética de precisão simples de DP queridos , eu queria saber:

1. Por que nenhum dos pacotes dá mais controle ao usuário sobre o tipo de precisão necessária? Eu posso ver muitas aplicações nas estatísticas em que a aritmética de SP (ou seja, número codificado com precisão de 7 dígitos) é boa o suficiente para uso prático (se eu estiver superestimando os ganhos envolvidos, me avise).
2. O python é mais flexível nisso? Se sim, por quê? Não vejo por que a ausência de um tipo 'único' em R tornaria impossível incluir essa opção (junto com um aviso) em digamos GPUtools ou magma (embora eu seja feliz em ser mostrado errado).

PS: Estou pensando especificamente nas aplicações onde os números já são dimensionados e centralizados em dimensão (para que a desigualdade de Chebychev seja vinculativa) em dimensão.

No arquivo de ajuda do GPUtools , parece que esse useSingle=TRUEé o padrão para as funções.

1. Porque antes das GPUs não havia sentido prático de usar reais únicos; você nunca tem muita precisão e a memória geralmente não é um problema. E apoiar apenas duplos tornou o design do R mais simples. (Embora o R suporte a leitura / gravação de reais simples.)
2. Sim, porque o Python tem como objetivo ser mais compatível com linguagens compiladas. No entanto, você está certo de que é possível para os wrappers das bibliotecas R fazerem conversão instantânea (isso obviamente leva tempo, mas esse é um problema menor); você pode tentar enviar por email os mantenedores dos pacotes GPU solicitando essas alterações.

Presumo que por programação GPU, você quer dizer programar placas nvidia? Nesse caso, as chamadas de código subjacentes de R e python são para C / CUDA .

O motivo simples de oferecer apenas uma única precisão é porque é isso que a maioria das placas GPU suporta.

No entanto, a nova arquitetura da nvidia Fermi suporta precisão dupla. Se você comprou uma placa de vídeo nvidia este ano, provavelmente é uma Fermi. Mesmo aqui as coisas não são simples:

• Você obtém um leve impacto no desempenho se compilar com precisão dupla (um fator de dois, se bem me lembro).
• Nos cartões Fermi mais baratos, a nvidia desabilitou intencionalmente a precisão dupla. No entanto, é possível contornar isso e executar programas de precisão dupla. Consegui fazer isso na minha GeForce GTX 465 no Linux.

Para responder à pergunta em seu título, "A precisão única está correta?", Depende do seu aplicativo (desculpe porcaria!). Suponho que todo mundo agora use precisão dupla, porque não dá mais um impacto no desempenho.

Quando brinquei com GPUs, a programação de repente se tornou muito mais complicada. Você precisa se preocupar com coisas como:

• warpsize e organizando sua memória corretamente.
• # roscas por kernel.
• a depuração é horrível - não há nenhuma declaração de impressão nas instruções do kernel da GPU
• falta de geradores de números aleatórios
• Única precisão.

A grande maioria das GPUs em circulação suporta apenas um ponto flutuante de precisão única.

No que diz respeito à questão do título, você precisa examinar os dados que manipulará para determinar se uma única precisão é suficiente para você. Frequentemente, você descobrirá que os singles são perfeitamente aceitáveis ​​para> 90% dos dados que você manipula, mas falha espetacularmente nos últimos 10%; a menos que você tenha uma maneira fácil de determinar se seu conjunto de dados em particular falhará ou não, você está usando a precisão dupla para tudo.

OK, uma nova resposta para uma pergunta antiga, mas ainda mais relevante agora. A pergunta que você está fazendo tem a ver com precisão finita, normalmente o domínio da análise de sinais e da matemática experimental.

Flutuadores de precisão dupla (DP) vamos fingir que não existem problemas de precisão finitos, o mesmo que acontece com a maioria dos problemas matemáticos do mundo real. Na matemática experimental, não há fingimento.

Flutuadores de precisão única (SP) nos forçam a considerar o ruído de quantização. Se nossos modelos de aprendizado de máquina rejeitam inerentemente ruídos, como redes neurais (NN), redes convolucionais (CNN), redes residuais (ResN), etc., o SP geralmente gera resultados semelhantes aos da DP.

Os flutuadores de meia precisão (HP) (agora suportados no cuda toolkit 7.5) exigem que os efeitos de quantização (ruído e arredondamento) sejam considerados. Muito provavelmente veremos a HP flutuar nos kits de ferramentas comuns de aprendizado de máquina.

Há trabalhos recentes para criar cálculos de menor precisão em flutuadores, bem como números de precisão fixos. O arredondamento estocástico permitiu que a convergência se processasse com as CNNs, enquanto a solução diverge sem ela. Estes documentos ajudarão você a melhorar sua compreensão dos problemas com o uso de números de precisão finita no aprendizado de máquina.

Para responder às suas perguntas:

SP não é tão ruim. Como você aponta, é duas vezes mais rápido, mas também permite colocar mais camadas na memória. Um bônus é em economizar despesas, obtendo dados dentro e fora da gpu. Os cálculos mais rápidos e as despesas gerais mais baixas resultam em menores tempos de convergência. Dito isto, a HP, para alguns problemas, será melhor em algumas partes da rede e não em outras.

1. Parece-me que muitos dos kits de ferramentas de aprendizado de máquina lidam com SPs e DPs. Talvez alguém com uma experiência mais ampla com os kits de ferramentas adicione seu níquel.
2. O Python suportará o que o kit de ferramentas gpu suporta. Você não deseja usar tipos de dados python, pois estará executando um script interpretado na CPU.

Observe que a tendência nas redes neurais agora é usar camadas muito profundas, com execuções de mais de alguns dias comuns nos clusters de gpu mais rápidos.