Discover MakerZone

MATLAB and Simulink resources for Arduino, LEGO, and Raspberry Pi

Learn more

Discover what MATLAB® can do for your career.

Opportunities for recent engineering grads.

Apply Today

Thread Subject:
parfor

Subject: parfor

From: Saad

Date: 25 Aug, 2011 14:00:27

Message: 1 of 6

Dear All,

I have a function called " example1". I would like to evaluate it accross 9 grids until the ratio of the current value over the previous value is between 0.98 and 1.05. Please look the code below:


%%9 dimensional grid

grid1D=[-10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10];

x=[ 1, 2 3, 4, 5 ,6 ,7 ,8, 9];

arguments_2=num2cell(x);

for k=1:9
    
    
arguments_2{k}=grid1D(k,:);

end


arguments=num2cell(x);


 for k=1:8
     
     if (j >=0.98) & (j <=1.05)
     
            break
  
     else
         
         arguments{k}=arguments_2{k};
     
 for i=1:21
  
    arguments{k}=arguments_2{k}(i)

h(i,:)=example1(arguments{:})
 

 end

[j1, idx]=min(h)

  arguments{k}=grid1D(idx)

 
   for i=1:21
  
    arguments{k+1}=arguments_2{k+1}(i)

h(i,:)=example1(arguments{:})
 

 end

[j2, idx]=min(h);

  arguments{k+1}=grid1D(idx);
  
  
  j=j2/j1
   
  
     end
  
 end
  

The function "example1" takes approximately 12 hours to run thats why I would like to use parfor. Now I dont know in which loop it is the most efficient to place it in my code above? Any comment would be very helpful. Thanks a lot

Best
S
  

Subject: parfor

From: Steven_Lord

Date: 25 Aug, 2011 15:21:18

Message: 2 of 6



"Saad " <saad.badaoui07@imperial.ac.uk> wrote in message
news:j35khr$gem$1@newscl01ah.mathworks.com...
> Dear All,
>
> I have a function called " example1". I would like to evaluate it accross
> 9 grids until the ratio of the current value over the previous value is
> between 0.98 and 1.05. Please look the code below:

*snip*

There's no need to repeat yourself; please try to keep all discussion of one
problem in one thread in the future. Thanks.

http://www.mathworks.com/matlabcentral/newsreader/view_thread/311906


Anyway, your statement "the ratio of the current value over the previous
value" suggests to me that the result of your computations is going to
depend on the order of the iterate values for which the loop body is
evaluated. That is incompatible with PARFOR:

http://www.mathworks.com/help/toolbox/distcomp/brb2x2l-1.html#brdqg4q-1

"You cannot use a parfor-loop when an iteration in your loop depends on the
results of other iterations. Each iteration must be independent of all
others."


Why are you trying to brute-force your function? You're going to need to
evaluate it for each of 21^9 points -- that's a LOT of function evaluations
if your function is not vectorized! I _think_ if you were to create custom
creation, mutation, and crossover functions you may be able to use Global
Optimization Toolbox to solve your problem.

http://www.mathworks.com/help/toolbox/gads/f6174dfi10.html#f14223

Alternately, if you clearly describe IN WORDS (NOT equations or code) what
exactly you're trying to do someone may be able to offer a suggestion as to
how to do what you want without brute-force.

--
Steve Lord
slord@mathworks.com
To contact Technical Support use the Contact Us link on
http://www.mathworks.com

Subject: parfor

From: Matt J

Date: 25 Aug, 2011 17:25:30

Message: 3 of 6

A few miscellaneous remarks:


> for k=1:8
>
> if (j >=0.98) & (j <=1.05)
=================

Are you sure it makes sense to apply this stopping criterion for every individual k? It's certainly not a good way in general to see if you've found a minimim. For example, if I apply your technique to the minimization of

 f(x)=x(1)^2 + x(2)^2 + x(3)^2

starting at x=[0 0 1], then I will get j=1 right from loop iteration k=2 and the algorithm will stop without ever processing x(3).



         
> arguments{k}=arguments_2{k};
================

This command plays no role in your code and should probably be deleted.
You immediately overwrite
arguments{k} with arguments_2{k}(i) in later lines of code.



> arguments{k}=grid1D(idx)
==============

Shouldn't this be

   arguments{k}=grid1D(k,idx);



>
> for i=1:21
>
> arguments{k}=arguments_2{k}(i)
>
> h(i,:)=example1(arguments{:})
>
>
> end
>
> [j1, idx]=min(h)
==========================

