Mélanger les lignes DataFrame

J'ai le DataFrame suivant:

    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
...

Le DataFrame est lu à partir d'un fichier csv. Toutes les lignes qui ont Type1 sont en haut, suivies des lignes avec Type2, suivies des lignes avec Type3, etc.

Je voudrais mélanger l'ordre des lignes du DataFrame, afin que tous Typesoient mélangés. Un résultat possible pourrait être:

    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
...

Comment puis-je atteindre cet objectif?

La façon idiomatique de le faire avec Pandas est d'utiliser la .sampleméthode de votre dataframe pour échantillonner toutes les lignes sans remplacement:

df.sample(frac=1)

L' fracargument mot-clé spécifie la fraction de lignes à renvoyer dans l'échantillon aléatoire, ce qui frac=1signifie donc retourner toutes les lignes (dans un ordre aléatoire).

Remarque: Si vous souhaitez mélanger votre cadre de données en place et réinitialiser l'index, vous pouvez par exemple

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

Ici, la spécification drop=Trueempêche .reset_indexde créer une colonne contenant les anciennes entrées d'index.

Note de suivi: Bien qu'il ne puisse pas sembler que l'opération ci-dessus soit en place , python / pandas est assez intelligent pour ne pas faire un autre malloc pour l'objet mélangé. C'est-à-dire que même si l' objet de référence a changé (j'entends par là qu'il id(df_old)n'est pas le même que id(df_new)), l'objet C sous-jacent est toujours le même. Pour montrer que c'est effectivement le cas, vous pouvez exécuter un simple profileur de mémoire:

$ 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)

Vous pouvez simplement utiliser sklearn pour cela

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

Vous pouvez mélanger les lignes d'une trame de données en l'indexant avec un index mélangé. Pour cela, vous pouvez par exemple utiliser np.random.permutation(mais np.random.choicec'est aussi une 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

Si vous souhaitez conserver l'index numéroté de 1, 2, .., n comme dans votre exemple, vous pouvez simplement réinitialiser l'index: df_shuffled.reset_index(drop=True)

TL; DR : np.random.shuffle(ndarray)peut faire le travail.
Donc, dans ton cas

np.random.shuffle(DataFrame.values)

DataFrame, sous le capot, utilise NumPy ndarray comme support de données. (Vous pouvez vérifier à partir du code source DataFrame )

Donc, si vous utilisez np.random.shuffle(), cela mélange le tableau le long du premier axe d'un tableau multidimensionnel. Mais l'indice des DataFramerestes n'a pas été mélangé.

Cependant, il y a quelques points à considérer.

• la fonction ne renvoie aucun. Si vous souhaitez conserver une copie de l'objet d'origine, vous devez le faire avant de passer à la fonction.
• sklearn.utils.shuffle(), comme l'a suggéré l'utilisateur tj89, peut désigner random_stateune autre option pour contrôler la sortie. Vous voudrez peut-être cela à des fins de développement.
• sklearn.utils.shuffle()est plus rapide. Mais SHUFFLE les informations d'axe (index, colonne) du DataFrameavec le ndarraycontenu.

Résultat de référence

entre sklearn.utils.shuffle()et np.random.shuffle().

ndarray

nd = sklearn.utils.shuffle(nd)

0,10793248389381915 sec. 8x plus rapide

np.random.shuffle(nd)

0.8897626010002568 sec

Trame de données

df = sklearn.utils.shuffle(df)

0.3183923360193148 sec. 3x plus rapide

np.random.shuffle(df.values)

0.9357550159329548 sec

Conclusion: S'il est correct d'axer les informations (index, colonne) à mélanger avec ndarray, utilisez sklearn.utils.shuffle(). Sinon, utiliseznp.random.shuffle()

code utilisé

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)

pythonanalyse comparative

(Je n'ai pas assez de réputation pour commenter cela sur le premier post, donc j'espère que quelqu'un d'autre pourra le faire pour moi.) Il y avait une préoccupation soulevée que la première méthode:

df.sample(frac=1)

fait une copie complète ou juste changé le dataframe. J'ai exécuté le code suivant:

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

et mes résultats étaient:

0x1f8a784d400
0x1f8b9d65e10
0x1f8b9d65b70

ce qui signifie que la méthode ne renvoie pas le même objet, comme cela a été suggéré dans le dernier commentaire. Cette méthode fait donc une copie mélangée .

Ce qui est également utile, si vous l'utilisez pour Machine_learning et souhaitez toujours séparer les mêmes données, vous pouvez utiliser:

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

cela garantit que vous gardez votre choix aléatoire toujours reproductible

AFAIK la solution la plus simple est:

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

mélanger la trame de données pandas en prenant un échantillon de tableau dans ce cas index et randomiser son ordre puis définir le tableau comme un index de trame de données. Triez maintenant le bloc de données en fonction de l'index. Voilà votre cadre de données mélangé

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()

production

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

Insérez votre bloc de données à la place du mien dans le code ci-dessus.

Voici une autre façon:

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