Discussão do artigo "Trabalho com modelos ONNX nos formatos float16 e float8"

 

Novo artigo Trabalho com modelos ONNX nos formatos float16 e float8 foi publicado:

Os formatos de dados utilizados para representar modelos de aprendizado de máquina desempenham um papel fundamental em sua eficiência. Nos últimos anos, surgiram vários novos tipos de dados desenvolvidos especificamente para trabalhar com modelos de aprendizado profundo. Neste artigo, vamos focar em dois novos formatos de dados que se tornaram amplamente utilizados nos modelos modernos.

Neste artigo, vamos focar em dois desses novos formatos de dados, especificamente float16 e float8, que estão começando a ser amplamente utilizados nos modelos ONNX modernos. Esses formatos representam alternativas aos formatos de dados de ponto flutuante mais precisos, mas que demandam mais recursos. Eles oferecem uma combinação ótima de desempenho e precisão, tornando-os especialmente atraentes para realizar várias tarefas de aprendizado de máquina. Vamos explorar as principais características e vantagens dos formatos float16 e float8, bem como apresentar funções para sua conversão em float e double padrão. 

Isso ajudará desenvolvedores e pesquisadores a entender melhor como usar esses formatos de forma eficiente em seus projetos e modelos. Como exemplo, vamos examinar o funcionamento do modelo ONNX ESRGAN, que é utilizado para melhorar a qualidade das imagens.

Autor: MetaQuotes

 
<img width="750" height="469" src="https://c.mql5.com/2/70/lenna-ESRGAN-compare__1.png" loading="lazy" title=""Fig.16. Comparação dos resultados do modelo ESRGAN para float e float16" alt="" Fig.16. Comparação dos resultados do modelo ESRGAN para float e float16"/ translate="no">
.
Adicione mais uma imagem do mesmo tamanho à direita - a imagem original ampliada quatro vezes (em vez de um pixel - quatro (2x2) da mesma cor).
 
fxsaber #:
Adicione outra imagem do mesmo tamanho à direita - imagem original quadruplicada (em vez de um pixel - quatro (2x2) da mesma cor).

Lenna-ESRGAN-ESRGAN_float e original em escala 4x

Você pode substituir o código para exibi-la:

   //ShowImage(canvas_original, "original_image",new_image_width,0,image_width,image_height,image_data);
   ShowImage4(canvas_original,"original_image",new_image_width,0,image_width,image_height,image_data);
//+------------------------------------------------------------------+
//| ShowImage4|
//+------------------------------------------------------------------+
bool ShowImage4(CCanvas &canvas,const string name,const int x0,const int y0,const int image_width,const int image_height, const uint &image_data[])
  {
   if(ArraySize(image_data)==0 || name=="")
      return(false);
//--- preparar a tela
   canvas.CreateBitmapLabel(name,x0,y0,4*image_width,4*image_height,COLOR_FORMAT_XRGB_NOALPHA);
//--- copiar a imagem para a tela
   for(int y=0; y<4*image_height-1; y++)
      for(int x=0; x<4*image_width-1; x++)
      {
         uint  clr =image_data[(y/4)*image_width+(x/4)];
         canvas.PixelSet(x,y,clr);
         }
//--- pronto para desenhar
   canvas.Update(true);
   return(true);
  }
 
Quantum #:

Você pode substituir o código para produzi-lo:

Obrigado! Reduzido por um fator de dois em cada coordenada, obtendo a imagem correta como a original.

Achei que o float16/32 ficaria próximo do original com essa transformação. Mas eles estão visivelmente melhores! Ou seja, UpScale+DownScale >> Original.


ZY Surpreso. Parece razoável passar todas as imagens/vídeos antigos por esse modelo onnx.

 

Se a entrada do onnx-model receber os mesmos dados, o resultado será sempre o mesmo?

Há um elemento de aleatoriedade no onnx-model?

 
fxsaber #:

Se o modelo onnx receber os mesmos dados como entrada, mas a saída sempre terá o mesmo resultado?

Há um elemento de aleatoriedade no modelo onnx?

Em geral, isso depende de quais operadores são usados no modelo ONNX.

Para esse modelo, o resultado deve ser o mesmo, pois ele contém operações determinísticas (1195 no total)

 

Описание float16

https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%BE_%D0%BF%D0%BE%D0%BB%D0%BE%D0%B2%D0%B8%D0%BD%D0%BD%D0%BE%D0%B9_%D1%82%D0%BE%D1%87%D0%BD%D0%BE%D1%81%D1%82%D0%B8


Примеры чисел половинной точности

Nesses exemplos, os números de ponto flutuante são representados em binário. Eles incluem o bit de sinal, o expoente e a mantissa.

0 01111 0000000000 = +1 *215-15 = 1
0 01111 0000000001 = +1.0000000001 2 *215-15=1+ 2-10 = 1.0009765625 (o próximo número maior depois de 1)

Ou seja, para números com 5 casas decimais (a maioria das moedas), somente 1,00098 pode ser aplicado após 1,00000.
Legal! Mas não para negociar e trabalhar com cotações.