Gelöst: Overflow Encountered in Double_Scalars in Python

1. Ursachen für den Fehler Überlauf in double_scalars in Python
2. Möglichkeiten zur Vermeidung des Fehlers Überlauf in double_scalars
3. Einige andere Überlaufwarnungen, die in Python auftreten
4. Abschluss

Doppelte Skalare, die unter dem Python-Bibliothekspaket Numpy definiert sind, sind ein Wert vom Datentyp Double. Dieser Datentyp wird zur Berechnung von Zahlen großer Größenordnung verwendet.

Oft wird die Größe dieser Zahlen so groß, dass das Programm in einen Überlaufzustand gerät und eine Warnung anzeigt Überlauf bei doppelten_Skalaren. Dieser Artikel erklärt den Überlauf in doppelten Skalaren, eine bestimmte Situation, die dieses Problem verursacht, und wie es gelöst werden kann.

Ursachen für den Fehler Überlauf in double_scalars in Python

Die Doppelskalare haben einen höheren und einen niedrigeren Bereich. Arithmetische Berechnungen mit kleineren Zahlen führen zu normalen Ergebnissen, aber wenn diese Zahlen über einen bestimmten Schwellenwert potenziert werden, tritt das Problem des Überlaufs bei doppelten_Skalaren auf.

Schauen wir uns ein Beispiel an, um es zu verstehen.

Dieses Programm zeigt den Bereich von Doppelskalaren, Berechnungen an der Grenze des Bereichs und dann den Punkt an, an dem der Überlauffehler auftritt; es zeigt die Warnung Überlauf in double_scalars an.

Das Programm importiert das Python-Paket numpy und setzt die Fehlerbehandlung auf all='warn', was bei Fehlern zur Laufzeit eine Warnung auslöst.

import numpy as np

np.seterr(all="warn")

Um den Bereich eines numpy-Datentyps zu finden, verwenden wir die Datentyp-Routine finfo. Diese Routine gibt, wenn sie aufgerufen wird, eine Grenze von Fließkommatypen wie Doppelskalar innerhalb des Systems zurück.

Um die untere Grenze eines doppelten Skalars zu finden, d. h. sein Minimum, ist eine Syntax wie - np.finfo(np.double).min erforderlich. In diesem Programm werden die Minimal- und Maximalwerte mit den Unterprogrammen min und max ermittelt.

print("Range of numpy double:", np.finfo(np.double).min, np.finfo(np.double).max)

Um die Werte am Rand des Bereichs zu finden, wird ein numpy-Array A vom Datentyp double erstellt. Dieses Array hat ein einzelnes Element mit dem Wert 143.

Der 0-te Indexwert wird in eine Variable a kopiert, um diesen Wert aus diesem Array mit sich selbst zu potenzieren. Diese Variable wird dann mit a**a potenziert.

A = np.array([143], dtype="double")
a = A[0]
print("At the border:", a ** a)

Das Programm läuft bis zum obigen Code korrekt, aber wenn eine Operation außerhalb des angegebenen Bereichs von Doppelskalaren ausgeführt wird, tritt ein Überlauf in double_scalars auf.

Es wird ein neues Array B erstellt, das einen größeren Wert speichert als der, der im vorherigen Array verwendet wurde, um diese Warnung zu reproduzieren.

Wenn dieser Wert mit sich selbst potenziert wird, zeigen Programme die Warnung Überlauf in doppelten_Skalaren an.

import numpy as np

np.seterr(all="warn")
print("Range of numpy double:", np.finfo(np.double).min, np.finfo(np.double).max)
A = np.array([143], dtype="double")
a = A[0]
print("At the border:", a ** a)
B = np.array([144], dtype="double")
b = B[-1]
print("Blowing out of range:", b ** b)

Ausgang:

C:/Users/Win 10/PycharmProjects/overflow_longscalars/2.py:11: RuntimeWarning: overflow encountered in double_scalars
  print("Blowing out of range:", b ** b)
Range of numpy double: -1.7976931348623157e+308 1.7976931348623157e+308
At the border: 1.6332525972973913e+308
Blowing out of range: inf

Möglichkeiten zur Vermeidung des Fehlers Überlauf in double_scalars

Wie im obigen Beispiel zu sehen ist, kann das Überschreiten des höchsten Bereichs eines Datentyps zu einem Überlauf in double_scalars führen. Der beste Weg, diesen Fehler zu vermeiden, besteht darin, innerhalb des angegebenen Bereichs zu arbeiten oder die Rechenleistung zu erhöhen.

Aber es gibt einige Fälle, in denen der Datentyp einen Engpass verursacht. Hier ist ein Programm, das die gleiche Warnung übermittelt.

Das erste Array vom Datentyp float32 läuft über, wenn der Wert 143 mit sich selbst potenziert wird. Dies geschieht, weil float bis zu 8 Bit Exponenten tragen kann.

Dagegen verträgt der Datentyp double eine Berechnung mit bis zu 11 Exponentenbits, weshalb er nicht in den Überlauf gerät und das Ergebnis liefert.

import numpy as np

np.seterr(all="warn")

A = np.array([143], dtype=np.float32)
a = A[-1]
print("Array with datatype float:", a ** a)
B = np.array([143], dtype=np.double)
b = B[-1]
print("Array with datatype double", b ** b)

Ausgang:

Das Programm läuft ähnlich wie bei den Doppelskalaren in einen Überlauf, wenn ein Programm versucht, a**a auszuführen, und am Ausgang inf anzeigt, was bedeutet, dass die Ergebnisse unendlich sind.

Allerdings erhalten wir das gewünschte Ergebnis, wenn unterschiedliche Datentypen verwendet werden.

Array with datatype float: inf
Array with datatype double 1.6332525972973913e+308
C:/Users/Win 10/PycharmProjects/overflow_longscalars/5.py:7: RuntimeWarning: overflow encountered in float_scalars
  print("Array with datatype float:", a ** a)

Einige Berechnungen verwenden unendlich, um die Ergebnisse auszudrücken, die außerhalb des Bereichs liegen, was bedeutet, dass das Ergebnis riesig ist.

Der Zahlenbereich für Datentypen wie float64 reicht von -1.79769313486e+308 bis 1.79769313486e+308. Es wird beobachtet, dass das Vergrößern oder Verkleinern einen Überlauf verursacht.

Wenn beispielsweise der maximale Bereich - np.double(1.79769313486e+308) mit 1.1 multipliziert wird, wird die Laufzeitwarnung Überlauf in double_scalars gefunden empfangen.

Es muss beachtet werden, dass dies nur eine Warnung ist und diese weiterläuft.

Da die Zahl jedoch zu groß wäre, kann sie keine zurückgeben. Stattdessen liefert es inf.

Obwohl einige gültige Berechnungen unendlich verwenden, erzeugen einige nan, was für keine Zahl steht, wie im folgenden Programm.

import numpy as np

var1 = np.inf - 10 ** 6
var2 = np.inf + 10 ** 6
var3 = np.inf / 10 ** 6
var4 = np.inf * 10 ** 6
var5 = np.inf * (-(10 ** 6))
var6 = 1 / np.inf
var7 = np.inf * np.inf
var8 = np.inf / np.inf
var9 = np.inf - np.inf

print(var1, var2, var3, var4, var5, var6, var7, var8, var9)

Ausgang:

inf inf inf inf -inf 0.0 inf nan nan

Das obige Programm zeigt alle möglichen Szenarien, in denen Unendlichkeit und nan auftreten können.

Manchmal geht ein Programm nicht in den Zustand des Überlaufs oder zeigt unendlich oder NaN an, sondern liefert Ergebnisse, die nicht nur ungenau, sondern erheblich falsch sind.

Im folgenden Beispiel wird ein Array A vom Datentyp int64 deklariert. Dieser Datentyp speichert je nach verwendeter Maschine unterschiedliche Bits.

Wenn ein in dieser Variablen gespeicherter Wert mit sich selbst potenziert wird, gibt das Programm unbedeutende Werte aus, anstatt einen Überlauf zu erleiden oder Unendlich anzuzeigen.

Beispielsweise sollte eine positive Ganzzahl wie 50, wenn sie mit sich selbst potenziert wird, eine positive Ganzzahl ergeben, aber wenn der folgende Code ausgeführt wird, ist das Ergebnis ein negativer Wert.

import numpy as np

np.seterr(all="warn")
A = np.array([50], dtype=np.int64)
a = A[-1]
print(a ** a)

Ausgang:

-6646187150092009472

Aber wir erhalten das passende Ergebnis, wenn derselbe Wert in einem Datentyp wie double oder longdouble gespeichert wird.

import numpy as np

np.seterr(all="warn")
A = np.array([50], dtype=np.longdouble)
a = A[-1]
print(a ** a)

Ausgang:

8.881784197001252e+84

Hinweis: Es ist zu beachten, dass die Laufzeitwarnung Überlauf bei double_scalars nur so lange umgangen werden kann, bis die Zahlen im Bereich des Datentyps liegen.

Obwohl das Verlassen dieses Bereichs das Programm nicht unterbricht und einen Fehler erzeugt, kann das Ignorieren der Warnung Überlauf in doppelten_Skalaren auf Kosten instabiler Ergebnisse gehen.

Einige andere Überlaufwarnungen, die in Python auftreten

In diesem Abschnitt lernen wir, andere Überlauffehler als Doppelskalare abzufangen. Es gibt hauptsächlich zwei andere Überläufe, die häufig auftreten.

1. Überlauf bei power

   Wenn die numpy-Subroutine power verwendet wird, um eine Zahl mit sich selbst zu potenzieren, und das Ergebnis ausserhalb des Bereichs liegt, wird der Fehler Überlauf in Potenz festgestellt ausgegeben.

   import numpy as np
   
   np.seterr(all="warn")
   print(np.power(143, 144, dtype=np.double))
   

   Ausgang:

   inf
   C:/Users/main.py:12: RuntimeWarning: overflow encountered in power
   print(np.power(143, 144, dtype=np.double))
   

2. Überlauf in exp festgestellt

   Diese Art von Überlauf tritt bei Operationen mit Exponenten auf. Das Potenzieren einer Zahl mit großen Exponenten ergibt inf, während das Teilen durch diese Zahl eine Null ergibt.

   import numpy as np
   
   print(1 * (1 + np.exp(1140)))
   print(1 / (1 + np.exp(1140)))
   

   Ausgang:

   inf
   0.0
   C:/Users/main.py:7: RuntimeWarning: overflow encountered in exp
   print(1*(1+np.exp(1140)))
   C:/Users/main.py:8: RuntimeWarning: overflow encountered in exp
   print(1/(1+np.exp(1140)))
   

Abschluss

Dieser Artikel erklärt, wie Laufzeitwarnungen wie Überlauf in double_scalars usw. umgangen werden können. Nachdem der Leser diesen Artikel durchgearbeitet hat, kann der Leser leicht Überlauffehler erkennen.