Sto usando sklearn e ho un problema con la propagazione dell'affinità. Ho costruito una matrice di input e continuo a ricevere il seguente errore.

ValueError: Input contains NaN, infinity or a value too large for dtype('float64').

Ho corso

np.isnan(mat.any()) #and gets False
np.isfinite(mat.all()) #and gets True

Ho provato a usare

mat[np.isfinite(mat) == True] = 0

per rimuovere i valori infiniti ma anche questo non ha funzionato. Cosa posso fare per eliminare i valori infiniti nella mia matrice, in modo da poter utilizzare l'algoritmo di propagazione dell'affinità?

Sto usando anaconda e python 2.7.9.

Questo potrebbe accadere all'interno di scikit e dipende da cosa stai facendo. Consiglio di leggere la documentazione per le funzioni che stai utilizzando. Potresti usarne uno che dipende, ad esempio, dal fatto che la tua matrice sia definita positiva e non soddisfi tali criteri.

EDIT : come potrei perderlo:

np.isnan(mat.any()) #and gets False
np.isfinite(mat.all()) #and gets True

è ovviamente sbagliato. Giusto sarebbe:

np.any(np.isnan(mat))

e

np.all(np.isfinite(mat))

Vuoi controllare se uno qualsiasi degli elementi è NaN e non se il valore restituito dalla anyfunzione è un numero ...

Ho ricevuto lo stesso messaggio di errore durante l'utilizzo di sklearn con i panda . La mia soluzione è ripristinare l'indice del mio dataframe dfprima di eseguire qualsiasi codice sklearn:

df = df.reset_index()

Ho riscontrato questo problema molte volte quando ho rimosso alcune voci nel mio df, ad esempio

df = df[df.label=='desired_one']

Questa è la mia funzione (sulla base di questo ) per pulire il set di dati di nan, Infe le cellule mancante (per insiemi di dati sghembi):

import pandas as pd

def clean_dataset(df):
    assert isinstance(df, pd.DataFrame), "df needs to be a pd.DataFrame"
    df.dropna(inplace=True)
    indices_to_keep = ~df.isin([np.nan, np.inf, -np.inf]).any(1)
    return df[indices_to_keep].astype(np.float64)

Le dimensioni del mio array di input erano distorte, poiché il mio input csv aveva spazi vuoti.

Questo è il controllo su cui fallisce:

• https://github.com/scikit-learn/scikit-learn/blob/0.17.X/sklearn/utils/validation.py#L51

Che dice

def _assert_all_finite(X):
    """Like assert_all_finite, but only for ndarray."""
    X = np.asanyarray(X)
    # First try an O(n) time, O(1) space solution for the common case that
    # everything is finite; fall back to O(n) space np.isfinite to prevent
    # false positives from overflow in sum method.
    if (X.dtype.char in np.typecodes['AllFloat'] and not np.isfinite(X.sum())
            and not np.isfinite(X).all()):
        raise ValueError("Input contains NaN, infinity"
                         " or a value too large for %r." % X.dtype)

Quindi assicurati di avere valori non NaN nel tuo input. E tutti questi valori sono in realtà valori float. Nessuno dei valori dovrebbe essere Inf.

Con questa versione di python 3:

/opt/anaconda3/bin/python --version
Python 3.6.0 :: Anaconda 4.3.0 (64-bit)

Guardando i dettagli dell'errore, ho trovato le righe di codici che causano l'errore:

/opt/anaconda3/lib/python3.6/site-packages/sklearn/utils/validation.py in _assert_all_finite(X)
     56             and not np.isfinite(X).all()):
     57         raise ValueError("Input contains NaN, infinity"
---> 58                          " or a value too large for %r." % X.dtype)
     59 
     60 

ValueError: Input contains NaN, infinity or a value too large for dtype('float64').

Da questo, sono stato in grado di estrarre il modo corretto per testare cosa stava succedendo con i miei dati utilizzando lo stesso test che non riesce dato dal messaggio di errore: np.isfinite(X)

Quindi, con un ciclo veloce e sporco, sono stato in grado di scoprire che i miei dati contengono effettivamente nans :

print(p[:,0].shape)
index = 0
for i in p[:,0]:
    if not np.isfinite(i):
        print(index, i)
    index +=1

(367340,)
4454 nan
6940 nan
10868 nan
12753 nan
14855 nan
15678 nan
24954 nan
30251 nan
31108 nan
51455 nan
59055 nan
...

Ora tutto quello che devo fare è rimuovere i valori in questi indici.

Ho riscontrato l'errore dopo aver provato a selezionare un sottoinsieme di righe:

df = df.reindex(index=my_index)

Risulta che my_indexconteneva valori che non erano contenuti in df.index, quindi la funzione di reindicizzazione ha inserito alcune nuove righe e le ha riempite con nan.

Nella maggior parte dei casi l'eliminazione di valori infiniti e nulli risolve questo problema.

sbarazzarsi di valori infiniti.

df.replace([np.inf, -np.inf], np.nan, inplace=True)

sbarazzarsi di valori nulli nel modo desiderato, valore specifico come 999, media o creare la propria funzione per imputare i valori mancanti

df.fillna(999, inplace=True)

Ho avuto lo stesso errore e nel mio caso X e y erano dataframe, quindi ho dovuto convertirli prima in matrici:

X = X.values.astype(np.float)
y = y.values.astype(np.float)

Modifica: X.as_matrix () originariamente suggerito è deprecato

ho ricevuto lo stesso errore. ha funzionato df.fillna(-99999, inplace=True)prima di fare qualsiasi sostituzione, sostituzione, ecc

Nel mio caso il problema era che molte funzioni di scikit restituiscono array numpy, che sono privi di indice panda. Quindi c'è stata una mancata corrispondenza dell'indice quando ho usato quegli array numpy per costruire nuovi DataFrame e poi ho provato a mescolarli con i dati originali.

Rimuovi tutti i valori infiniti:

(e sostituisci con min o max per quella colonna)

# find min and max values for each column, ignoring nan, -inf, and inf
mins = [np.nanmin(matrix[:, i][matrix[:, i] != -np.inf]) for i in range(matrix.shape[1])]
maxs = [np.nanmax(matrix[:, i][matrix[:, i] != np.inf]) for i in range(matrix.shape[1])]

# go through matrix one column at a time and replace  + and -infinity 
# with the max or min for that column
for i in range(log_train_arr.shape[1]):
    matrix[:, i][matrix[:, i] == -np.inf] = mins[i]
    matrix[:, i][matrix[:, i] == np.inf] = maxs[i]

provare

mat.sum()

Se la somma dei tuoi dati è infinita (maggiore del valore float massimo che è 3.402823e + 38) otterrai quell'errore.

vedere la funzione _assert_all_finite in validation.py dal codice sorgente di scikit:

if is_float and np.isfinite(X.sum()):
    pass
elif is_float:
    msg_err = "Input contains {} or a value too large for {!r}."
    if (allow_nan and np.isinf(X).any() or
            not allow_nan and not np.isfinite(X).all()):
        type_err = 'infinity' if allow_nan else 'NaN, infinity'
        # print(X.sum())
        raise ValueError(msg_err.format(type_err, X.dtype))