Python 创建一个权重矩阵,有效地求和为一
我正在创建一个线性组合生成器和测试仪。目标是测试N个输入的所有线性组合,以确定哪一个产生最佳分数 创建权重矩阵可以通过一种强有力的方式完成,如下所示。但是,当有2+个模块没有上限时,这在应用程序中是不灵活的。有没有一种方法可以推广这段代码 这也将是理想的矩阵形式的输出,所以我可以简单地乘以输入矩阵与标量,以获得线性组合输出 编辑:完全明确。我正在寻找一种灵活参考的方法Python 创建一个权重矩阵,有效地求和为一,python,arrays,numpy,iteration,Python,Arrays,Numpy,Iteration,我正在创建一个线性组合生成器和测试仪。目标是测试N个输入的所有线性组合,以确定哪一个产生最佳分数 创建权重矩阵可以通过一种强有力的方式完成,如下所示。但是,当有2+个模块没有上限时,这在应用程序中是不灵活的。有没有一种方法可以推广这段代码 这也将是理想的矩阵形式的输出,所以我可以简单地乘以输入矩阵与标量,以获得线性组合输出 编辑:完全明确。我正在寻找一种灵活参考的方法 for i in range...: for j in range...: for k in range
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年代,所以我不是最好的提问者。尝试搜索递归算法。维基百科可能会有所帮助,因为它是一种寻找解决方案的方法,而不是过于特定于语言。祝你好运