Python 创建一个权重矩阵，有效地求和为一

我正在创建一个线性组合生成器和测试仪。目标是测试N个输入的所有线性组合，以确定哪一个产生最佳分数

创建权重矩阵可以通过一种强有力的方式完成，如下所示。但是，当有2+个模块没有上限时，这在应用程序中是不灵活的。有没有一种方法可以推广这段代码

这也将是理想的矩阵形式的输出，所以我可以简单地乘以输入矩阵与标量，以获得线性组合输出

编辑：完全明确。我正在寻找一种灵活参考的方法

for i in range...: 
   for j in range...: 
       for k in range...

适用于2、3、4、+模块

def generate_weights(n=4, min_weight=0, max_weight=100):
    weight_dictionary = {}
    combination = 1
    for i in range(0, 101):
        for j in range(0, 101):
            for k in range(0, 101):
                for l in range(0, 101):
                    # For now, ignoring conditions on each individual scalar's min and max weight criteria
                    if i + j + k + l == 100:
                        weight_dictionary[combination] = (i, j, k, l)
                        combination+=1
    return weight_dictionary

test = generate_weights()

由于“i+j+k+l==100”，您不需要每次计算范围0~100，您可以限制范围并排除不可能的值，如下所示：

    for i in range(0, 101):
        for j in range(0, 101-i):
            for k in range(0, 101-i-j):
                for l in range(0, 101-i-j-k):

之前的时间复杂度：O（n**4）

之后的时间复杂度：O（n*log（n））

由于“i+j+k+l==100”，您不需要每次计算范围0~100，您可以限制范围并排除不可能的值，如下所示：

    for i in range(0, 101):
        for j in range(0, 101-i):
            for k in range(0, 101-i-j):
                for l in range(0, 101-i-j-k):

之前的时间复杂度：O（n**4）

之后的时间复杂度：O（n*log（n））

---

通常，处理未知层叠循环深度的最简单方法是使用递归。每次函数运行时，它运行一个循环，递归深度给出堆栈

import numpy as np

def generate_weights0( layers = 4, tgt = 100 ):
    """ Generate list of lists with 'layers' items adding to tgt """
    result = []

    def one_layer( layers, tgt, cumul ):
        """  layers: layers still to produce.
             tgt: the tgt still left to be consumed.
             cumul: a list of the combinations for the layers already processed.
        """
        if layers == 1: # return results for the last layer
            cumul.append( tgt )
            result.append( cumul )
        else:
            # For each i call one_layer with revised parameters
            for i in range( tgt + 1 ):
                cumul_ = cumul.copy()
                cumul_.append( i )
                # Recursive call with updated parameters
                one_layer( layers - 1, tgt - i, cumul_ )

    one_layer( layers, tgt, [] )  # Execute the initialised function
    return np.array( result )

上面返回的结果假设min为零。为了避免复杂性，第二个函数调用上述函数，并将参数调整为最小值。然后将最小值添加到所有结果中

def generate_weights( layers = 4, min_ = 0, tgt = 100 ):
    tgt = tgt - ( layers * min_ )
    return generate_weights0( layers, tgt ) + min_

---

我认为这会返回您想要的结果。

通常，处理未知深度的堆叠循环的最简单方法是使用递归。每次函数运行时，它运行一个循环，递归深度给出堆栈

import numpy as np

def generate_weights0( layers = 4, tgt = 100 ):
    """ Generate list of lists with 'layers' items adding to tgt """
    result = []

    def one_layer( layers, tgt, cumul ):
        """  layers: layers still to produce.
             tgt: the tgt still left to be consumed.
             cumul: a list of the combinations for the layers already processed.
        """
        if layers == 1: # return results for the last layer
            cumul.append( tgt )
            result.append( cumul )
        else:
            # For each i call one_layer with revised parameters
            for i in range( tgt + 1 ):
                cumul_ = cumul.copy()
                cumul_.append( i )
                # Recursive call with updated parameters
                one_layer( layers - 1, tgt - i, cumul_ )

    one_layer( layers, tgt, [] )  # Execute the initialised function
    return np.array( result )

上面返回的结果假设min为零。为了避免复杂性，第二个函数调用上述函数，并将参数调整为最小值。然后将最小值添加到所有结果中

def generate_weights( layers = 4, min_ = 0, tgt = 100 ):
    tgt = tgt - ( layers * min_ )
    return generate_weights0( layers, tgt ) + min_

---

我想这会达到您的目的。

您好，谢谢您的优化！我目前正在研究一种方法，将手动写入“范围内的I…范围内的j…范围内的k…”更改为对数组的动态引用，并循环通过该数组或列表以获得相同的结果。您好，感谢您的优化！我目前正在研究一种方法，将手动写入“范围内的I…范围内的j…范围内的k…”更改为对数组的某个动态引用，并循环通过该数组或列表以获得相同的结果。谢谢，这正是我所寻找的。如果您有任何关于递归的建议资源以及何时使用它，我想研究一下！我第一次使用递归是在20世纪80年代，所以我不是最好的提问者。尝试搜索递归算法。维基百科可能会有所帮助，因为它是一种寻找解决方案的方法，而不是过于特定于语言。祝你好运。谢谢，这正是我想要的。如果您有任何关于递归的建议资源以及何时使用它，我想研究一下！我第一次使用递归是在20世纪80年代，所以我不是最好的提问者。尝试搜索递归算法。维基百科可能会有所帮助，因为它是一种寻找解决方案的方法，而不是过于特定于语言。祝你好运