Question

我正在尝试查找四个不同参数（kc，tauI，tauC，tauD）的值，以优化控制器的性能。我希望我的程序在合理的时间内在给定的数字范围内测试尽可能多的组合。我需要帮助弄清楚如何尝试在给定范围内使用所有参数组合。

我尝试使用itertools.combinations，但似乎不适用于数组。这不只是一个语法问题，而是一个用于解决该问题的方法的问题。

    kc = np.linspace (0.1 , 1, 10)
    tauI = np.linspace (0.1 , 1, 10)
    tauD = np.linspace (0.1 , 1, 10)
    tauC = np.linspace (0.1 , 1, 10)

    def performance(kc, tauI, tauD, tauC):

        # defining s
        s = control.tf([1, 0], [0, 1])

        # defining all combinations of parameters to test for controller 
        performance
        possible_combinations = itertools.combinations([kc, tauI, tauD, tauC])

        index = 0
        best_performance = 1000

        for i in possible_combinations:
            kc = possible_combinations[index][0]
            tauI = possible_combinations[index][1]
            tauD = possible_combinations[index][2]
            tauC = possible_combinations[index][3]

            # defining the transfer functions
            Gp = 1/(s**2 + s + 1)
            Gd = (s + 1)/(s**2 + s + 1)
            Gc = Kc * (1 + 1/(tauI*s) + (tauD * s)/(tauC * s + 1))

            # defining the system
            sys_D = Gd/(1 + Gp * Gc)
            sys_U = Gc/(1 + Gp * Gc)

            # calculate the performance

            total_performance = 0.

            # loop through csv files and calculate performance
            for filename in all_files:
                # import disturbance from csv
                T_i = pd.read_csv(filename, header = 0)
                T_i = T_i.values.reshape(1,60)
                # calculate output response
                Y = Y_func(sys_D, time_array, T_i)
                # calculate input response
                U = U_func(sys_U, time_array, Y)
                # calculate performance for this csv file
                perfect = perf(Y, U)
                # add the performance for this csv to the total performance
                total_performance += perfect

            # calculate the average performance
            average_perf = total_performance/len(all_files)

            # check if the performance for these parameters were better than 
            # previously run tests
            if average_perf < best_performance:
                best_performance = average_perf
                kept_kc = kc
                kept_tauI = tauI
                kept_tauD = tauD
                kept_tauC = tauC

Answer 1

这将满足您的需求。我不确定这是否比将代码放入4个for循环更好。

kc = np.linspace (0.1 , 1, 10)
tauI = np.linspace (0.1 , 1, 10)
tauD = np.linspace (0.1 , 1, 10)
tauC = np.linspace (0.1 , 1, 10)

def possible_combinations():               
    for k in kc:                
        for ti in tauI:         
            for td in tauD:     
                for tc in tauC:   
                    yield k, ti, td, tc

for a,b,c,d in possible_combinations():    
    print( a, b, c, d )

itertools.combinations对一个列表中的n个项进行所有组合。

from itertools import combinations  
for i, j in combinations([1,2,3,4], 2):   
    print(i,j)

out: 1 2
     1 3
     1 4
     2 3
     2 4
     3 4

有没有一种方法可以计算多个数组的所有可能组合？

1 个答案: