Is there a way to calculate all possible combinations of multiple arrays?

Question

I am trying to find values for four different parameters (kc, tauI, tauC, tauD) in order to optimize the performance of a controller. I want my program to test as many combinations as possible within a reasonable timeframe in a given range of numbers. I need help with figuring out how to try all the combinations of the parameters in a given range.

I have tried using itertools.combinations, but it doesn't seem to work on arrays. This is not as much a syntax question but more a question of which approach to use to solve this problem.

    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

Looks like you want a [cartesian product](https://stackoverflow.com/q/11144513/7207392) — Paul Panzer, Mar 27 '19 at 04:56
have a look at scipy.optimize.brute, its optimize the function base on a grid search. — Yohai Magan, Mar 27 '19 at 07:55

score 0 · Answer 1 · answered Mar 27 '19 at 23:00

This will generaqte what you seem to need. Whether this is any better than putting the code inside 4 for loops I'm not sure.

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 does all combinations of n items from one list.

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

Is there a way to calculate all possible combinations of multiple arrays?

1 Answers1