We use cookies on this site to enhance your user experience. By browsing this website, you consent to the use of cookies. Learn more.

Turn on suggestions

Auto-suggest helps you quickly narrow down your search results by suggesting possible matches as you type.

Showing results for

- AI & ML General
- :
- Eureqa
- :
- Use time delays or time-lags of a variable in Eure...

- Article History
- Subscribe to RSS Feed
- Mark as New
- Mark as Read
- Bookmark
- Subscribe
- Email to a Friend
- Printer Friendly Page
- Report Inappropriate Content

Use time delays or time-lags of a variable in Eureqa

*Originally posted on 6/28/13 by Michael Schmidt*

*----------*

A time delay retrieves the value of a variable or expression at a fixed offset in the past, according to the time ordering or index of each data point in the dataset. This post describes the time delay building-blocks available in Eureqa and different modeling techniques with delayed values.

Eureqa provides the delay(x, c) building-block to represent an arbitrary time delay, where *x* could be any expression. The expression delay(x, c) returns the value of *x* at *c* time units in the past. When delay(x, c) is used as a building-block, Eureqa can automatically optimize expressions or variables to be delayed with time delay amount *c*.

The figure above plots an arbitrary variable *x* and a delayed value delay(x, 1.0), where the values are ordered by some time variable *t*. The delayed version is equal to *x* at 1.0 time units into the past.

To use time delay building-blocks, your data must have some notion of time or ordering. You also need to tell Eureqa which variable in your data represents the time or ordering value:

If you don’t specify a time variable, Eureqa will use the row number in the spreadsheet as the time value of each data point.

If a particular delayed time value falls between two points in the dataset, the value is linearly interpolated between the two data points using the time value.

Eureqa also provides the delay_var(x, c) building-block which is identical to delay(x, c), except that it only accepts a variable as input. It’s provided as a special case of the delay(x, c) building-block to allow you to constrain the types delays used in the solutions; though, in the end, they are effectively identical.

Notice that the delayed output plotted above does not have values on the left side of the graph for the first few time points. This is because these points request previous values of *x* that lie before the first point in our dataset. Eureqa will automatically ignore these data points when calculating errors.

However, there is a way to control how much of the dataset Eureqa is allowed to ignore—you may specify a maximum delay offset. You can limit the fraction of data used for time delay history values in the *Advanced Solution Settings* menu:

The default maximum fraction is 50% of the data. If you find that Eureqa is identifying solutions with very large time delays, perhaps just to avoid modeling difficult features in the first half of the dataset, you may want reduce this fraction.

Additionally, you can control the number of delayed values per variable (including a zero delay of an ordinary variable use) in this dialog.

Another way to model a value as a function of its previous values is with fixed delays. You can enter in fixed time delays, or “lags” of the variable, directly into the **Search Relationship** option. For example:

` x = f( delay(x, 2.1), delay(x, 5.6) )`

This search relationship tells Eureqa to find an equation to model the value of *x* as a function of its value at 2.1 and 5.6 time units in the past.

You may also want to specify a minimum time delay offset. If you entered a search relationship such as x = f(x), Eureqa would find a trivial answer f(x) = x. More likely, you wanted to find a model of *x*, but as a function of *x* at least some amount of time in the past. The way to do this is to again use a fixed delay, such as:

` x = f(delay(x, 3.21))`

Here, 3.21 is the minimum time delay. Now, if the time delay building-blocks are enabled, Eureqa can delay this delayed input further if necessary.

Another common use for time delays is for modeling using Delay Differential Equations. Finding delay differential equations is just like searching for ordinary differential equations. For example, enter a search relationship like

` D(y,t) = f(y)`

but also enable time delay building-blocks. This relationship has a trivial solution; however, Eureqa will return the slope formula such as

` f(y) = ( y – delay(y, 0.1) )/0.1`

Therefore, you most likely want to limit the total number of delays per variable to one (which includes the zero delay of the normal variable use). You can set this in the Advanced Solution Settings menu. The default is unlimited.

In MATLAB, you can implement a time delay using the interp1 function. For example, the expression delay(x, 1.23) would be implemented as:

` interp1(t, x, t — 1.23, ‘linear’)`

Implementing delays in Excel is a littler harder. You need to download an Excel add-on that adds an interpolate function. For example, the package XlXtrFun adds a function “Interpolate” that is just like MATLAB's interp1.

© 2019 DataRobot, Inc DataRobot.com Community Guidelines Privacy Policy Terms of Service Version History