Caderno 2

Do Contínuo ao Computável: Discretização e Erros Numéricos¶

Os computadores, em sua essência, operam sobre representações discretas e finitas da informação. Diferente do mundo físico e das formulações matemáticas clássicas, as quais, na maioria das vezes, pressupõem um universo contínuo e infinitamente preciso, os sistemas computacionais lidam com números armazenados em memória finita, com quantidade limitada de dígitos binários. Esse contraste entre o mundo contínuo e o mundo discreto estabelece a base para compreender os desafios e limitações presentes na implementação de modelos matemáticos por meio de algoritmos.

Quando resolvemos numericamente problemas formulados na linguagem do Cálculo — que envolve conceitos como continuidade, derivadas e integrais —, precisamos realizar um processo chamado discretização. Esse processo consiste em transformar variáveis, domínios e operações contínuas em versões finitas e manipuláveis por algoritmos. Contudo, essa transformação introduz inevitavelmente erros computacionais, que podem ser classificados em diversas categorias: erros de arredondamento, decorrentes da representação finita dos números; erros de truncamento, provenientes da aproximação de processos infinitos (como séries ou integrais) por expressões finitas; e erros algorítmicos ou de método, que surgem das escolhas específicas dos procedimentos numéricos adotados.

Compreender a origem, o comportamento e os impactos desses erros é fundamental para qualquer profissional que utiliza simulações numéricas ou algoritmos computacionais. Mais do que uma questão técnica, essa compreensão permite avaliar a confiabilidade dos resultados, projetar métodos mais robustos e, quando possível, minimizar os efeitos adversos da discretização. Em última análise, o estudo dos métodos numéricos é, em grande parte, um estudo sobre como transpor, com inteligência e controle, a fronteira que separa o contínuo idealizado da matemática do discreto real dos computadores.

Aritmética computacional¶

Computadores representam números inteiros de forma exata [Recorte 9: Aritmética exata e números racionais]. No entanto, a representação de números reais é sempre aproximada e limitada a um conjunto finito de valores. Essa limitação decorre da necessidade de codificar números contínuos em uma estrutura binária finita. A aritmética computacional, portanto, lida tanto com números inteiros quanto com os chamados números em ponto flutuante, que permitem representar aproximações de números reais.

O estudo da aritmética computacional concentra-se em dois aspectos fundamentais:

1. a representação dos números no formato de máquina, isto é, em base binária, com precisão e alcance finitos; e

2. o desenvolvimento de algoritmos capazes de realizar operações aritméticas fundamentais, como adição, subtração, multiplicação e divisão, de forma eficiente e consistente dentro dos limites impostos pelo hardware.

Métodos numéricos são, essencialmente, algoritmos que utilizam essas quatro operações como blocos fundamentais, aplicando-as de forma estruturada e sofisticada para resolver problemas matemáticos de interesse científico e de engenharia. Atualmente, o padrão IEEE 754 [Recorte 3: Padrão de Ponto Flutuante IEEE 754] é adotado globalmente pelos fabricantes de processadores. Esse padrão define as regras para a representação, as operações e os comportamentos dos números em ponto flutuante, assegurando portabilidade e previsibilidade dos cálculos entre diferentes arquiteturas, seja em 16, 32, 64 ou 128 bits. Sua primeira versão foi publicada em 1985, com a atualização mais recente ocorrendo em 2019 1.

Unidade Lógica e Aritmética¶

A Unidade Lógica e Aritmética (ULA) é a parte do hardware computacional conectada à unidade central de processamento (CPU) que realiza as operações aritméticas e lógicas sobre os dados processados (Figura 1). A ULA é um componente eletrônico que funciona segundo a lógica dos cicuitos digitais, ou seja, interpretando operações em lógica Booleana (and, or, not).

Há muito mais por trás das operações fundamentais executadas pelos computadores. Em Python, por exemplo, há casos de aproximações que chegam a ser curiosos. Isto ocorre devido ao erro inerente da representação numérica, principalmente quando os números são fracionários.

Casos curiosos¶

A aritmética de ponto flutuante possui situações inusitadas e respostas estranhas que podem levar-nos a duvidar se estamos realizando operações corretamente. Abaixo, mostramos alguns casos curiosos (coloquialmentem) que ocorrem devido à representação finita de números pelo computador. Outras indagações sobre ponto flutuante são respondidas em [Números em ponto flutuante e seus problemas].

• A fração $1/3 = 0.3333\ldots$ é uma dízima. O seu triplo é?

• A soma $0.3 + 0.3 + 0.3$ difere de 0.9.

• $1/10 + 1/10 + 1/10 \neq 3/10$

• Multiplicação por fracionários

A finitude explicada¶

Os casos acima possuem uma razão comum: a capacidade finita dos computadores para representar números fracionários. Vamos analisar de modo breve o caso da fração 1/10 sem nos aprofundar em detalhes.

Em um computador de arquitetura 64 bits que segue o padrão IEEE 754, a melhor aproximação para 1/10 é um número com 55 dígitos decimais.

Notemos que tentar aumentar os dígitos não produzirá significância:

Portanto, quando somamos 1/10 + 1/10 + 1/10 vemos um número diferente de 3/10.

Notação científica¶

Números em ponto flutuante são a versão computacional da notação científica. Escrevemos um número decimal em notação científica da seguinte forma:

com a fração (ou mantissa) $f$ determinando a precisão e o expoente $e$ a ordem de grandeza. Pontos flutuantes admitem $f$ na forma normalizada, isto é, menor do que 1. A tabela abaixo mostra alguns exemplos de como usamos essas notações.

Em termos de código Python – e em outras linguagen smte, a notação científica em base 10 pode ser realizada da seguinte forma:

Ponto flutuante: a reta “perfurada”¶

Desde os primórdios dos computadores mecânicos e eletrônicos, a precisão e a confiabilidade dos cálculos têm estado no centro das atenções e ambas são afetadas pelas discrepâncias entre números reais, infinitos e contínuos, e suas representações em máquina, finitas e discretas. Nas décadas de 1940 e 1950, houve uma clara percepção de que o sistema de ponto fixo, até então utilizado, era bastante limitado para dar precisão aos cálculos e que o aparato de hardware disponível na época era incapaz de lidar com situações de “sobrecarga” (overflow) ou “subfluxo” (underflow). Em outras palavras, representar números muito pequenos ou muito grandes, como 10^-30 ou 543.671³, era algo impensável.

Com a introdução da aritmética de ponto flutuante nos anos 1950 e 1960, os computadores passaram a representar uma quantidade significativa de números. Porém, o preço que se pagou por esse progresso foi a aparição de novos tipos de erros, como os erros de arredondamento, que ocorrem quando os números são aproximados para caber no formato de ponto flutuante. Mesmo com a implantação do padrão IEEE-754 em 1985, o qual uniformizou a representação e a manipulação de números em ponto flutuante, os erros inerentes não foram eliminados. A pesquisa em computação científica e de alto desempenho, reveladora de que os erros são obstinados, está bastante ativa e expandindo o conhecimento. Recentemente, um grupo de espanhois trouxe perspectivas promissoras para o formato posit64 2, uma alternativa potencialmente superior ao padrão IEEE-754. Através de diversos testes, eles concluíram que o sistema baseado na arquitetura RISC-V (quinta geração da Reduced Instruction Set Computer), oferece maior precisão, resiliência a erros de arredondamento e eficiência de armazenamento.

Em vez de operar sobre o conjunto dos números reais (conjunto $\mathbb{R}$), a matemática computacional está definida no domínio $\mathbb{F}$, o conjunto dos números em ponto flutuante representáveis pela máquina. Vejamos um exemplo.

Um sistema de ponto flutuante simplório em base binária, com apenas 3 dígitos de precisão e limites de underflow e overflow com expoentes variando de -1 a 2 possui 32 números representáveis, além do zero. Os 16 números positivos, derivados das mantissas 0.100, 0.101, 0.110 e 0.111, são os seguintes:

• $(0.100 \times 2^{-1})_{2} = (0.01)_2 = 0.2^0 + 0.2^{-1} + 1.2^{-2} = 1/4$

• $(0.100 \times 2^{0})_{2} = (0.1)_2 = 0.2^0 + 1.2^{-1} = 1/2$

• $(0.100 \times 2^{1})_{2} = (1.0)_2 = 1.2^0 + 0.2^{-1} = 1$

• $(0.100 \times 2^{2})_{2} = (10.0)_2 = 1.2^1 + 0.2^{1} + 0.2^{-1} = 2$

• $(0.101 \times 2^{-1})_{2} = (0.0101)_2 = 0.2^0 + 0.2^{-1} + 1.2^{-2} + 0.2^{-3} + 1.2^{-4}= 5/16$

• $(0.101 \times 2^{0})_{2} = (0.101)_2 = 0.2^0 + 1.2^{-1} + 0.2^{-2} + 1.2^{-3} = 5/8$

• $(0.101 \times 2^{1})_{2} = (1.01)_2 = 1.2^0 + 0.2^{-1} + 1.2^{-2} = 1$

• $(0.101 \times 2^{2})_{2} = (10.1)_2 = 1.2^1 + 0.2^{1} + 0.2^{-1} = 2$

(...)

Prosseguindo para os números restantes, obtemos a seguinte tabela:

Na reta real, esses valores ficariam dispostos da seguinte forma:

Isto é, $\mathbb{F}$ é uma reta “perfurada”, para a qual apenas 16 números positivos, 16 simétricos destes (que seriam refletidos na origem para o extremo negativo) e mais o 0 são representáveis. Logo, esse sistema seria capaz de representar apenas 33 números.

Simulador de $\mathbb{F}$¶

Clássicamente, um sistema de ponto flutuante é descrito por $\mathbb{F}(b, t, L, U)$, onde $b$ é a base (geralmente binária nos sistemas modernos), $t$ são os dígitos significativos da mantissa, que determina a precisão, $L$ é o menor expoente inteiro possível (que controal o limite de underflow) e $U$ é o maior expoente inteiro possível (que controla o limite de overflow). No exemplo acima, o sistema é $\mathbb{F}(2, 3, -1, 2)$.

O código abaixa gera uma reta perfurada para um sistema computacional de interesse.

Limites de máquina para ponto flutuante¶

Nos sistemas mais modernos, os parâmetros de $\mathbb{F}$ crescem vertiginosamente com o aumento dos bits (Tabela 1). A quantidade de números representáveis no Float64 é aproximadamente 1.84e19 apenas considerando os números normais.

(*) Nem todos os processadores oferecem suporte nativo para float128. É frequentemente implementado em software.

Em Python, podemos utilizar diferentes sistemas de ponto flutuante. Cada um possui suas particularidades. Os mais comuns são:

• float16 (meia precisão): ideal para aplicações onde a velocidade e o uso de memória são críticos, como em inferências de aprendizado profundo em dispositivos com recursos limitados.

• float32 (precisão simples): comumente usado em jogos, gráficos, e muitas aplicações de aprendizado de máquina devido ao bom equilíbrio entre precisão e eficiência.

• float64 (precisão dupla; alias para float): essencial para simulações científicas, finanças e outras áreas onde a precisão é crucial e a memória não é preocupação.

O numpy suporta todos os três na maioria dos computadores de hoje (Tabela 2).

A seguinte função imprime os valores dos principais atributos de numpy.finfo que nos ajudam a entender melhor os limites de máquina em Python para esses sistemas de ponto flutuante.

A partir daí, podemos verificar os valores para cada sistema individualmente:

O épsilon de máquina¶

A unidade de arredondamento, comumente chamada de “épsilon de máquina” e aqui denotada por $\epsilon_M$, é definida como o menor número positivo que, somado à unidade, produz um resultado diferente de 1 na máquina. Em termos matemáticos:

De outra forma, essa definição pode ser interpretada como: $\epsilon_M$ é a menor diferença entre 1 e o próximo número maior que pode ser representado no sistema numérico da máquina.

Para ilustrar este conceito, consideremos um sistema hipotético de 8 bits, no qual cada número é codificado como uma sequência de 8 dígitos binários, segundo a seguinte estrutura:

• 1 bit para o sinal;

• 3 bits para o expoente (com bias);

• 4 bits para a mantissa (ou parte fracionária).

Neste sistema, o número 1 em base decimal é representado pelo binário 00110000. O próximo número representável é 00110001, que corresponde ao valor decimal 1.0625. Assim, o épsilon de máquina para este sistema é:

Para este cálculo, utilizamos a fórmula geral de ponto flutuante: $x = (-1)^s 2^{(c - \text{bias})} \cdot (1 + f)$.

• O bias, para 3 bits de expoente, é calculado como: $\text{bias} = \frac{2^3 - 1}{2} = 3$

• No caso do número 1, os bits do expoente são 011, que correspondem ao valor: $c = (0) 2^2 + (1) 2^1 + (1) 2^0 = 3$

• Como o sinal é positivo $(s = 0)$ e a mantissa está zerada $(f = 0)$, o cálculo resulta em: $x = (1) 2^{(3-3)} (1 + 0) = 1$

A representação binária 00110000 corresponde, portanto, ao número decimal 1.

No próximo número representável, a menor alteração ocorre no bit menos significativo da mantissa, que vale $2^{-4} = 0.0625$. Isso significa que a sequência binária 00110001 representa: 1 + 0.0625 = 1.0625. Portanto, $\epsilon_M = 0.0625$. Se adicionarmos outro bit da mantissa (o segundo bit menos significativo), obteremos uma contribuição de $2^{-3} = 0.125$, que somada à anterior resulta em: 0.0625 + 0.125 = 0.1875. Assim, o número subsequente seria 1.1875, e a diferença entre 1.1875 e 1.0625 é 0.125, maior que $\epsilon_M$.

