les pandas de roulement calcul avec fenêtre basée sur les valeurs au lieu de compte

Je suis à la recherche d'un moyen de faire quelque chose comme les différents rolling_* fonctions de pandas, mais je veux que la fenêtre des rolling calcul défini par un intervalle de valeurs (par exemple, une plage de valeurs d'une colonne d'un DataFrame), pas par le nombre de lignes dans la fenêtre.

Comme un exemple, supposons que j'ai ces données:

>>> print d
   RollBasis  ToRoll
0          1       1
1          1       4
2          1      -5
3          2       2
4          3      -4
5          5      -2
6          8       0
7         10     -13
8         12      -2
9         13      -5

Si je fais quelque chose comme rolling_sum(d, 5), je reçois un roulement somme dont chaque fenêtre contient 5 lignes. Mais ce que je veux, c'est un roulement somme dont chaque fenêtre contient une certaine gamme de valeurs de RollBasis. C'est que j'aimerais être en mesure de faire quelque chose comme d.roll_by(sum, 'RollBasis', 5), et d'obtenir un résultat où la première fenêtre contient toutes les lignes dont le RollBasis est entre 1 et 5, puis la deuxième fenêtre contient toutes les lignes dont le RollBasis est entre 2 et 6, puis la troisième fenêtre contient toutes les lignes dont le RollBasis est entre 3 et 7, etc. Windows n'auront pas le même nombre de lignes, mais la gamme de RollBasis valeurs sélectionnées dans chaque fenêtre sera le même. La sortie devrait ressembler à:

>>> d.roll_by(sum, 'RollBasis', 5)
    1    -4    # sum of elements with 1 <= Rollbasis <= 5
    2    -4    # sum of elements with 2 <= Rollbasis <= 6
    3    -6    # sum of elements with 3 <= Rollbasis <= 7
    4    -2    # sum of elements with 4 <= Rollbasis <= 8
    # etc.

Je ne peux pas faire cela avec groupby, parce que groupby produit toujours disjoints groupes. Je ne peux pas le faire avec les rolling fonctions, parce que leur windows toujours rouler en nombre de lignes, pas par des valeurs. Alors, comment puis-je le faire?

OriginalL'auteur BrenBarn | 2013-01-13

  1. 13

    Je pense que cela ne ce que vous voulez:

    In [1]: df
Out[1]:
   RollBasis  ToRoll
0          1       1
1          1       4
2          1      -5
3          2       2
4          3      -4
5          5      -2
6          8       0
7         10     -13
8         12      -2
9         13      -5

In [2]: def f(x):
   ...:     ser = df.ToRoll[(df.RollBasis >= x) & (df.RollBasis < x+5)]
   ...:     return ser.sum()

    La fonction ci-dessus prend une valeur, dans ce cas RollBasis, puis les indices de la trame de données de la colonne ToRoll en fonction de cette valeur. Le retour de la série se compose de ToRoll valeurs qui répondent à la RollBasis + 5 critère. Enfin, cette série est résumée et retourné.

    In [3]: df['Rolled'] = df.RollBasis.apply(f)

In [4]: df
Out[4]:
   RollBasis  ToRoll  Rolled
0          1       1      -4
1          1       4      -4
2          1      -5      -4
3          2       2      -4
4          3      -4      -6
5          5      -2      -2
6          8       0     -15
7         10     -13     -20
8         12      -2      -7
9         13      -5      -5

    Code pour le jouet exemple DataFrame dans le cas où quelqu'un d'autre veut essayer:

    In [1]: from pandas import *

In [2]: import io

In [3]: text = """\
   ...:    RollBasis  ToRoll
   ...: 0          1       1
   ...: 1          1       4
   ...: 2          1      -5
   ...: 3          2       2
   ...: 4          3      -4
   ...: 5          5      -2
   ...: 6          8       0
   ...: 7         10     -13
   ...: 8         12      -2
   ...: 9         13      -5
   ...: """

