Is there any way to get the benefit of caching when splitting the run?

[happyych]

Hello, I want to get some advice for getting benefit of caching effect when I run large amount of lines.

I made a vecorized model and tried to run more than 10,000 lines at once.

As far as I checked, my vectorized model has the best performance when I assigned 1000 lines at once on my machine.
So, I tried to split 10,000 lines to 10 groups (each by 1000 lines) and looping the run 10 times.

At this point, I want to find some way to get the effect of caching for every looping.
For the first loop, all the variable data(modelpoint, assumption data table, product information table and etc...) have to be read.
However, after the first loop, I think there is some way to use the data the model read in the former loop so that the run
can just focus on the variables that have to be newly updated.
(below is the code I use)

block_size = 1000
result = []

start = time.time()
for i in range(0,10):
    cs.start_mp = i * block_size
    cs.end_mp = (i+1) * block_size
    calc = cs.result_output()
    result.append(calc)
    
end = time.time()
elapsed = end - start

Could you recommend any way I can get the benefit of caching?

Thanks a lot and have a nice weekend!

[fumitoh]

Let's say your model is structured as below:

model----Projection-----result_output()
                     +--model_points()
                     +--all_model_points()
                     +--start_mp
                     +--end_mp

all_model_points() returns all model points as a DataFrame, and
model_points extracts a block from all_model_points() every time smart_mp and end_mp are updated.

def model_points():
    return all_model_points().iloc[start_mp:end_mp]

all_model_points() doesn't need to be updated every time smart_mp and end_mp are updated.

You can restructure the model by creating a new space and put start_mp , end_mp, all_model_points() in there as below.

model----Projection----result_output()
       |            +--model_points()
       |            +--inp<-----InputData          
       |
       |
       +-InputData----all_model_points()
                   +--start_mp
                   +--end_mp

Names in InputData are not accessible from formulas in Projection. So assign InputData to a name(e.x. inp) in Projection.

model.Projection.inp = model.InputData

Then, change the formulas in model_points and reference inp.start_mp and inp.end_mp and inp.all_model_points().

def model_points():
    return inp.all_model_points().iloc[inp.start_mp:inp.end_mp]

[happyych]

Thank you for your advice!

I have one more question. Does your advice also work when I export the model?

When I export the model, although I changed "start_mp" and "end_mp" at "InputData" space, it seems "model_point()" at "Projection" space doesn't change.

I am curious about whether it only works in modelx or I can also apply it after exporting.

Thank you!

[fumitoh]

That's a good question. No, my example doesn't work for the exported model.
Currently, there's no way to clear values in exported models.

The workaround is to parameterize Projection with block_id by either:

model.Projection.parameters = ("block_id",)  # comma is needed

or

model.Projection.formula = lambda block_id: None

model----Projection[block_id]----result_output()
       |                      +--model_points()
       |                      +--inp<-----InputData          
       |
       |
       +-InputData----all_model_points()

model_points needs to be changed accordingly.

def model_points():
    start_mp = block_id * 1000
    end_mp = (block_id + 1) * 1000
    return inp.all_model_points().iloc[start_mp:end_mp]   
    # Actually you need to take min of end_mp and len(inp.all_model_points()) for the upper bound

The updated model (before export) will create Projection[0], Projection[1], Projection[2], ....
so you should delete each Projection[i] by del model.Projection[i] in the loop after you copied result_output.

The exported model doesn't support del model.Projection[i] at the momemnt.
As a hack, you can do del model.Projection._mx_roots[i] until del model.Projection[i] becomes available for exported models.

[happyych]

Wow... thank you for your detail explanation.
Through your recommendation, it works well!

Do you have any plan to add function for deleting value in "exported" model?

Hope to see the new version which can
delete sub parameter space as you mentioned.

Thanks!

[fumitoh]

Yes, I'd like to implement it in a future release.