It doesn't really make sense that you run this loop twice for every k in order to get both j1 and j2. When the for-loop over k increments and k becomes k+1, your computation of j1 will be identical to your most recent computation of j2.





 
> The function "example1" takes approximately 12 hours to run thats why I would like to use parfor.
===================

As Steve said, nothing above looks parallelizable. However, 12 hours is a really long time for a function evaluation. Why don't you show us what's inside example1 and we can see if maybe PARFOR can be used to accelerate example1 itself?

Subject: parfor

From: Saad

Date: 25 Aug, 2011 21:19:13

Message: 4 of 6

"Matt J" wrote in message <j360ia$rd6$1@newscl01ah.mathworks.com>...
> A few miscellaneous remarks:
>
>
> > for k=1:8
> >
> > if (j >=0.98) & (j <=1.05)
> =================
>
> Are you sure it makes sense to apply this stopping criterion for every individual k? It's certainly not a good way in general to see if you've found a minimim. For example, if I apply your technique to the minimization of
>
> f(x)=x(1)^2 + x(2)^2 + x(3)^2
>
> starting at x=[0 0 1], then I will get j=1 right from loop iteration k=2 and the algorithm will stop without ever processing x(3).
>
>
>
>
> > arguments{k}=arguments_2{k};
> ================
>
> This command plays no role in your code and should probably be deleted.
> You immediately overwrite
> arguments{k} with arguments_2{k}(i) in later lines of code.
>
>
>
> > arguments{k}=grid1D(idx)
> ==============
>
> Shouldn't this be
>
> arguments{k}=grid1D(k,idx);
>
>
>
> >
> > for i=1:21
> >
> > arguments{k}=arguments_2{k}(i)
> >
> > h(i,:)=example1(arguments{:})
> >
> >
> > end
> >
> > [j1, idx]=min(h)
> ==========================
>
> It doesn't really make sense that you run this loop twice for every k in order to get both j1 and j2. When the for-loop over k increments and k becomes k+1, your computation of j1 will be identical to your most recent computation of j2.
>
>
>
>
>
>
> > The function "example1" takes approximately 12 hours to run thats why I would like to use parfor.
> ===================
>
> As Steve said, nothing above looks parallelizable. However, 12 hours is a really long time for a function evaluation. Why don't you show us what's inside example1 and we can see if maybe PARFOR can be used to accelerate example1 itself?


Hi Matt and Steven

Apologies for the repetition it wont happen next time. Unfortunately the function example1 is really long and depends on other functions thats why I didnt paste it. To run the function takes up to 12 hours (generally between 5 and 12h max). Another bad news is that the function cannot be vectorized.
Here is what I am doing:

1) I am setting up a 9-D grid: grid1D is a cell.
 grid1D=[-10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10]; %% this is just an example. In my study, I will just take 6 values per grid otherwise the number of evaluation will be very high.

2) the function "example1" is function of 9 parameters. So the aim of this exercise is to evaluate "example1" by changing the first parameter (iterating accross grid1D{1}) and keeping the other parameters fixed. Once this operation is done, take the parameter of grid1D{1} that gives the smallest value of "example1" and plug it into the function and move to other grid (grid1D{2}). Iterate accross all the values of this grid and keep the parameter that minimize the function "example1"....I keep doing this until "if" condition is fullfilled.

Now all I am doing is evaluating the same function by changing the parameters (in each grid1D). so In theory this is parallelizable no? Maybe the way I wrote the code above is confusing ? (sorry about that)

Matt, I am not sure but I think the reason why your function quickly fulfilled the "if" condition is because the function that you took as example is quite simple which is not the case for "example1". But I agree it is risky the iteration is risky it might not evaluate all the grids.

3) so basically in my code I am iterating accross the Grids and inside each grid I am iterating accross the values of the grid

As you mentioned PARFOR is not suitable when one iteration is dependent on the others but there is a still a room to use PARFOR in my case no? knowing that all I do is to evaluate the function at different values?

4) Worse case scenario, do you think I can do it manually? I can run the inner loop with PARFOR for grid1{1} ( I iterate accross grid1d{1} )

%%%%Inner loop%%%%
 parfor i=1:21
  
    arguments{k}=arguments_2{k}(i)

h(i,:)=example1(arguments{:})
 

 end

[j1, idx]=min(h)

  arguments{k}=grid1D(idx)

