Shuffle DataFrame righe

Ho il seguente DataFrame:

    Col1  Col2  Col3  Type
0      1     2     3     1
1      4     5     6     1
...
20     7     8     9     2
21    10    11    12     2
...
45    13    14    15     3
46    16    17    18     3
...

DataFrame viene letto da un file CSV. Tutte le righe che hanno Type1 sono in cima, seguite dalle righe con Type2, seguite dalle righe con Type3, ecc.

Vorrei mescolare l'ordine delle righe del DataFrame, in modo che tutto Typesia mescolato. Un possibile risultato potrebbe essere:

    Col1  Col2  Col3  Type
0      7     8     9     2
1     13    14    15     3
...
20     1     2     3     1
21    10    11    12     2
...
45     4     5     6     1
46    16    17    18     3
...

Come posso raggiungere questo obiettivo?

Il modo idiomatico per farlo con Pandas è utilizzare il .samplemetodo del tuo frame di dati per campionare tutte le righe senza sostituzione:

df.sample(frac=1)

L' fracargomento della parola chiave specifica la frazione di righe da restituire nel campione casuale, quindi frac=1significa restituire tutte le righe (in ordine casuale).

Nota: se si desidera mescolare il proprio frame di dati sul posto e ripristinare l'indice, è possibile farlo ad es

df = df.sample(frac=1).reset_index(drop=True)

Qui, specificando si drop=Trueimpedisce la .reset_indexcreazione di una colonna contenente le vecchie voci di indice.

Nota di follow-up: anche se potrebbe non sembrare che l'operazione sopra sia in atto , python / panda è abbastanza intelligente da non fare un altro malloc per l'oggetto mischiato. Cioè, anche se l' oggetto di riferimento è cambiato (per cui intendo id(df_old)non è lo stesso di id(df_new)), l'oggetto C sottostante è sempre lo stesso. Per dimostrare che questo è davvero il caso, è possibile eseguire un semplice profiler di memoria:

$ python3 -m memory_profiler .\test.py
Filename: .\test.py

Line #    Mem usage    Increment   Line Contents
================================================
     5     68.5 MiB     68.5 MiB   @profile
     6                             def shuffle():
     7    847.8 MiB    779.3 MiB       df = pd.DataFrame(np.random.randn(100, 1000000))
     8    847.9 MiB      0.1 MiB       df = df.sample(frac=1).reset_index(drop=True)

Puoi semplicemente usare sklearn per questo

from sklearn.utils import shuffle
df = shuffle(df)

È possibile mescolare le righe di un frame di dati indicizzando con un indice mischiato. Per questo, puoi ad esempio usare np.random.permutation(ma np.random.choiceè anche una possibilità):

In [12]: df = pd.read_csv(StringIO(s), sep="\s+")

In [13]: df
Out[13]: 
    Col1  Col2  Col3  Type
0      1     2     3     1
1      4     5     6     1
20     7     8     9     2
21    10    11    12     2
45    13    14    15     3
46    16    17    18     3

In [14]: df.iloc[np.random.permutation(len(df))]
Out[14]: 
    Col1  Col2  Col3  Type
46    16    17    18     3
45    13    14    15     3
20     7     8     9     2
0      1     2     3     1
1      4     5     6     1
21    10    11    12     2

Se vuoi mantenere l'indice numerato da 1, 2, .., n come nell'esempio, puoi semplicemente reimpostare l'indice: df_shuffled.reset_index(drop=True)

TL; DR : np.random.shuffle(ndarray)può fare il lavoro.
Quindi, nel tuo caso

np.random.shuffle(DataFrame.values)

DataFrame, sotto il cofano, utilizza NumPy ndarray come titolare dei dati. (Puoi controllare dal codice sorgente DataFrame )

Quindi, se lo usi np.random.shuffle(), mescolerebbe l'array lungo il primo asse di un array multidimensionale. Ma l'indice dei DataFrameresti non mischiato.

Tuttavia, ci sono alcuni punti da considerare.

• la funzione non restituisce nessuna. Nel caso in cui si desideri conservare una copia dell'oggetto originale, è necessario farlo prima di passare alla funzione.
• sklearn.utils.shuffle(), come suggerito dall'utente tj89, può designare random_stateinsieme a un'altra opzione per controllare l'output. Potresti volerlo a scopo di sviluppo.
• sklearn.utils.shuffle()è più veloce. Ma SHUFFLE le informazioni sull'asse (indice, colonna) del DataFrameinsieme con ndarrayesso contiene.

Risultato del benchmark

tra sklearn.utils.shuffle()e np.random.shuffle().

ndarray

nd = sklearn.utils.shuffle(nd)

0,10793248389381915 sec. 8 volte più veloce

np.random.shuffle(nd)

0,8897626010002568 sec

dataframe

df = sklearn.utils.shuffle(df)

0,3183923360193148 sec. 3 volte più veloce

np.random.shuffle(df.values)

0.9357550159329548 sec

Conclusione: se va bene mescolare le informazioni degli assi (indice, colonna) insieme a ndarray, usare sklearn.utils.shuffle(). Altrimenti, usanp.random.shuffle()

codice usato

import timeit
setup = '''
import numpy as np
import pandas as pd
import sklearn
nd = np.random.random((1000, 100))
df = pd.DataFrame(nd)
'''

timeit.timeit('nd = sklearn.utils.shuffle(nd)', setup=setup, number=1000)
timeit.timeit('np.random.shuffle(nd)', setup=setup, number=1000)
timeit.timeit('df = sklearn.utils.shuffle(df)', setup=setup, number=1000)
timeit.timeit('np.random.shuffle(df.values)', setup=setup, number=1000)

pitoneAnalisi comparativa

(Non ho abbastanza reputazione per commentare questo post in alto, quindi spero che qualcun altro possa farlo per me.) È emersa la preoccupazione che il primo metodo:

df.sample(frac=1)

fatto una copia profonda o appena cambiato il dataframe. Ho eseguito il seguente codice:

print(hex(id(df)))
print(hex(id(df.sample(frac=1))))
print(hex(id(df.sample(frac=1).reset_index(drop=True))))

e i miei risultati sono stati:

0x1f8a784d400
0x1f8b9d65e10
0x1f8b9d65b70

il che significa che il metodo non sta restituendo lo stesso oggetto, come suggerito nell'ultimo commento. Quindi questo metodo fa davvero una copia mescolata .

Ciò che è utile, se lo usi per Machine_learning e vuoi separare sempre gli stessi dati, puoi usare:

df.sample(n=len(df), random_state=42)

questo assicura che la scelta casuale rimanga sempre replicabile

AFAIK la soluzione più semplice è:

df_shuffled = df.reindex(np.random.permutation(df.index))

mescolare il frame di dati panda prendendo un array di esempio in questo caso indice e randomizzare il suo ordine, quindi impostare l'array come indice del frame di dati. Ora ordina il frame di dati in base all'indice. Ecco qui il tuo dataframe mischiato

import random
df = pd.DataFrame({"a":[1,2,3,4],"b":[5,6,7,8]})
index = [i for i in range(df.shape[0])]
random.shuffle(index)
df.set_index([index]).sort_index()

produzione

    a   b
0   2   6
1   1   5
2   3   7
3   4   8

Inserisci il tuo frame di dati al posto mio nel codice sopra.

Ecco un altro modo:

df['rnd'] = np.random.rand(len(df)) df = df.sort_values(by='rnd', inplace=True).drop('rnd', axis=1)