Панды умножают каждую строку набора данных на несколько векторов

Question

df = {1,2,3
      4,5,6
      7,8,9,
      10,11,12
}

weights={[1,3,3],[2,2,2],[3,1,1]}

Я хочу умножить свой df на каждую строку весов матрицы (поэтому у меня будет три разных df, по одному для каждого вектора весов, и объединить каждый df, сохраняя наибольшую строку значений). Пример:

df0=df * weights[0]={1,6,9
                    4,15,18,
                    7,24,27
                    10,33,36
                    } 

df1=df*wieghts[1]={2,4,6,
                   8,19,12,
                   14,16,18,
                   20,22,24
                  }

df2=df*wieghts[2]={3,2,3,
                   12,5,6,
                   21,8,9,
                   30,11,12
                  }

и

final_df_lines=max{df0,df1,df2}={1,6,9 - max line line from df0, 
                                     4,15,18, - max line from df0, 
                                     7,24,27 - max line from df0, 
                                     10,33,36 - max line from df0, 
                                     } 

В этом примере все max были из df0 ... но они могли быть из любого из трех df. Линия Макс просто добавляет числа из той же строки ..

Мне нужно сделать все это векторизованным (без каких-либо петель или если ...), как мне это сделать? возможно ли это хотя бы? Мне действительно нужно Welp :( в течение 2 дней я ищу в Интернете, чтобы сделать это ... Я не работал в Python слишком долго ...

Answer 1

вы можете попробовать concatenat, чтобы объединить все весовые коэффициенты в столбцах в виде одного кадра данных с suffix of column, представляющим каждый вес, и на grouping with respect to the weight умножить получим максимальное суммирование индекса

с максимальным весом индекса вы можете умножить фрейм данных

df2 = pd.concat([(df*i).add_suffix('__'+str(i)) for i in weights],axis=1).T
                0   1   2   3
0__[1, 3, 3]    1   4   7   10
1__[1, 3, 3]    6   15  24  33
2__[1, 3, 3]    9   18  27  36
0__[2, 2, 2]    2   8   14  20
1__[2, 2, 2]    4   10  16  22
2__[2, 2, 2]    6   12  18  24
0__[3, 1, 1]    3   12  21  30
1__[3, 1, 1]    2   5   8   11
2__[3, 1, 1]    3   6   9   12

#   by grouping with respect to the weight it multiplied, get max index
a = df2.groupby(df2.index.str.split('__').str[1]).apply(lambda x: x.sum()).idxmax()

#  max weights with respect to summation of rows
df['idxmax'] = a.str.slice(1,-1).str.split(',').apply(lambda x: list(map(int,x)))

c    [1, 3, 3]
d    [1, 3, 3]
3    [1, 3, 3]
4    [1, 3, 3]
dtype: object

df.apply(lambda x: x.loc[df.columns.difference(['idxmax'])] * x['idxmax'],1)

   0    1   2
0   1   6   9
1   4   15  18
2   7   24  27
3   10  33  36

Answer 2

РЕДАКТИРОВАТЬ: Поскольку вопрос был обновлен, мне пришлось обновить тоже:

Вы должны сначала выровнять матрицы, чтобы иметь возможность выполнять поэлементную матричную операцию без использования цикла:

    import numpy as np

    a = [
         [1,2,3],
         [4,5,6],
         [7,8,9],
         [10,11,12]
         ]

    weights = [
               [1,3,3], 
               [2,2,2],
               [3,1,1]
              ]

    w_s = np.array( (4 * [weights[0]], 4 * [weights[1]], 4 * [weights[2]]) )
    a_s = np.array(3 * [a])

result_matrix1 = w_s * a_s[0]
result_matrix2 = w_s * a_s[1]
result_matrix3 = w_s * a_s[2]

print(result_matrix1)
print(result_matrix2)
print(result_matrix3)

Выход:

[[[ 1  6  9]
  [ 4 15 18]
  [ 7 24 27]
  [10 33 36]]

 [[ 2  4  6]
  [ 8 10 12]
  [14 16 18]
  [20 22 24]]

 [[ 3  2  3]
  [12  5  6]
  [21  8  9]
  [30 11 12]]]
[[[ 1  6  9]
  [ 4 15 18]
  [ 7 24 27]
  [10 33 36]]

 [[ 2  4  6]
  [ 8 10 12]
  [14 16 18]
  [20 22 24]]

 [[ 3  2  3]
  [12  5  6]
  [21  8  9]
  [30 11 12]]]
[[[ 1  6  9]
  [ 4 15 18]
  [ 7 24 27]
  [10 33 36]]

 [[ 2  4  6]
  [ 8 10 12]
  [14 16 18]
  [20 22 24]]

 [[ 3  2  3]
  [12  5  6]
  [21  8  9]
  [30 11 12]]]

Решение - numpy, но вы также можете сделать это с pandas, если, конечно, предпочтете.