Store the best parameter and plug it in the function " example1" and then move to grid1D{2} run with parfor again and keep going until the function doesnt change (much)...it might be a silly way but at least it will enable me to use PARFOR to speed up the computation...What do you think?

Matt I also agree with you it might not be an intelligent way to minimize the function but Iam just replication a paper to retrieve the parameters.

Sorry for this long email and thanks a lot for any valuable advice you could give me.

Best Regards

S

Subject: parfor

From: Steven_Lord

Date: 25 Aug, 2011 21:34:15

Message: 5 of 6



"Saad " <saad.badaoui07@imperial.ac.uk> wrote in message
news:j36e8h$f8b$1@newscl01ah.mathworks.com...
> "Matt J" wrote in message <j360ia$rd6$1@newscl01ah.mathworks.com>...

*snip*

> Hi Matt and Steven
>
> Apologies for the repetition it wont happen next time. Unfortunately the
> function example1 is really long and depends on other functions thats why
> I didnt paste it. To run the function takes up to 12 hours (generally
> between 5 and 12h max). Another bad news is that the function cannot be
> vectorized.

How long does ONE execution of your function take?
Have you run one execution through the Profiler to identify where the
bottlenecks are located?
How sure are you that it is impossible to vectorize your function? Is it
simply more difficult to vectorize than you want to do at the moment?

> Here is what I am doing:
>
> 1) I am setting up a 9-D grid: grid1D is a cell.
> grid1D=[-10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10;
> -10:1:10; -10:1:10]; %% this is just an example. In my study, I will just
> take 6 values per grid otherwise the number of evaluation will be very
> high.

Why?

> 2) the function "example1" is function of 9 parameters. So the aim of
> this exercise is to evaluate "example1" by changing the first parameter
> (iterating accross grid1D{1}) and keeping the other parameters fixed. Once
> this operation is done, take the parameter of grid1D{1} that gives the
> smallest value of "example1" and plug it into the function and move to
> other grid (grid1D{2}). Iterate accross all the values of this grid and
> keep the parameter that minimize the function "example1"....I keep doing
> this until "if" condition is fullfilled.

So you don't actually need to evaluate on all 21^9 elements of your 9-D
grid. Instead you'll do something like evaluating at (switching to 4D to
save me some typing)

part 1:
[-10 -10 -10 -10]
[-9 -10 -10 -10]
[-8 -10 -10 -10]
% etc
[10 -10 -10 -10]

and decide for which x the value of the function evaluated at
[x -10 -10 -10] is minimized, then repeat with:

part 2:
% we already know [x -10 -10 -10] from part 1
[x -9 -10 -10]
[x -8 -10 -10]
[x -7 -10 -10]
% etc
[x 10 -10 -10]

part 3:
[x y -9 -10]
% etc

Is this a correct assessment of what you're trying to do?

> Now all I am doing is evaluating the same function by changing the
> parameters (in each grid1D). so In theory this is parallelizable no? Maybe
> the way I wrote the code above is confusing ? (sorry about that)

The evaluation may be parallelizable, but since part 2 depends on the
results of part 1, part 1 must be completed before you can start part 2 and
so on down the line. Thus you could parallelize this in chunks of 20 or 21
functions evaluations being done in parallel; depending on how involved your
function is, the benefit from parallelizing may be good or may be outweighed
by the parallel setup cost.

*snip*

> Matt I also agree with you it might not be an intelligent way to minimize
> the function but Iam just replication a paper to retrieve the parameters.

How did the author of the paper retrieve those parameters -- did they do it
in this same pseudo brute-force way?

--
Steve Lord
slord@mathworks.com
To contact Technical Support use the Contact Us link on
http://www.mathworks.com

Subject: parfor

From: Saad

Date: 26 Aug, 2011 14:31:27

Message: 6 of 6

"Steven_Lord" <slord@mathworks.com> wrote in message <j36f4n$hpu$1@newscl01ah.mathworks.com>...
>
>
> "Saad " <saad.badaoui07@imperial.ac.uk> wrote in message
> news:j36e8h$f8b$1@newscl01ah.mathworks.com...
> > "Matt J" wrote in message <j360ia$rd6$1@newscl01ah.mathworks.com>...
>
> *snip*
>
> > Hi Matt and Steven
> >
> > Apologies for the repetition it wont happen next time. Unfortunately the
> > function example1 is really long and depends on other functions thats why
> > I didnt paste it. To run the function takes up to 12 hours (generally
> > between 5 and 12h max). Another bad news is that the function cannot be
> > vectorized.
>
> How long does ONE execution of your function take?
> Have you run one execution through the Profiler to identify where the
> bottlenecks are located?
> How sure are you that it is impossible to vectorize your function? Is it
> simply more difficult to vectorize than you want to do at the moment?
>

