Comment puis-je attraper un numpy avertissement comme c'est une exception (pas juste pour le test)?

Je dois faire un polynôme de Lagrange en Python pour un projet que je suis en train de faire. Je suis en train de faire un barycentriques le style d'éviter l'utilisation explicite d'une boucle for, par opposition à un Newton est divisé différence de style. Le problème que j'ai c'est que j'ai besoin d'attraper une division par zéro, mais en Python (ou peut-être numpy) il fait juste un avertissement au lieu d'une normale exception.

Donc, ce que j'ai besoin de savoir comment le faire est de prendre cet avertissement, comme si c'était une exception. Les questions liées à ce que j'ai trouvé sur ce site ont répondu à pas dans la façon dont j'avais besoin. Voici mon code:

import numpy as np
import matplotlib.pyplot as plt
import warnings

class Lagrange:
    def __init__(self, xPts, yPts):
        self.xPts = np.array(xPts)
        self.yPts = np.array(yPts)
        self.degree = len(xPts)-1 
        self.weights = np.array([np.product([x_j - x_i for x_j in xPts if x_j != x_i]) for x_i in xPts])

    def __call__(self, x):
        warnings.filterwarnings("error")
        try:
            bigNumerator = np.product(x - self.xPts)
            numerators = np.array([bigNumerator/(x - x_j) for x_j in self.xPts])
            return sum(numerators/self.weights*self.yPts) 
        except Exception, e: # Catch division by 0. Only possible in 'numerators' array
            return yPts[np.where(xPts == x)[0][0]]

L = Lagrange([-1,0,1],[1,0,1]) # Creates quadratic poly L(x) = x^2

L(1) # This should catch an error, then return 1.

Lorsque ce code est exécuté, le résultat que j'obtiens est:

Warning: divide by zero encountered in int_scalars

C'est l'avertissement que j'ai envie de l'attraper. Il devrait se produire à l'intérieur de la compréhension de liste.

Êtes-vous bien sûr que c'est Warning: ...? Essayer des choses comme np.array([1])/0 - je obtenir RuntimeWarning: ... en sortie.
Pas un doublon; NumPy a son propre avertissement de l'architecture sur le dessus de Pythons, qui peut être précisément contrôlée (voir la réponse par Bakuríu).
Je corrige la position des mains et appris une nouvelle chose. J'ai supprimé mon commentaire d'origine pour éviter le déclenchement de l'insigne de la collection de la frénésie.
Une autre approche que l'on pourrait utiliser est tout simplement de vérifier si le dénominateur est de 0 avant la division, ce qui évite la surcharge de jongler avec numpy du système d'alerte. (Bien que cela signifie probablement que vous avez à développer neat compréhension de liste dans une boucle de vérifier si l'un des dénominateurs est égale à zéro.)

InformationsquelleAutor John K. | 2013-04-10

179

Il semble que votre configuration est à l'aide de la print option pour numpy.seterr:
```
>>> import numpy as np
>>> np.array([1])/0   #'warn' mode
__main__:1: RuntimeWarning: divide by zero encountered in divide
array([0])
>>> np.seterr(all='print')
{'over': 'warn', 'divide': 'warn', 'invalid': 'warn', 'under': 'ignore'}
>>> np.array([1])/0   #'print' mode
Warning: divide by zero encountered in divide
array([0])
```
Cela signifie que l'avertissement que vous voyez est pas un avertissement réel, mais c'est juste des caractères imprimés à stdout(voir la documentation de seterr). Si vous voulez l'attraper, vous pouvez:
1. Utilisation numpy.seterr(all='raise') qui va directement à lever l'exception. Toutefois, cela change le comportement de toutes les opérations, donc c'est vraiment un grand changement dans son comportement.
2. Utilisation numpy.seterr(all='warn'), qui va transformer l'imprimé avertissement un avertissement réel et vous serez en mesure d'utiliser la solution ci-dessus pour localiser ce changement de comportement.
Une fois que vous avez réellement un avertissement, vous pouvez utiliser le warnings module pour contrôler la façon dont les mises en garde doivent être traités:
```
>>> import warnings
>>> 
>>> warnings.filterwarnings('error')
>>> 
>>> try:
...     warnings.warn(Warning())
... except Warning:
...     print 'Warning was raised as an exception!'
... 
Warning was raised as an exception!
```
Lire attentivement la documentation de filterwarnings car elle permet de filtrer uniquement l'avertissement que vous voulez et a d'autres options. Je voudrais également envisager de chercher à catch_warnings qui est un gestionnaire de contexte qui entraîne la réinitialisation automatique de l'original filterwarnings fonction:
```
>>> import warnings
>>> with warnings.catch_warnings():
...     warnings.filterwarnings('error')
...     try:
...         warnings.warn(Warning())
...     except Warning: print 'Raised!'
... 
Raised!
>>> try:
...     warnings.warn(Warning())
... except Warning: print 'Not raised!'
... 
__main__:2: Warning: 
```
- Je pense que c'est un début. Mais il ne fait pas régler mon problème. Si j'ajoute les avertissements.warn(Avertissement())) dans mon code dans le bloc try, il va prendre l'avertissement. Pour une raison quelconque, il ne l'attrape pas la division par zéro avertissement. Voila exactement le message d'erreur: warning: division par zéro rencontrées dans int_scalars
- Vous devez éditer votre question et ajouter la sortie exacte, sinon on ne peut dire quel est le problème. à possible que numpy définit cet avertissement de classe quelque part et que vous avez à discovere dans lequel les sous-paquetage pour être en mesure de l'attraper. Jamais l'esprit, j'ai découvert que vous devez utiliser RuntimeWarning. Mise à jour de la réponse.
- Êtes-vous sûr? J'ai modifié mon code pour l'utiliser, sauf RuntimeWarning:. Il ne fonctionne toujours pas =/
- Dans la documentation il déclare qu'un RuntimeWarning est soulevée. Le problème est peut-être que votre numpy configuration à l'aide de la print option, qui imprime simplement l'avertissement, mais ce n'est pas un avertissement réel manipulé par le warnings module... Si c'est le cas vous pouvez essayer d'utiliser numpy.seterr(all='warn') et essayez de nouveau.
- Dans ma version de numpy, vous ne pouvez pas utiliser numpy.seterr(all='error'), error doit être raise.
- Oui, vous avez raison. Je ne me souviens pas si les anciennes versions permis 'error' au lieu de cela, si j'ai écrit que, parce que j'ai été distrait.
InformationsquelleAutor Bakuriu
35

