Использование split-apply-Объединить, чтобы удалить некоторые значения с помощью пользовательской функции и объединить то, что осталось

Question

Так что это не тот набор данных, с которым мне нужно работать, а шаблон огромного, с которым я работаю (~ 1,8 миллиона точек данных) для исследовательского проекта по раку, поэтому я подумал, смогу ли я получить этоработать с меньшим, тогда я могу адаптировать его для моего большого! Итак, в качестве примера, скажем, у меня есть следующий набор данных:

import numpy as np
import pandas as pd
df = pd.DataFrame({
   'cond': ['A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'A', 'B', 'B','B', 'B', 'B', 'B', 'B','B','B'],
   'Array':  ['S', 'S', 'TT', 'TT','S', 'S', 'TT', 'TT','S', 'S', 'TT', 'TT','S', 'S', 'TT', 'TT','SS','TT'],
   'X':  [1, 2, 3, 1, 2 , 3, 4, 7.3, 5.1, 3.2, 1.4, 5.5, 9.9, 3.2, 1.1, 3.3, 1.2, 5.4],
   'Y':  [3.1, 2.2, 2.1, 1.2,  2.4, 1.2, 1.5, 1.33, 1.5, 1.6, 1.4, 1.3, 0.9, 0.78, 1.2, 4.0, 5.0, 6.0],
   'Marker':  [2.0, 1.2, 1.2, 2.01, 2.55, 2.05, 1.66, 3.2, 3.21, 3.04, 8.01, 9.1, 7.06, 8.1, 7.9, 5.12, 5.23, 5.15],
   'Area': [3.0, 2.0, 2.88, 1.33,  2.44, 1.25, 1.53, 1.0, 0.156, 2.0, 2.4, 6.3, 6.9, 9.78, 10.2, 15.0, 16.0, 19.0]
})
print(df)

Это производит вывод, который выглядит следующим образом:

   cond Array    X     Y  Marker    Area
0     A     S  1.0  3.10    2.00   3.000
1     A     S  2.0  2.20    1.20   2.000
2     A    TT  3.0  2.10    1.20   2.880
3     A    TT  1.0  1.20    2.01   1.330
4     A     S  2.0  2.40    2.55   2.440
5     A     S  3.0  1.20    2.05   1.250
6     A    TT  4.0  1.50    1.66   1.530
7     A    TT  7.3  1.33    3.20   1.000
8     A     S  5.1  1.50    3.21   0.156
9     B     S  3.2  1.60    3.04   2.000
10    B    TT  1.4  1.40    8.01   2.400
11    B    TT  5.5  1.30    9.10   6.300
12    B     S  9.9  0.90    7.06   6.900
13    B     S  3.2  0.78    8.10   9.780
14    B    TT  1.1  1.20    7.90  10.200
15    B    TT  3.3  4.00    5.12  15.000
16    B    SS  1.2  5.00    5.23  16.000
17    B    TT  5.4  6.00    5.15  19.000

Хорошо, так что теперь мне нужно сделать, эторазделить их по двум меткам: «cond» и «Array». Я сделал это, используя

g=df.groupby(['cond','Array'])['Marker']

. Это разбивает его на 4 меньших набора, разбитых на пары AS, A-TT, BS, B-TT. Теперь у меня есть настроенная функция для работы. Это часть функции, и я объясню, как она работает:

def num_to_delete(p,alpha,N):
    if p==0.950:
        if 1-alpha==0.90:
            if N<=60:
                m=1
            if 60<N<80:
                m=round(N/20-2)
            if 80<=N:
                m=2
        if 1-alpha==0.95:
            if N<=80:
                m=1
            if 80<N<=100:
                m=round(N/20 -3)
            if 100<N:
                m=2
    return m

Хорошо, так, как она работает, я передаю ей "p" и "alpha", которые я выбираю (реальноефункция охватывает еще много случаев р и альфа). N, которое вводится в него - это количество элементов моего меньшего набора данных (в данном случае для AS это 5, для A-TT это 4 и т. Д.). Так что я пытаюсь добиться того, чтобы для каждого меньшего набора данных выплевывалось количество точек для удаления (в этом примере функция всегда будет давать нам 1, но я пытаюсь кодировать это с помощью функции дляприложение для супер большого набора данных). Так как он дает число 1, я хочу, чтобы он удалил 1 самую большую точку данных для этого набора и сказал мне, какая самая высокая точка осталась.

Итак, в качестве примера, для связи AS, у меня есть 5 точек данных: 2.0, 1.2, 2.55, 2.05 и 3.21. Поскольку существует 5 точек данных, моя функция говорит мне удалить 1 из них, поэтому проигнорируйте 3.21 и скажите, какая самая высокая оставшаяся точка данных, которая в данном случае равна 2.55. Я хочу сделать это для каждой связи, но в моем реальном наборе данных у меня будет разное количество элементов, поэтому функция скажет мне удалить разные числа для каждой связи.

Моя конечная цель - иметьитоговая таблица выглядит следующим образом:

   cond Array   NumDeleted p95/a05  p95/a10       
0     A     S  1.0      2.55   2.55
1     A    TT  1.0      2.01   2.01
2     B     S  1.0      7.06   7.06
3     B    TT  1.0      8.01   8.01

Для большего набора значения в последних 2 столбцах будут отличаться, потому что в большом наборе данных разница в количестве значений намного больше. будут удалены, и, следовательно, остальные значения будут отличаться. В конце концов мне нужно будет изменить второй набор данных на основе значений, которые я получу для p95 / a05 и p95 / a10

В любом случае, извините, это было такое длинное объяснение, но если кто-то может помочь, этобыть удивительным! Я надеюсь, что это довольно просто сделать, так как я застрял на этом более недели.

Answer 1

РЕДАКТИРОВАТЬ: более общее решение

Во-первых, это поможет сделать closure для определения ваших конфигураций. Предполагается, что в будущем у вас будет больше конфигураций:

def create_num_to_delete(p, alpha):
    """Create a num_to_delete function given p and alpha."""
    def num_to_delete(N):
        if p == 0.950:
            if 1 - alpha == 0.90:
                if N <= 60:
                    m = 1
                if 60 < N < 80:
                    m = round(N/20 - 2)
                if 80 <= N:
                    m = 2
            if 1-alpha == 0.95:
                if N <= 80:
                    m = 1
                if 80 < N <= 100:
                    m = round(N/20 -3)
                if 100 < N:
                    m = 2
        return m

    return num_to_delete

Затем вы можете использовать это замыкание для определения словаря конфигураций:

configurations = {
    'p95/a05': create_num_to_delete(0.95, 0.05),
    'p95/a10': create_num_to_delete(0.95, 0.10),
}

Затем определитефункция, которая обобщает ваши данные. Эта функция должна полагаться на вашу конфигурацию, чтобы она оставалась динамической.

def summarize(x):
    # The syntax on the right-hand side is called list comprehension.
    # As you can probably guess, it's essentially a flattened for-loop that
    # produces a list. The syntax starting with "for" is your basic for loop
    # statement, and the syntax to the left of "for" is an expression that
    # that serves as the value of the resulting list for each iteration
    # of the loop.
    #
    # Here, we are looping through the "num_to_delete" functions we defined in
    # our `configurations` dictionary. And calling it in our group `x`.
    Ns = [num_to_delete(len(x)) for num_to_delete in configurations.values()]

    markers = x['Marker'].sort_values(ascending=False)

    highest_markers = []
    for N in Ns:
        if N == len(x):
            highest_markers.append(None)
        else:
            # Since we know that `markers` is already sorted in descending
            # order, all we need to get the highest remaining value is to get
            # the value in the *complete list* of values offset by the 
            # the number of values that need to be deleted (this is `N`).
            #
            # Since sequences are 0-indexed, simply indexing by `N` is enough.
            # For example, if `N` is 1, indexing by `N` would give us
            # the marker value *indexed by* 1, which is,
            # in a 0-sequenced index, simply the second value.
            highest_markers.append(markers.iloc[N])

    # Returning a list from an applied groupby function translates into
    # a DataFrame which the series index as the columns and the series values
    # as the row values. Index in this case is just the list of configuration
    # names we have in the `configurations` dictionary.
    return pd.Series(highest_markers, index=list(configurations.keys()))

Наконец, apply функция для вашего набора данных и сброс индекса. Это сохраняет cond и Array как столбцы:

grouped = df.groupby(['cond', 'Array'])
grouped.apply(summarize).reset_index()

Вывод:

    cond    Array   p95/a05 p95/a10
0   A   S   2.55    2.55
1   A   TT  2.01    2.01
2   B   S   7.06    7.06
3   B   SS  NaN NaN
4   B   TT  8.01    8.01

Надеюсь, это поможет.