To be honest, I am not very confident about the fact the function "example1" cannot be vectorized, it is just that the function itself is a sequence of other long functions ( and Iam not sure how to vectorize them at the moment).

Yes I run one execution through Profiler and the speed problem is coming from an optimization (of 5 parameters). because each time, fminsearch iterates to evaluate the function that I would like to minimize (say function "example2") it has to read another functions in the file because their outputs are necessary to compute the output of "example2".


> > Here is what I am doing:
> >
> > 1) I am setting up a 9-D grid: grid1D is a cell.
> > grid1D=[-10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10; -10:1:10;
> > -10:1:10; -10:1:10]; %% this is just an example. In my study, I will just
> > take 6 values per grid otherwise the number of evaluation will be very
> > high.
>
> Why?

I would like to start with max 10 values for each grid because 21 evaluations for each grid might be a bit too much.

>
> > 2) the function "example1" is function of 9 parameters. So the aim of
> > this exercise is to evaluate "example1" by changing the first parameter
> > (iterating accross grid1D{1}) and keeping the other parameters fixed. Once
> > this operation is done, take the parameter of grid1D{1} that gives the
> > smallest value of "example1" and plug it into the function and move to
> > other grid (grid1D{2}). Iterate accross all the values of this grid and
> > keep the parameter that minimize the function "example1"....I keep doing
> > this until "if" condition is fullfilled.
>
> So you don't actually need to evaluate on all 21^9 elements of your 9-D
> grid. Instead you'll do something like evaluating at (switching to 4D to
> save me some typing)
>
> part 1:
> [-10 -10 -10 -10]
> [-9 -10 -10 -10]
> [-8 -10 -10 -10]
> % etc
> [10 -10 -10 -10]
>
> and decide for which x the value of the function evaluated at
> [x -10 -10 -10] is minimized, then repeat with:
>
> part 2:
> % we already know [x -10 -10 -10] from part 1
> [x -9 -10 -10]
> [x -8 -10 -10]
> [x -7 -10 -10]
> % etc
> [x 10 -10 -10]
>
> part 3:
> [x y -9 -10]
> % etc
>
> Is this a correct assessment of what you're trying to do?
>

Yes thats exactly what I am trying to do.


> > Now all I am doing is evaluating the same function by changing the
> > parameters (in each grid1D). so In theory this is parallelizable no? Maybe
> > the way I wrote the code above is confusing ? (sorry about that)
>
> The evaluation may be parallelizable, but since part 2 depends on the
> results of part 1, part 1 must be completed before you can start part 2 and
> so on down the line. Thus you could parallelize this in chunks of 20 or 21
> functions evaluations being done in parallel; depending on how involved your
> function is, the benefit from parallelizing may be good or may be outweighed
> by the parallel setup cost.
>

I agree that I need to wait until the first iteration is finished before running the second one. Now if I run the first loop of the first grid in this way:

for i=1:21 %% iteration accross the value of the first grid
  
    arguments{k}=arguments_2{k}(i)

h(i,:)=example1(arguments{:})
 

 end

[j1, idx]=min(h)
.....
It says that the variables has a classification problems. I dont think I parallelized the loop in a good way. I was wondering if you could suggest a code that could be help parfor to run? because since I am doing it grid by grid now I probably have to delete "arguments{k}=arguments_2{k}(i)" ? Thank you very much for your comment on this.

> *snip*
>
> > Matt I also agree with you it might not be an intelligent way to minimize
> > the function but Iam just replication a paper to retrieve the parameters.
>
> How did the author of the paper retrieve those parameters -- did they do it
> in this same pseudo brute-force way?

Yes the author did it exaclty the same way (Grid Search Method).



Kind Regards

Saad
>
> --
> Steve Lord
> slord@mathworks.com
> To contact Technical Support use the Contact Us link on
> http://www.mathworks.com

Tags for this Thread

What are tags?

A tag is like a keyword or category label associated with each thread. Tags make it easier for you to find threads of interest.

Anyone can tag a thread. Tags are public and visible to everyone.

Contact us