In [4]: df = read_csv(io.BytesIO(text), header=0, index_col=0, sep='\s+')
    Merci, cela semble le faire. J'ai ajouté ma propre réponse avec une version généralisée de tout cela, mais je suis de l'acceptation de votre réponse.

    OriginalL'auteur Zelazny7

  2. 11

    Basé sur Zelazny7 réponse, j'ai créé ce plus de solution générale:

    def rollBy(what, basis, window, func):
    def applyToWindow(val):
        chunk = what[(val<=basis) & (basis<val+window)]
        return func(chunk)
    return basis.apply(applyToWindow)

>>> rollBy(d.ToRoll, d.RollBasis, 5, sum)
0    -4
1    -4
2    -4
3    -4
4    -6
5    -2
6   -15
7   -20
8    -7
9    -5
Name: RollBasis

    Il n'est toujours pas idéal, car il est très lent par rapport à rolling_apply, mais c'est peut-être inévitable.

    C'est beaucoup plus rapide si, au lieu de filtrage sur la valeur de la deuxième colonne, on filtre sur la valeur d'un indice. Les Pandas indices actuellement en charge des non-entrées uniques, de sorte que vous solution pourrait être accéléré par la définition de la base de la colonne que l'index et le filtrage.

    OriginalL'auteur BrenBarn

  3. 9

    Basé sur BrenBarns réponse, mais accéléré par l'utilisation de l'étiquette en fonction de l'indexation plutôt que booléen basé sur l'indexation:

    def rollBy(what,basis,window,func,*args,**kwargs):
    #note that basis must be sorted in order for this to work properly     
    indexed_what = pd.Series(what.values,index=basis.values)
    def applyToWindow(val):
        # using slice_indexer rather that what.loc [val:val+window] allows
        # window limits that are not specifically in the index
        indexer = indexed_what.index.slice_indexer(val,val+window,1)
        chunk = indexed_what[indexer]
        return func(chunk,*args,**kwargs)
    rolled = basis.apply(applyToWindow)
    return rolled

    C'est beaucoup plus vite que vous n'utilisez pas une colonne indexée:

    In [46]: df = pd.DataFrame({"RollBasis":np.random.uniform(0,1000000,100000), "ToRoll": np.random.uniform(0,10,100000)})

In [47]: df = df.sort("RollBasis")

In [48]: timeit("rollBy_Ian(df.ToRoll,df.RollBasis,10,sum)",setup="from __main__ import rollBy_Ian,df", number =3)
Out[48]: 67.6615059375763

In [49]: timeit("rollBy_Bren(df.ToRoll,df.RollBasis,10,sum)",setup="from __main__ import rollBy_Bren,df", number =3)
Out[49]: 515.0221037864685

    Il est intéressant de noter que l'indice en fonction de la solution est O(n), tandis que la logique de découpage version est O(n^2) dans le cas moyen (je pense).

    Je trouve qu'il est plus utile de le faire via les fenêtres régulièrement espacées à partir de la valeur min de la Base de la valeur max de Base, plutôt qu'à chaque valeur de base. Cela signifie modifiant la fonction ainsi:

    def rollBy(what,basis,window,func,*args,**kwargs):
    #note that basis must be sorted in order for this to work properly
    windows_min = basis.min()
    windows_max = basis.max()
    window_starts = np.arange(windows_min, windows_max, window)
    window_starts = pd.Series(window_starts, index = window_starts)
    indexed_what = pd.Series(what.values,index=basis.values)
    def applyToWindow(val):
        # using slice_indexer rather that what.loc [val:val+window] allows
        # window limits that are not specifically in the index
        indexer = indexed_what.index.slice_indexer(val,val+window,1)
        chunk = indexed_what[indexer]
        return func(chunk,*args,**kwargs)
    rolled = window_starts.apply(applyToWindow)
    return rolled
    Pour que cela fonctionne correctement (au moins dans les pandas 0.14), je pense que vous avez besoin de remplacer chunk = indexed_what[indexeur] par chunk = indexed_what.lci[indexeur]. Sinon, la tranche est considérée comme un indice de gamme, mais c'est un positionnement de gamme.
    Ce ne sont pas les mêmes résultats que Bren de réponse en raison de la façon dont ils traitent ouvert/fermé intervalles (voir résultat de l'indice 5 dans l'exemple). Il ne permet pas non plus de quoi être un DF au lieu de juste une série.

    OriginalL'auteur Ian Sudbery