Eccezione imprevista in numpy.isfinite()

Question

Ricevo questa eccezione per un motivo che non capisco. E 'abbastanza complicato, dove il mio np.array v proviene, ma qui è il codice quando si verifica l'eccezione:

print v, type(v) 

for val in v: 
    print val, type(val) 

print "use isfinte() with astype(float64): " 
np.isfinite(v.astype("float64")) 

print "use isfinite() as usual: " 
try: 
    np.isfinite(v) 
except Exception,e: 
    print e 

Questo dà il seguente risultato:

[6.4441947744288255 7.2246449651781788 4.1028442021807656 
4.8832943929301189] <type 'numpy.ndarray'> 

6.44419477443 <type 'numpy.float64'> 
7.22464496518 <type 'numpy.float64'> 
4.10284420218 <type 'numpy.float64'> 
4.88329439293 <type 'numpy.float64'> 

np.isfinte() with astype(float64): 
[ True True True True] 

np.isfinte() as usual: 
ufunc 'isfinite' not supported for the input types, and the inputs could not be safely coerced to any supported types according to the casting rule ''safe'' 

Non capisco il TypeError . Tutti gli elementi sono np.float64 e dovrebbero andare bene. Forse un bug? Questo errore si verifica solo a volte, ma non riesco a trovare differenze tra gli array. Hanno sempre lo stesso tipo.

Grazie in anticipo.

EDIT: Esempio di funzionamento:

strutture dati sono piccoli come indicato sopra.

import pandas as pd 
import numpy as np 


def forward_estim(H,end): 

    old_idx = H.index 
    new_idx = pd.period_range(old_idx[-1],end,freq=old_idx.freq) 

    H_estim = pd.DataFrame(columns=["A","B","C","D"],index=new_idx) 

    H_chg = H.values[1:]-H.values[:-1] 
    mean_ = H_chg.mean() 
    std_ = H_chg.std() 

    H_estim.ix[0] = H.ix[-1] 

    for i in range(1,len(H_estim)): 
     H_estim.A[i] = H_estim.A[i-1] + mean_ + std_/2 
     H_estim.B[i] = H_estim.B[i-1] + mean_ + std_ 
     H_estim.C[i] = H_estim.C[i-1] + mean_ - std_ 
     H_estim.D[i] = H_estim.D[i-1] + mean_ - std_/2 

    return H_estim.ix[1:] 


H_idx = pd.period_range("2010-01-01","2012-01-01",freq="A") 
print H_idx 

H = pd.Series(np.array([2.3,3.0,2.9]),index=H_idx) 
print H 

H_estim = forward_estim(H,"2014-01-01") 
print H_estim 

np.isfinite(H_estim.values.astype("float64")) 
print "This works!" 

np.isfinite(H_estim.values) 
print "This does not work!" 

Questo è gestito qui utilizzando:

MacOsX Mavericks, Python 2.7.6, 1.8.1 NumPy, panda 0.13.1

Answer 1

H_estim.values è una matrice numpy con il tipo di dati object (dare un'occhiata a H_estim.values.dtype):

In [62]: H_estim.values 
Out[62]: 
array([[3.4000000000000004, 3.6000000000000005, 2.7999999999999998, 3.0], 
     [3.9000000000000004, 4.3000000000000007, 2.6999999999999993, 
     3.0999999999999996]], dtype=object) 

In [63]: H_estim.values.dtype 
Out[63]: dtype('O') 

in una matrice object, i dati memorizzati nella memoria del dell'array sono puntatori a oggetti Python, non gli oggetti stessi. In questo caso, gli oggetti sono np.float64 casi:

In [65]: H_estim.values[0,0] 
Out[65]: 3.4000000000000004 

In [66]: type(H_estim.values[0,0]) 
Out[66]: numpy.float64 

Così, sotto molti aspetti, questa matrice sembra e si comporta come un array di np.float64 valori, ma non è lo stesso. In particolare, gli infiniti ufunc (incluso np.isfinite) non gestiscono gli array di oggetti.

H_estim.values.astype(np.float64) converte l'array in uno con il tipo di dati np.float64 (ovvero un array in cui gli elementi dell'array sono i valori effettivi in ​​virgola mobile, non i puntatori agli oggetti). Confrontate quanto segue con l'output mostrato sopra per H_estim.values.

In [70]: a = H_estim.values.astype(np.float64) 

In [71]: a 
Out[71]: 
array([[ 3.4, 3.6, 2.8, 3. ], 
     [ 3.9, 4.3, 2.7, 3.1]]) 

In [72]: a.dtype 
Out[72]: dtype('float64') 

Answer 2

utente si assume che "Tutti gli elementi sono np.float64 e dovrebbe andare bene ". Tuttavia, questo probabilmente non è il caso. Quanto è grande la struttura dei dati? Puoi guardare tutti i valori e trovare qualcosa di sospetto? Da http://matplotlib.1069221.n5.nabble.com/type-error-with-python-3-2-and-version-1-1-1-of-matplotlib-numpy-error-td38784.html vediamo che questo problema potrebbe apparire con i tipi di dati Decimal. C'è un modo per creare un esempio di lavoro minimo che riproduca il problema? Dovrebbe essere possibile e, quando crei questo esempio, molto probabilmente verrà già individuato il problema.