Esse exemplo evidencia um ponto fundamental: a unidade de arredondamento ($\epsilon_M$) não corresponde a uma “distância constante” na reta dos números reais. A densidade dos números representáveis na máquina não é uniforme — ela depende diretamente do valor do expoente. Assim, embora $\epsilon_M$ defina a menor diferença ao redor de 1, para números muito maiores ou muito menores, essa distância aumenta ou diminui exponencialmente, como a figura da reta perfurada anterior mostra.

Sensibilidade numérica¶

A sensibilidade numérica mede o quanto a saída de um problema ou algoritmo é afetada por pequenas variações na entrada. Se pequenas perturbações nos dados de entrada causam grandes variações na saída, dizemos que o problema (ou o algoritmo) é sensível, ou seja, mal condicionado. Se, ao contrário, a saída varia pouco frente a pequenas perturbações, dizemos que o problema é bem condicionado, portanto, pouco sensível.

Quando subtraímos 1 de valores de $\epsilon$ cada vez menores, a subtração no denominador da fração

começa a se aproximar de zero por cancelamento subtrativo e o valor de $f$ torna-se cada vez mais instável até cair a “zero”. O efeito de $\epsilon_M$ em cálculos pode ser mostrado na figura abaixo.

Valores e operações especiais¶

O padrão IEEE 754 traz alguns valores especiais para representar cadeias de bits especiais. São eles:

• NaN (not a number): representa um valor que é um erro.

• Inf (infinity): representa o infinito (em ambos os sentidos, positivo e negativo).

A partir desses valores especiais, operáveis pelo módulo numpy com numpy.nan e numpy.inf, respectivamente, podemos imitar operações matemáticas “equivalentes”. Primeiramente, façamos:

Em seguida, analisemos qual é o comportamento de algumas operações especiais:

• $n \div \pm \infty \to \pm 0, \ \ n \in \mathbb{F}$

• $\pm \infty \times \pm \infty \to \pm \infty$

• $n \div \pm 0 \to \ \ !, \ \ n \in \mathbb{F}^{*}$ (neste caso, teremos um erro de divisão por zero)

• $n \times \pm \infty \to \pm \infty, n \in \mathbb{F}$

• $\pm \infty \pm \infty \to \pm \infty \vee \text{nan}$

• $\pm 0 \div \pm 0 \to \ \ !$ (neste caso, também teremos um erro de divisão por zero)

• $\pm \infty \div \pm \infty \to \text{nan}$

• $\pm \infty \times 0 \to \text{nan}$

• $\text{nan} \neq \text{nan}$

Erros e seus efeitos¶

Credita-se a Alexander Pope (1688 - 1744), poeta inglês, a autoria do provérbio: “errar é humano; perdoar é divino” [phrases.org.uk]. Apesar de sua motivação, no século XVIII, ser o apontamento da indelével falibilidade humana – que Nicolau de Cusa (citado na epígrafe) via como elemento positivo para que a humanidade construa seu conhecimento gradativamente com percepção intelectual de sua insipiência –, esta máxima tem uma tênue relação com os diversos tipos de erros que persistem em cálculos realizados por máquinas. Discutiremos a seguir algumas definições de erros computacionais e como eles se manifestam ou se propagam em cálculos numéricos aplicáveis a qualquer área do conhecimento.

Motivação¶

Como forma de demonstrar que cômputos podem ter resultados distintos, consideremos a somatória (descendente, da maior para a menor parcela)

e a sua versão escrita de forma “refletida” (ascendente, da menor para a maior parcela), ou seja,

É evidente que $S_A(n)$ e $S_D(n)$ são matematicamente equivalentes e devem produzir o mesmo resultado independentemente de $n$ e do sentido em que forem somadas. Porém, vejamos o que acontece ao programarmos uma pequena função para computar ambas as formas.

Como se percebe pela última coluna, os valores produzidos pelas somas para $n > 10$ não são exatamente iguais. Embora existam diferenças ínfimas nos resultados, elas não são zero, assim indicando que a maneira como computamos expressões matemáticas cujos resultados são idênticos pode levar a resultados distintos. Ter-se $S_A(n) - S_D(n) \neq 0$ equivale a admitir a presença de um “erro” – ainda que ele seja pequeno e desprezível – cuja magnitude depende da escolha de $n$.

Naturalmente, se tomássemos a versão infinita de $S_D$ (ou $S_A$), chamando-a apenas de $S$ e substituindo $n$ por $\infty$, isto é,

tanto $S_D(n)$ e $S_A(n)$ seriam consideradas aproximações para $S$.

Supondo que somente $S_D(n)$ é a forma correta de “chegar perto” de $S$, a implicação

revelaria o acréscimo $\epsilon_n$ como uma quantidade não-nula coexistindo com o valor finito $n$. Uma vez que computadores são incapazes de calcular somas infinitas por limitação de memória, $\epsilon_n$ define um tipo de erro. Este erro é inerente ao processo de cálculo aproximado de séries infinitas. Além disso, ele dependerá de $n$, ou seja, da quantidade de termos utilizados na soma $S_D$ para aproximar o real valor de $S$.

Entretanto, estamos ainda diante de um problema de difícil tratamento, visto que a soma $S$ só pode ser obtida aproximadamente, pois $\sum_{k=1}^{\infty} \frac{1}{k}$ não é convergente. Logo, é impossível estabelecer um valor “exato” para $S$, a fim de compará-lo com suas aproximações. Caso intentássemos medir discrepâncias no cálculo desta série, teríamos que adotar um valor já aproximado para cumprir o papel de exato e utilizar outros valores também aproximados como “aproximações de uma aproximação”. Embora pareça estranho e paradoxal, o que acontece em muitas situações práticas quando lidamos com um processo iterativo ou de aproximações sucessivas é justamente isso.

Vamos tomar os valores da tabela de $S_D(n)$. Suponhamos que $S_D(100000) = 12.090146129863408$ assumisse o papel de valor “exato” de $S$. Fosse este o caso, poderíamos calcular pelo menos quatro erros:

Para obter cada valor acima, poderíamos escrever:

Não é difícil ver que o valor de $E$ em relação a $S_D(100000)$ aumenta quando tomamos valores de $n$ cada vez menores. Em outras palavras, nossas aproximações de um valor supostamente exato (aproximado) tornam-se cada vez mais pobres quando não dispomos de parcelas suficientes para somar. Além disso, usar $S_D(100000)$ como ponto de referência não é nada confiável, já que ele apenas fará com que tenhamos uma sensação ilusória de exatidão.

Se, em vez de uma série divergente, escolhermos outra, convergente, poderemos fazer cálculos de erro tomando como referência um valor definitivamente exato. Então, consideremos a série

A série $S_2$ ficou conhecida como Problema de Basel, proposto em 1650 pelo matemático italiano Pietro Mengoli, e solucionado por Leonhard Euler em 1734 – Basel é o nome de uma cidade da Suíça, onde Euler nasceu. Graças a Euler e a teoria matemática operante nos bastidores, existe certeza suficiente de que $S_2 = \frac{\pi^2}{6}$.

Do mesmo modo como fizemos no caso anterior, geraremos uma nova tabela para valores de $S_2(n)$ com $n$ crescente até o limite de 100.000, até porque não temos como computar $S_2$ ad infinitum. Então, vejamos um código similar:

Neste caso, a diferença existente na última coluna caracteriza, de fato, o erro real entre o valor exato $S_2$ e suas aproximações, de modo que, neste caso,

A partir daí, notamos que o erro reduz-se a quase zero à medida que o valor de $n$ aumenta, assim dando-nos uma constatação, pelo menos aproximada, de que a soma, de fato, é $\pi^2/6 \approx 1.6449340668482264$. Para obtermos os valores dos erros, um código similar poderia ser implementado:

Talvez não tenha sido percebido, mas, até aqui, já tratamos, conceitualmente, de três tipificações de erro, a saber:

1. erro de truncamento, quando limitamos o número de termos de uma expansão infinita, tornando-a finita.

2. erro real aproximado (ou erro verdadeiro aproximado), quando assumimos que o valor exato da expansão infinita (série divergente) é a soma obtida até a parcela $n$, com $n$ muito grande, mas finito, e calculamos a diferença entre este valor e a soma obtida até uma parcela anterior à $n$-ésima;

3. erro real (ou erro verdadeiro), quando calculamos a diferença entre a soma exata (série convergente) e a soma obtida até a parcela $n$.

Curioso, não? E não para por aí! Ainda há outras definições de erro. Veremos mais algumas no decorrer do curso.

Tipos de erros¶

Consideremos avaliar o polinômio $P(x) = 0.172x^3 - 0.878x^2 + 0.042x + 0.583$ no ponto $x=79.9$.

Vamos fazer o seguinte:

1. Assumir que 82132.957032 seja o valor exato para o polinômio em $x = 79.9$.

2. Calcular $P(79.9)$ utilizando duas formas.

