python3：如何计算按 3 分组的 10 个因子（每个因子有 15 个值）的所有变化

Question

请您帮我计算按 3 分组的 10 个因子（每个因子有 15 个值）的所有变化。

我们有 10 个因素。 每个因子有 15 个值。例如。 1,2,3,4,5,6...15

第一个三元组因素的所有可能组合（例如因素1、因素2、因素3）是：

15 (factor1 combination values) x 15 (factor2 combination values) x 15 (factor3 combination values) = 3 375

这应该针对 10 个因素中所有可能的三元组进行计算：

    3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 = 59 049 possible combinations of 3 factors
 (except duplicates like factor1, factor1, factor2)

因此，我们有 3 个因子的 59 049 个组合 x 其值的 3 375 个组合 = 1.99 亿条记录

理想的输出：

1st place   2nd place   3rd place   1st place value 2nd place value 3rd place value
factor1     factor2     factor3     1               1               1
factor1     factor2     factor3     1               1               2
factor1     factor2     factor3     1               1               3
…           …           …           …               …               …   
factor8     factor9     factor10    15              15              15

感谢您对如何实现目标的每一次提示。

Answer 1

您的问题的关键：“重复除外”is simply a binomial coefficient 的组合数，可以通过itertools.product() 或pandas.MultiIndex.from_product() 生成实例（也可以this anwer）。

因此，(factor1, factor2, factor3) 的确切数字是binom(10, 3) =120 而不是3**10=59,049。因此总行数为120*3375=405,000。

解决方案：

我对所有数字进行了参数化，只是为了使数学逻辑清晰。此外，通过相应地重新计算comb_facs，可以将此解决方案应用于不同数量的值。

import pandas as pd
import numpy as np
import itertools
from scipy.special import comb

# data and parameters
n_cols = 10
k_cols = 3  # binomial coeff. (n k)
n_vals = 15  # 15 vals
dic = {}
for i in range(1, n_cols+1):
    dic[f"f{i}"] = np.array([j for j in range(1, 1+n_vals)], dtype=object)
df = pd.DataFrame(dic)

# preallocate the output arrays: factors and values
comb_cols = comb(n_cols, k_cols)  # binom(10,3) = 120
comb_facs = int(n_vals ** k_cols)  # NOTE: must recalculate if number of values are not constant
total_len = int(comb_cols * comb_facs)
factors = np.zeros((total_len, k_cols), dtype=object)
values = np.zeros((total_len, k_cols), dtype=int)

# the actual iteration
for i, tup in enumerate(itertools.combinations(df.columns, k_cols)):

    # 1. Cartesian product of (facA, facB, facC).
    #    can also use list(itertools.product())
    vals = pd.MultiIndex.from_product(
        [df[tup[i]].values for i in range(k_cols)]  # df.f1, df.f2, df.f3
    )
    arr_vals = pd.DataFrame(index=vals).reset_index().values
    # 2. Populate factor names and values into output arrays
    factors[i * comb_facs:(i + 1) * comb_facs, :] = tup  # broadcasting
    values[i * comb_facs:(i + 1) * comb_facs, :] = arr_vals

# result
pd.concat([pd.DataFrame(factors, columns=["1p fac", "2p fac", "3p fac"]),
           pd.DataFrame(values, columns=["1p val", "2p val", "3p val"])], axis=1)

Out[41]: 
       1p fac 2p fac 3p fac  1p val  2p val  3p val
0          f1     f2     f3       1       1       1
1          f1     f2     f3       1       1       2
2          f1     f2     f3       1       1       3
3          f1     f2     f3       1       1       4
4          f1     f2     f3       1       1       5
       ...    ...    ...     ...     ...     ...
404995     f8     f9    f10      15      15      11
404996     f8     f9    f10      15      15      12
404997     f8     f9    f10      15      15      13
404998     f8     f9    f10      15      15      14
404999     f8     f9    f10      15      15      15
[405000 rows x 6 columns]