155 views

Skip to first unread message

Jun 4, 2013, 12:01:28 PM6/4/13

to eureqa...@googlegroups.com

I can't think of a good way to do this currently. We might add support for group-wise coefficients at some point that could do this.

I'm not sure if this is useful here, but there is a correlation coefficient error metric you can choose. This would ignore differences in offset (and scale) and just focus on shape.

Another trick you might use to turn a single coefficient into many is to use a periodic function, for example you might try:

y = f0()*sin( f1()*par + f2() ) + f3()*x

I'm not certain how well this would work though, especially with 60 different offsets, but might be worth a shot.

Michael

On Wed, May 29, 2013 at 8:59 AM, <bene...@gbg.bg> wrote:

Lets say I have the following function:

f(x) = C + a*x

Real function has many more parameters, but that's irrelevant for this topic.

The data I have looks like:

par x f(x)

1 2 204

1 3 206

1 4 208

2 2 104

2 3 106

2 4 108

3 2 504

3 3 506

3 4 508

In this case the solution would be f(x) = C + 2*x, where C[3] = [200, 100, 500]

The way I simulate this currently is with the following syntax

f(x) = if ( par=1, f0() , if ( par=2, f1(), f2() ) ) + f3()*x

The problem is that par ranges between 1-60. Writing that with nested if - then - else modules would be unreadable. Is there a way to do the same without 60 nested 'if's?

--

You received this message because you are subscribed to the Google Groups "Eureqa Group" group.

To unsubscribe from this group and stop receiving emails from it, send an email to eureqa-group...@googlegroups.com.

For more options, visit https://groups.google.com/groups/opt_out.

Jul 18, 2013, 8:51:43 AM7/18/13

to eureqa...@googlegroups.com

Well, no, the trick didn't work unfortunately. What I'm experiencing though is Eureqa slowing down to a crawl and getting quite inefficient. Here's one of the functions I'm trying to solve:

wi = if(tr = 1, f11(), if(tr = 2, f12(), if(tr = 3, f13(), if(tr = 4, f14(), if(tr = 5, f15(), if(tr = 6, f16(), if(tr = 7, f17(), if(tr = 8, f18(), if(tr = 9, f19(), if(tr = 10, f20(), if(tr = 11, f21(), if(tr = 12, f22(), if(tr = 13, f23(), if(tr = 14, f24(), if(tr = 15, f25(), if(tr = 16, f26(), if(tr = 17, f27(), if(tr = 18, f28(), if(tr = 19, f29(), f30()))))))))))))))))))) + if(tr = 1, f111(), if(tr = 2, f112(), if(tr = 3, f113(), if(tr = 4, f114(), if(tr = 5, f115(), if(tr = 6, f116(), if(tr = 7, f117(), if(tr = 8, f118(), if(tr = 9, f119(), if(tr = 10, f120(), if(tr = 11, f121(), if(tr = 12, f122(), if(tr = 13, f123(), if(tr = 14, f124(), if(tr = 15, f125(), if(tr = 16, f126(), if(tr = 17, f127(), if(tr = 18, f128(), if(tr = 19, f129(), f130())))))))))))))))))))*ta + f2()*l1 + f3()*l3 + f4()*l4 + f5()*l5 + f6()*s1 + f7()*s3 + f8()*s4 + f9()*s5

which in normal terms would look like

wi = A[tr] + B[tr]*ta + f2()*l1 + f3()*l3 + f4()*l4 + f5()*l5 + f6()*s1 + f7()*s3 + f8()*s4 + f9()*s5, where tr goes from 1 to 20.

On a dual core cpu this ends up with 2-3 generations per second, understandably getting a result takes forever. What's more, the system doesn't realize which values it needs to adjust and seemingly just randomly changes all of them till it achieves a result with lower error. For example if I've got a result with a minimal margin of error and I add more data for tr 20, Eureqa should only change the value of f30() and f130(), but instead it changes everything, losing accuracy on other data sets.

I don't know, maybe I'm using the wrong tool for solving my problem, but I haven't found one yet. Ignoring this issue Eureqa is an amazing piece of software and it has helped me greatly so far.

wi = if(tr = 1, f11(), if(tr = 2, f12(), if(tr = 3, f13(), if(tr = 4, f14(), if(tr = 5, f15(), if(tr = 6, f16(), if(tr = 7, f17(), if(tr = 8, f18(), if(tr = 9, f19(), if(tr = 10, f20(), if(tr = 11, f21(), if(tr = 12, f22(), if(tr = 13, f23(), if(tr = 14, f24(), if(tr = 15, f25(), if(tr = 16, f26(), if(tr = 17, f27(), if(tr = 18, f28(), if(tr = 19, f29(), f30()))))))))))))))))))) + if(tr = 1, f111(), if(tr = 2, f112(), if(tr = 3, f113(), if(tr = 4, f114(), if(tr = 5, f115(), if(tr = 6, f116(), if(tr = 7, f117(), if(tr = 8, f118(), if(tr = 9, f119(), if(tr = 10, f120(), if(tr = 11, f121(), if(tr = 12, f122(), if(tr = 13, f123(), if(tr = 14, f124(), if(tr = 15, f125(), if(tr = 16, f126(), if(tr = 17, f127(), if(tr = 18, f128(), if(tr = 19, f129(), f130())))))))))))))))))))*ta + f2()*l1 + f3()*l3 + f4()*l4 + f5()*l5 + f6()*s1 + f7()*s3 + f8()*s4 + f9()*s5

which in normal terms would look like

wi = A[tr] + B[tr]*ta + f2()*l1 + f3()*l3 + f4()*l4 + f5()*l5 + f6()*s1 + f7()*s3 + f8()*s4 + f9()*s5, where tr goes from 1 to 20.

On a dual core cpu this ends up with 2-3 generations per second, understandably getting a result takes forever. What's more, the system doesn't realize which values it needs to adjust and seemingly just randomly changes all of them till it achieves a result with lower error. For example if I've got a result with a minimal margin of error and I add more data for tr 20, Eureqa should only change the value of f30() and f130(), but instead it changes everything, losing accuracy on other data sets.

I don't know, maybe I'm using the wrong tool for solving my problem, but I haven't found one yet. Ignoring this issue Eureqa is an amazing piece of software and it has helped me greatly so far.

Reply all

Reply to author

Forward

0 new messages

Search

Clear search

Close search

Google apps

Main menu