Como se vê, a partir da 7a. casa decimal, começamos a notar uma leve diferença do valor do polinômio, embora ambas as formas, padrão de Hörner (estruturada), sejam matematicamente equivalentes. Embora os valores sejam próximos, a forma estruturada é uma opção menos custosa, sob o ponto de vista computacional, visto que ela possui menos avaliações de operações aritméticas.

A forma polinomial padrão, escrita de maneira ampliada, resulta em

ao passo que a forma de Hörner é escrita como:

Qual é a diferença entre ambas? O número de multiplicações (vermelho) e adições/subtrações (azul) é diferente. Enquanto na forma $P(x)$, temos 6 multiplicações e 3 adições/subtrações, a forma $P_H(x)$ reduz as operações para 3 multiplicações e 3 adições/subtrações. Isso é o mesmo que dizer que o número de operações aritméticas de multiplicação foi reduzido em 50%!

A conclusão é: a avaliação de polinômios pela forma de Hörner é mais lucrativa e propensa a um erro menor.

Erro real¶

O erro real (ou verdadeiro), $E$, não sinalizado, entre o valor exato $x$ e o aproximado $\hat{x}$ é dado por:

Note que, por convenção, se $E > 0$, erramos por superestimação (“excesso”). Por outro lado, se $E < 0$, erramos por subestimação (“omissão”).

Calculamos o erro real operando com diferença simples.

Utilizando o exemplo da seção anterior, temos:

Erro absoluto¶

O erro absoluto, $EA$, é a versão sinalizada de $E$. Dado por

ele ignora a condição de subestimação ou superestimação e se atém à diferença absoluta entre o valor exato e o valor aproximado.

A função módulo, $f(x) = | x |$, pode ser diretamente calculada com abs.

É evidente que $E_{PH} > E_P$. Entretanto, podemos verificar isso pelo seguinte teste lógico:

Erro relativo¶

O erro relativo, $ER$, aperfeiçoa a idea de erro absoluto a partir do momento que passa a considerar a ordem de grandeza das quantidades envolvidas, mensurando uma variação que se limita ao valor exato. Assim,

expressão que, devido à simetria da função módulo, pode ainda ser expandida para

Os erros relativos podem ser computados como:

Erro relativo percentual¶

O erro relativo percentual é outra forma útil de expressar a disparidade relativa entre valores. Ele é definido por:

Como não temos uma forma explícita de percentual, por cálculo, o melhor a fazer é algo como:

Erro relativo aproximado (benchmark)¶

Como vimos no exemplo motivacional deste capítulo, há casos (a maioria deles) em que não dispomos de valores exatos (obtidos por soluções analíticas, por exemplo), sendo possível estimar erros relativos apenas aproximadamente usando um valor de referência. Costuma-se chamar este valor de benchmark. Definido o benchmark por $x'$, o erro relativo aproximado é dado:

No exemplo da avaliação dos polinômios, se não dispuséssemos do valor exato, ou $P(x=79.9)$ ou $P_H(x=79.9)$ deveria ser adotado como benchmark. Se optássemos pelo segundo, apenas um erro relativo aproximado poderia ser calculado, a saber:

Erro relativo aproximado percentual¶

O erro relativo aproximado percentual é, meramente, a versão percentual do erro relativo aproximado, logo, dado por

Erro de cancelamento¶

O erro de cancelamento ocorre quando números de grandezas próximas são subtraídos. Como exemplo de situação crítica, induzimos uma divisão por zero usando o valor do épsilon de máquina $\epsilon_M$ ao fazer

Isto ocorre porque o denominador sofre um cancelamento subtrativo Uma vez que $0.25\epsilon_M < \epsilon_M$, a operação $0.25\epsilon_M$ não produz efeito sobre 1, de modo que a computação encontra um “limbo”. Para a matemática exata, a operação deveria ser “diferente de zero”.

Erros de truncamento e de arredondamento¶

O erro de truncamento está relacionado ao “corte” abrupto de dígitos de precisão em um valor numérico ou de parcelas em uma expansão infinita. No início do capítulo, exemplificamos como uma série pode ser aproximada truncando um ou mais termos de sua expansão.

No caso de números, o truncamento ocorre quando se ignora o valor da $k+1$-ésima casa decimal para finalidades de aproximação até a $k$-ésima casa. Por exemplo, se $x = 13.4256$, a aproximação de $x$ por truncamento até a terceira casa seria $x = 13.425$. O dígito 6 é ignorado nos cálculos.

No caso do arredondamento, o $k$-ésimo dígito é somado de 1 se o dígito da $k+1$-ésima casa for maior ou igual a 5. A aproximação de $x$ por arredondamento até a terceira casa seria $x = 13.426$, visto que o dígito 6 é maior do que 5. A regra de arredondamento é a que usamos no cotidiano.

Erros e funções de perda no contexto da inteligência artificial¶

Diversas definições de erro também existem no contexto da inteligência artificial (IA). Todavia, em modelos de IA, o conceito de erro está profundamente vinculado à diferença entre a saída produzida por um modelo e um valor considerado verdadeiro, chamado de “gabarito” (ground truth). O gabarito representa o conhecimento correto sobre um fenômeno, seja a classificação correta de uma imagem, o preço real de um imóvel, ou a demanda energética observada em determinado dia. O modelo, por sua vez, gera uma saída predita — e a diferença entre predição e realidade constitui o erro.

Essa diferença é quantificada por meio de uma função de perda (loss function), que mede o quão ruim uma predição foi em relação ao gabarito. Portanto, a conotação do erro nesse contexto é de uma métrica de desempenho. Várias métricas existem e tendem a expressar distâncias entre valores reais e valores preditos. A seguir, descrevemos algumas dessas métricas sob o ponto de vista de vetores no espaço de $n$ dimensões. Em todas as fórmulas, $\bf{x}$ é o vetor de dados reais, cuja $i$-ésima componente é representada por $x_i$, e $\bf{\hat{x}}$ é o vetor de dados preditos (aproximados), cuja $i$-ésima componente é representada por $\hat{x_i}$. Assim, $n$ reflete o número de pontos de amostragem.

Erro absoluto médio¶

O erro absoluto médio (mean absolute error, MAE) é definido como:

O MAE é útil quando queremos minimizar a soma das diferenças absolutas.

Erro quadrático médio¶

O erro quadrático médio (mean squared error, MSE) é definido como:

Erro absoluto médio percentual¶

O erro absoluto médio percentual (mean absolute percentage error, MAPE) é definido como:

Erro logarítmico quadrático médio¶

O erro logarítmico quadrático médio (mean squared logarithmic error, MSLE) é definido como:

Erro induzido pela norma $p$ e erro máximo¶

O MAE e o MSE, por exemplo, são casos particulares da definição genérica dada por:

para $p=1$ e $p=2$, respectivamente. Em particular, a chamada “norma do máximo” é definida por

que mede a maior diferença absoluta entre o vetor de valores reais e o vetor de valores preditos.

A norma $p$ é chamada de norma de Minkowski. As diferentes normas decorrentes da escolha de $p$ são usadas em contextos diferentes para medir mudanças específicas. Quanto maior é o valor de $p$, mais ela se concentra em captar discrepâncias maiores. Assim, normas menores são mais robustas a outliers. Quando $p=1$, temos a norma de Manhattan; quando $p=2$, temos a norma Euclidiana, bastante conhecida de outras disciplinas.

Calculando o desempenho¶

Usando a biblioteca scikit-learn, é possível utilizar funções já disponíveis no módulo sklearn.metrics para calcular essas métricas. Abaixo, utilizamos um exemplo genérico para um conjunto de valores reais e valores preditos associados aos reais para $n=4$. As plotagens resumem a dispersão entre valores reais e preditos e os erros dados por cada métrica.

Percebe-se que cada métrica retorna um valor diferente para o erro entre os valores exatos e os aproximados. Cabe ao usuário interpretar qual faz mais sentido para o conjunto de dados em análise.

Aplicações¶

Erros pontuais na função de Airy¶

A função de Airy é solução da equação de Schrödinger da mecânica quântica. Ela muda o seu comportamento de oscilatório para exponencial. A fim de demonstrar como o erro é uma função, dependente do ponto onde é avaliado, criaremos uma função “perturbada” que simulará o papel de função de Airy aproximada, enquanto manteremos a função de Airy verdadeira como exata. Em seguida, criaremos outra função de utilidade para calcular diretamente o erro relativo pontual.

Podemos usar o conceito de função anônima (lambda) para calcular diretamente o erro relativo para cada ponto $x$. Assim, seja:

onde $\hat{A}(x)$ é a função de Airy aproximada e $A(x)$ é a função de Airy exata. Então:

A seguir, mostramos a plotagem das funções exatas e aproximadas, bem como do erro relativo pontual.

Avaliação de algoritmos de ordenação¶

Vamos considerar um cenário em que estamos avaliando a eficiência de dois algoritmos de ordenação: o algoritmo de ordenação por inserção (insertion sort) e o algoritmo de ordenação rápida (quick sort). Suponha que temos um conjunto de dados com 10.000 elementos e queremos comparar o tempo de execução teórico e o medido para ambos os algoritmos.

Consideremos:

• $x$: tempo de execução teórico do algoritmo.

• $\hat{x}$: tempo de execução medido do algoritmo.

• $ER = 1 - \dfrac{\hat{x}}{x}$

O insertion sort possui complexidade teórica de $O(n^2)$. Consideremos que o tempo teórico para 10.000 elementos seja de 50 segundos. O quick sort possui complexidade teórica de $O(n \, \log \, n)$. Consideremos que o tempo teórico para 10.000 elementos seja de 2 segundos.

Após executar os algoritmos em uma máquina específica, suponhamos que tenhamos obtido os seguintes tempos de execução:

• insertion sort: 55 segundos.

• quick sort: 2.5 segundos.

O cálculo do erro relativo mostra que:

• insertion sort: $ER = 1 - \frac{55}{50} = 1 - 1.1 = -0.1 = -10\%$

• quick sort: $ER = 1 - \frac{2.5}{2} = 1 - 1.25 = -0.25 = -25\%$.

Ou seja, para o insertion sort, o erro relativo de -10% indica que o algoritmo demorou 10% mais do que o esperado, o que pode ser atribuído a fatores como sobrecarga de processamento ou otimizações que não foram realizadas. Para o quick sort, o erro relativo de -25% indica que o algoritmo demorou 25% mais do que o esperado, sugerindo que o algoritmo pode não ter se comportado da melhor maneira para este conjunto de dados específico, ou que a implementação usada não foi a mais eficiente.

Esses cálculos de erro relativo são essenciais para avaliar o desempenho dos algoritmos em ambientes reais, comparando-os com as expectativas teóricas. Eles ajudam a identificar discrepâncias que podem surgir devido a vários fatores, como características do hardware, implementações específicas do algoritmo, e peculiaridades dos dados de entrada.

Erros de precificação imobiliária por redes neurais¶

Vamos considerar um cenário onde estamos treinando uma rede neural para prever preços de imóveis com base em características como área, número de quartos, localização, etc. Para avaliar o desempenho da rede neural, usaremos o MSE e o MAE.

1. Dados do Conjunto de Treinamento e Teste

   • Temos um conjunto de dados com 1.000 amostras de preços de imóveis.

2. Treinamento da Rede Neural

   • A rede neural é treinada com um conjunto de treinamento e avaliada com um conjunto de teste.

3. Resultados do Conjunto de Teste

   • Valores reais dos preços dos imóveis: $\mathbf{x} = [200 \ \ 300 \ \ 250 \ \ 500 \ \ 400]^T$

   • Valores previstos pela rede neural $\mathbf{\hat{x}} = [210 \ \ 290 \ \ 240 \ \ 520 \ \ 410]^T$

4. Cálculo do MSE

$\text{MSE} = \frac{1}{5} \left[ (200 - 210)^2 + (300 - 290)^2 + (250 - 240)^2 + (500 - 520)^2 + (400 - 410)^2 \right]$

$\text{MSE} = \frac{1}{5} \left[ 100 + 100 + 100 + 400 + 100 \right] = \frac{1}{5} \times 800 = 160$

5. Cálculo do MAE

$\text{MAE} = \frac{1}{5} \left[ |200 - 210| + |300 - 290| + |250 - 240| + |500 - 520| + |400 - 410| \right]$

$\text{MAE} = \frac{1}{5} \left[ 10 + 10 + 10 + 20 + 10 \right] = \frac{1}{5} \times 60 = 12$

6. Interpretação dos Resultados

   • MSE: Um valor de 160 indica que, em média, os quadrados dos erros são relativamente altos. Como o MSE penaliza mais fortemente os grandes erros, este valor sugere que há algumas previsões com grandes discrepâncias.

   • MAE: Um valor de 12 indica que, em média, os erros absolutos entre as previsões e os valores reais são de 12 unidades monetárias. O MAE sendo menor que o MSE sugere que a maioria dos erros são pequenos, mas existem alguns grandes erros que estão influenciando o MSE.

   • Ajuste do Modelo: Se o MSE for muito maior que o MAE, isto pode indicar a presença de outliers que estão afetando negativamente o desempenho do modelo. Nesse caso, pode ser útil investigar os outliers e ajustar o modelo ou os dados de treinamento.

7. Avaliação de Desempenho

Ambas as métricas são úteis para avaliar a precisão do modelo, mas cada uma tem suas vantagens. O MSE é mais sensível a grandes erros, enquanto o MAE é mais intuitivo e menos sensível a outliers. O uso de MSE e MAE permite uma avaliação completa do desempenho de uma rede neural. Enquanto o MSE fornece uma visão detalhada dos erros grandes, o MAE oferece uma métrica mais robusta contra outliers, facilitando a interpretação dos resultados e a melhoria do modelo.