Python Forum

Hello,
I have a function with 3 intricated loops to get the best parameters from about 16000000 combinations. This takes a lot of time.
I am looking for an alternative.
Here is the function.

            for a in range(700, 800, 1):
                a = a / 100
                for c in range(100, 200, 1):
                    #c = c / 10.0
                    for seed in range(min_seed, max_seed + 1):
                        #seed = seed/20.0
                        generated_sequence = generate_sequence(a, c, best_m, seed, len(adjusted_values))
                        cubed_difference = calculate_mean_squared_error(generated_sequence, adjusted_values)

                        if cubed_difference < min_cubed_difference:
                            min_cubed_difference = cubed_difference
                            best_a = a
                            best_c = c
                            best_seed = seed

You can try to perform all calculations, either using vectorisation (numpy/pandas) or multiprocessing and only then finding best/min_cube_difference

The biggest performance bump will come from doing less. Not knowing what generate_sequence or calculate_mean_squared_error do I cannot offer any definitive suggestions on how this could be done. Essentially you are looking for the roots of a function. Sometimes this can be done analytically. No looping is always the fastest solution. If your function is linear, you could use something like Newton-Raphson to find the roots. If there are several roots you may have to repeat this process multiple times for different regions of the problem space.

A better algorithm can make your code millions of times faster, but if that isn't possible you can make the code thousands of times faster by not doing it in Python. As buran mentions, you can use numpy to do the calculations in C. If your equations are not amenable to numpy vectorization, you can write a C library that does the calculations and returns a result. This can be called from Python, or maybe just forget about Python and do everything in C.

Why so cagey?

Tell us what the functions and variables are!

As the guys said, np is faster than Python.

Quote:It is sometimes said that Python, compared to low-level languages such as C++, improves development time at the expense of runtime.

For this example, from realpython.com, numpy is nearly 100 times faster:

import numpy as np
from timeit import timeit

def profit(prices):
    max_px = 0
    min_px = prices[0]
    for px in prices[1:]:
        min_px = min(min_px, px)
        max_px = max(px - min_px, max_px)
    return max_px

def profit_with_numpy(prices):
    """Price minus cumulative minimum price, element-wise."""
    prices = np.asarray(prices)
    return np.max(prices - cummin(prices))

cummin = np.minimum.accumulate
# compare speeds
seq = np.random.randint(0, 100, size=100000)
setup = ('from __main__ import profit_with_numpy, profit, seq;' ' import numpy as np')
num = 250
pytime = timeit('profit(seq)', setup=setup, number=num)
nptime = timeit('profit_with_numpy(seq)', setup=setup, number=num)
print('Speed difference: {:0.1f}x'.format(pytime / nptime))

Output:
Speed difference: 93.5x

I've heard using integers is faster than float numbers if you are doing millions and millions of calculations. Maybe you could find some way to use integers instead of floats? Ie.. shift the float input the number of sig figs you require, do your calculations as ints, then shift it back when complete?

(Dec-07-2023, 12:28 PM)RockBlok Wrote: [ -> ]I've heard using integers is faster than float numbers if you are doing millions and millions of calculations. Maybe you could find some way to use integers instead of floats? Ie.. shift the float input the number of sig figs you require, do your calculations as ints, then shift it back when complete?

What are the detailed steps? Many people are waiting for results so they can use it
Link Removed