D'ajouter un peu d' @Bakuriu réponse:

Si vous savez déjà où l'avertissement est susceptible de se produire alors qu'il est souvent plus propre d'utiliser la numpy.errstate gestionnaire de contexte, plutôt que de numpy.seterr qui traite de toutes les mises en garde du même type, la même quel que soit l'endroit où ils se produisent dans votre code:
```
import numpy as np

a = np.r_[1.]
with np.errstate(divide='raise'):
    try:
        a / 0   # this gets caught and handled as an exception
    except FloatingPointError:
        print('oh no!')
a / 0           # this prints a RuntimeWarning as usual
```
Edit:

Dans mon exemple j'ai eu a = np.r_[0], mais apparemment, il y avait un changement dans numpy du comportement, tels que la division par zéro est traitée différemment dans les cas où le numérateur est tous des zéros. Par exemple, dans numpy 1.16.4:
```
all_zeros = np.array([0., 0.])
not_all_zeros = np.array([1., 0.])

with np.errstate(divide='raise'):
    not_all_zeros / 0.  # Raises FloatingPointError

with np.errstate(divide='raise'):
    all_zeros / 0.  # No exception raised

with np.errstate(invalid='raise'):
    all_zeros / 0.  # Raises FloatingPointError
```
Le correspondant des messages d'avertissement sont également différents: 1. /0. est enregistré comme RuntimeWarning: divide by zero encountered in true_divide, alors que 0. /0. est enregistré comme RuntimeWarning: invalid value encountered in true_divide. Je ne sais pas exactement pourquoi ce changement a été fait, mais je soupçonne que cela a à voir avec le fait que le résultat de 0. /0. n'est pas représentable comme un nombre (numpy renvoie NaN dans ce cas) alors que 1. /0. et -1. /0. retour +Inf et -Inf, respectivement, par l'IEE 754 la norme.

Si vous voulez attraper les deux types d'erreur, vous pouvez toujours passer np.errstate(divide='raise', invalid='raise'), ou all='raise' si vous voulez soulever l'exception d'un tout sorte de virgule flottante erreur.
- En particulier, il soulève FloatingPointError, pas ZeroDivisionError.
- Cela ne fonctionne pas sur Python 3.6.3 avec numpy==1.16.3. Pourriez-vous le mettre à jour s'il vous plaît?
- Apparemment, il y avait un changement dans numpy comportement qui signifie division par zéro est maintenant gérée différemment selon que le numérateur est aussi (tous) à zéro.
InformationsquelleAutor ali_m
26

D'élaborer sur @Bakuriu la réponse ci-dessus, j'ai trouvé que cela me permet de rattraper un moteur d'exécution d'avertissement d'une manière similaire à la façon dont je voudrais prendre un avertissement d'erreur, l'impression de l'avertissement de bien:
```
import warnings

with warnings.catch_warnings():
    warnings.filterwarnings('error')
    try:
        answer = 1 / 0
    except Warning as e:
        print('error found:', e)
```
Vous aurez probablement être en mesure de jouer avec la mise en place des avertissements.catch_warnings() de placement en fonction de la taille d'un parapluie que vous voulez jeter par la capture des erreurs de cette façon.
- réponse = 1 / 0 déclenchera une erreur de façon indépendante, vous risquez de vous donner un exemple correct...
InformationsquelleAutor ntk4
4

Supprimer les avertissements.filterwarnings et d'ajouter:
```
numpy.seterr(all='raise')
```
InformationsquelleAutor Shital Shah

Vous devez vous connecter pour publier un commentaire.

Edit: