Empirical Dynamic Modeling (EDM)

https://sugiharalab.github.io/EDM_Documentation
Admin
Empirical Dynamic Modeling (EDM) is a non-parametric framework for modeling nonlinear dynamic...
Tokens:17,231
Snippets:95
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Install rEDM using install.packages

Source: https://sugiharalab.github.io/EDM_Documentation/installation

Installs the rEDM library, an R package for Empirical Dynamic Modeling, using the install.packages function. This is the standard method for R installations.

```r
install.packages("rEDM")
```

--------------------------------

### Install pyEDM using pip

Source: https://sugiharalab.github.io/EDM_Documentation/installation

Installs the pyEDM library, a Python package for Empirical Dynamic Modeling, using the pip package installer. This is the standard method for Python installations.

```python
pip install pyEDM
```

--------------------------------

### Import Libraries and Load Data

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Imports necessary libraries from pyEDM and matplotlib, and loads sample data for demonstration.

```python
from pyEDM import *
import matplotlib.pyplot as plt


```

```python
tentmap      = sampleData['TentMap']
tentmapNoise = sampleData['TentMapNoise']


```

```python
plt.plot( tentmap['TentMap'][1:40] );


```

--------------------------------

### Inference of Causality (Convergent Cross Mapping - CCM)

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Infers causality between time series using Convergent Cross Mapping (CCM). CCM determines if one time series can be used to reconstruct the dynamics of another, suggesting a directional influence. This example visualizes the relationship between sardine population and sea surface temperature and then applies CCM to infer causality.

```python
sardine_anchovy_sst = sampleData['sardine_anchovy_sst']
sardine_anchovy_sst[['anchovy','np_sst']].plot();


```

```python
CCM( dataFrame = sardine_anchovy_sst, E = 3, 
     columns = "anchovy", target = "np_sst",
     libSizes = "10 75 5", sample = 100, showPlot = True );


```

--------------------------------

### Simplex Prediction

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Performs time series prediction using the Simplex projection method. This method reconstructs the dynamics of the system in the state space and uses nearest neighbors to forecast future values. It requires the data frame, library and prediction ranges, column name(s), embedding dimension (E), and an option to show the plot.

```python
Simplex( dataFrame = tentmapNoise, lib = "1 500", pred = "501 550", 
         columns = "TentMap", E = 2, showPlot = True );


```

--------------------------------

### Evaluate Optimal SMap Theta Parameter

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Evaluates the optimal theta parameter for the SMap (State-dependent Moving Average) algorithm, which indicates state-dependence and the extent of nonlinearity. The PredictNonlinear function is used, requiring the data frame, library and prediction ranges, column name(s), and embedding dimension (E).

```python
PredictNonlinear( dataFrame = tentmapNoise, lib = "1 100", pred = "201 500",
                  columns = "TentMap", E = 2 );


```

--------------------------------

### Simplex Prediction with Multivariate Embedding

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Demonstrates Simplex prediction using multivariate time series data. This involves reconstructing the state space using multiple variables. The function call includes the data frame, library and prediction ranges, embedding dimension (E), the target variable, and specifies that the embedding is multivariate (`embedded = True`).

```python
block_3sp = sampleData['block_3sp']
block_3sp.head(3)


```

```python
# embedded = True
Simplex( dataFrame = block_3sp, lib = "1 99", pred = "100 195", 
         E = 3, columns = "x_t y_t z_t", target = "x_t",
         embedded = True, showPlot = True );


```

--------------------------------

### Evaluate Optimal Embedding Dimension (Simplex)

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Uses the EmbedDimension function to determine the optimal embedding dimension (E) for time series data. This is crucial for reconstructing the attractor of a dynamical system. The function requires the data frame, a library range, a prediction range, and the column name(s) to analyze.

```python
EmbedDimension( dataFrame = tentmap, lib = "1 100", pred = "201 500", 
                columns = "TentMap" );


```

--------------------------------

### SMap Prediction with Multivariate Embedding

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Demonstrates SMap prediction using multivariate time series data with embedded dimensions. This allows for capturing complex interactions between multiple variables. The function call includes the data frame, library and prediction ranges, theta parameter, embedding dimension (E), specifies multivariate embedding (`embedded = True`), the columns to use, the target variable, and an option to show the plot.

```python
# embedded = True
SMap( dataFrame = sampleData[ 'circle' ],
      lib = "1 100", pred = "110 190", theta = 4, E = 2, 
      embedded = True, columns = "x y", target = "x", showPlot = True );


```

--------------------------------

### SMap Prediction

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Performs time series prediction using the SMap (State-dependent Moving Average) algorithm. SMap accounts for the changing dynamics of a system over time. This function requires the data frame, library and prediction ranges, column name(s), embedding dimension (E), the theta parameter, and an option to show the plot.

```python
SMap( dataFrame = tentmapNoise, lib = "1 500", pred = "501 550", 
      columns = "TentMap", E = 2, theta = 3, showPlot = True );


```

--------------------------------

### Evaluate Nonlinearity (PredictInterval)

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Assesses the nonlinearity of a time series by examining the decay in predictability as the forecast interval increases. The PredictInterval function is used for this purpose, requiring the data frame, library and prediction ranges, column name(s), and the embedding dimension (E).

```python
PredictInterval( dataFrame = tentmap, lib = "1 100", pred = "251 500",
                 columns = "TentMap", E = 2 );


```

--------------------------------

### Multiview Embedding

Source: https://sugiharalab.github.io/EDM_Documentation/basic_examples

Performs Multiview embedding to analyze time series data by considering different combinations of variables and their lagged versions. This can reveal complex relationships and improve predictive accuracy. The function requires the data frame, library and prediction ranges, embedding dimension (E), the columns to use, the target variable, and an option to show the plot. The output includes metrics like MAE and RMSE for different views.

```python
MV = Multiview( dataFrame = block_3sp, lib = "1 99", pred = "105 190", E = 3,
                columns = "x_t y_t z_t", target = "x_t", showPlot = True );


```

```python
MV['View']
# Col_i are column indices in block_3sp


```

--------------------------------

### Configuring SMap Solvers with sklearn Regularization

Source: https://sugiharalab.github.io/EDM_Documentation/solvers_demo

Sets up a dictionary of SMap solvers, including the default SVD (None) and various scikit-learn linear models with specified regularization parameters. This allows for flexible control over the SMap fitting process.

```python
circle = pyEDM.sampleData['circle']

lmSolvers = {
    'SVD'          : None, 
    'Ridge'        : Ridge( alpha = 0.05 ),
    'Lasso'        : Lasso( alpha = 0.005 ),
    'ElasticNet'   : ElasticNet( alpha = 0.001, l1_ratio = 0.001 ),
    'RidgeCV'      : RidgeCV(),
    'LassoCV'      : LassoCV( cv = 5 ),
    'ElasticNetCV' : ElasticNetCV( l1_ratio = [.05,.1,.5,.7,.9,.95,1], cv = 5 )
}
```

--------------------------------

### Initialize Data Structures for S-map Visualization (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Initializes pandas DataFrames and numpy arrays for the Lorenz system data. It loads the data, defines a query point, and adds 'dist' and 'weight' columns to the DataFrame, which will be used for S-map calculations.

```python
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# load the lorenz system data and assign the query point (arbitrary)
lorenz    = pd.read_csv("lorenz_full_system.csv")
N         = lorenz.shape[0]
query_idx = 300 
query_pt  = lorenz.iloc[query_idx]
truth_pt  = lorenz.iloc[query_idx + 1] # Tp = 1

# add columns for distance and weight
lorenz.insert(3,"dist",  np.zeros(N))
lorenz.insert(4,"weight",np.zeros(N))
```

--------------------------------

### Load and Inspect Sample Data

Source: https://sugiharalab.github.io/EDM_Documentation/cond_emb_demo

Loads the 'circle' sample dataset and displays the first three rows to provide an overview of the data structure. This step is crucial for understanding the input data before applying embedding techniques.

```python
df = sampleData["circle"]
df.head(3)

```

--------------------------------

### Applying SMap with Custom sklearn Solvers

Source: https://sugiharalab.github.io/EDM_Documentation/solvers_demo

Iterates through the defined SMap solvers, applying each to the 'circle' dataset using pyEDM's SMap function. It prints the solver name and displays a plot of the results, demonstrating the effect of different regularization techniques.

```python
for solverName in lmSolvers.keys() :
    print( solverName )
    result = pyEDM.SMap( dataFrame = circle,
                         lib = "1 100", pred = "101 198",
                         embedded = True, E = 2, theta = 3.14,
                         columns = "x y", target = "x", showPlot = True,
                         solver = lmSolvers[ solverName ] )
```

--------------------------------

### EDM Parameters Documentation

Source: https://sugiharalab.github.io/EDM_Documentation/parameters

This section details the parameters available for various EDM functions, including data input, embedding, prediction, and cross-correlation analysis.

```APIDOC
## EDM Parameters

### Description
This section details the parameters available for various EDM functions, including data input, embedding, prediction, and cross-correlation analysis.

### Parameters

#### Input Data Parameters

- **dataFrame** (data.frame) - Input data.frame. The columns must be named. The first column must be time index, strings or values unless `noTime = True`.
- **columns** (String or vector) - Column name(s) in the input data used to create the library. String names must be whitespace separated.
- **target** (String) - Column name in the input data used for prediction.
- **dataFile** (String) - CSV format data file name. The first row must be column names. The first column must be time index, strings or values unless `noTime = True`.
- **pathIn** (String) - Filesystem path to input `dataFile`. CSV format.
- **noTime** (Logical) - Indicates whether input data lack a time vector in the first column: default `False`.

#### Embedding Parameters

- **E** (Integer) - Embedding dimension.
- **tau** (Integer) - Time offset of embedding specified as number of time series rows. `tau` < 0 are lags, `tau` > 0 future values.
- **embedded** (Logical) - Specifies if the input data are embedded. If `embedded = True`, no embedding is performed. If `embedded = False`, all input data are embedded to dimension `E` with time shift `tau`.
- **validLib** (Boolean vector) - Conditional embedding. Boolean vector identifying time series rows whose corresponding embedding vectors define the state-space library.
- **maxE** (Integer) - Maximum value of `E` to evaluate in `EmbedDimension`.

#### Prediction Parameters

- **Tp** (Integer) - Prediction horizon (number of time column rows).
- **theta** (String or numeric vector) - In `Smap`: S-Map neighbor localisation exponent. Single numeric. In `PredictNonlinear`: A whitespace delimited string or numeric vector with values of S-map localisation parameters to be evaluated.
- **knn** (Integer) - Number of nearest neighbors. If `knn=0`; `knn` is set to `E+1` for `Simplex()`; set to number of `lib` data rows for `SMap()`.
- **exclusionRadius** (Integer) - Excludes library vectors from the search space of nearest neighbors if their relative time index is within `exclusionRadius`.
- **generateSteps** (Logical) - Generative feedback predictions for `Simplex()` or `SMap()`.
- **maxTp** (Integer) - Maximum value of `Tp` to evaluate in `PredictInterval`.

#### Cross-Correlation Measurement (CCM) Parameters

- **lib** (String or vector) - Pairs of start and stop indices of input data rows used to create the library of E-dimensional embedding vectors. String indices must be whitespace separated.
- **libSizes** (String or vector) - Integers specifying CCM library sizes. If three values are provided, and, if the third value is less than the second, they are treated as a sequence generator specifying the initial library size; the final library size; and the library size increment. String values must be whitespace separated.
- **sample** (Integer) - Number of random samples to draw at each library size evaluation for CCM.
- **random** (Logical) - Specifies random (`True`) or sequential library sampling (`False`) in CCM.
- **replacement** (Logical) - Specifies sampling with replacement in CCM. Not recommended.
- **includeData** (Logical) - Returns all CCM projection data frames.
- **seed** (Integer) - Specifies the random sampler seed in CCM. If `seed=0`, then a random seed is generated.
- **sequential** (Logical) - CCM flag to disable multiprocessing.

#### Multiview Parameters

- **multiview** (Integer) - Number of multiview ensembles to average for the final prediction estimate in Multiview.
- **D** (Integer) - Multiview dimension.
- **trainLib** (Logical) - Use in-sample (`lib`=`pred`) prediction for multiview ranking.
- **excludeTarget** (Logical) - Exclude `target` variable from multiviews.

#### General and Utility Parameters

- **pred** (String or vector) - Pairs of start and stop indices of input data rows where predictions are made. String indices must be whitespace separated.
- **solver** (sklearn.linear_model object) - In pyEDM `SMap()`: An instance of a sklearn.linear_model object.
- **ignoreNan** (Logical) - Specifies whether data NaN values are to be ignored in `SMap`: default `True`.
- **numProcess** (Integer) - Number of parallel processes for computation in `EmbedDimension`; `PredictInterval` and `PredictNonlinear`.
- **mpMethod** (String) - Python multiprocessing context start method.
- **chunksize** (Integer) - Python multiprocessing chunksize.
- **verbose** (Logical) - Produces additional console reporting.
- **showPlot** (Logical) - Plots results (pyEDM & rEDM).
```

--------------------------------

### Import pyEDM Library

Source: https://sugiharalab.github.io/EDM_Documentation/cond_emb_demo

Imports all necessary functions from the pyEDM library for use in subsequent analyses. This is a prerequisite for all pyEDM operations.

```python
from pyEDM import *

```

--------------------------------

### Visualize S-map Weighting with Varying Thetas (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Visualizes how the S-map weighting function changes with different values of the localization parameter 'theta'. It calculates weights based on distance and plots the state-space points, with darker points indicating higher weights, for each theta.

```python
thetas = [0,1,2,4]
fig = plt.figure(figsize=(10,10))
for i in range( len(thetas) ): 
    # set the weight
    for idx, row in lorenz.iterrows():
        dist = lorenz['dist'].iloc[idx-1]
        weighted_dist = np.exp( -thetas[i]*dist/dist_scale )
        lorenz['weight'].iloc[idx-1] = weighted_dist

    # plot weighted data - dark points have higher weight
    ax = plt.subplot(2,2,(i+1),projection="3d")
    ax.scatter(lorenz.iloc[:,0],lorenz.iloc[:,1],lorenz.iloc[:,2],
               c=1-lorenz.iloc[:,4],cmap="gray")
    # plot the query point as a red filled circle
    ax.scatter( query_pt[0],query_pt[1],query_pt[2], c="red", s=100)
    plt.title( 'Theta = {}'.format(thetas[i]) ) 
plt.show()
# each of the plots correspond to a theta value which defines
```

--------------------------------

### Weight Library and Response Vector (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Applies an exponential weighting matrix to the model and response vectors. This step is part of the S-Map method, where states closer to the query point are given higher weights for prediction.

```python
# weight our library and response vec
weight_matrix = np.identity(N-1) * lorenz[['weight']][:-1].to_numpy()
model         = np.dot(weight_matrix,model.to_numpy())
response_vec  = np.dot(weight_matrix,response_vec.to_numpy())
```

--------------------------------

### Prepare Data for Autoregressive Model (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Prepares the response vector and the model matrix for an autoregressive model. The model matrix includes lagged embedding vectors and an additional column of ones for the error/constant term. This is a crucial step for time-series prediction using AR models.

```python
response_vec = lorenz[['x']][1:]
model        = lorenz[['x','y','z']][:-1]
# insert column of 1's to compute the error/const of the AR model (sub 1 since last pt has no next pt)
model.insert(0,"err_const",np.ones(lorenz.shape[0]-1))
print(model,response_vec)
```

--------------------------------

### Simplex Prediction Using First 30 Library Points

Source: https://sugiharalab.github.io/EDM_Documentation/cond_emb_demo

Constructs a Simplex prediction model using only the first 30 data points (indices 0-29) of the library. This demonstrates conditional embedding by restricting the library to a specific time subset.

```python
validLib = [False] * df.shape[0]      # 0:199 False
validLib[ 0:29 ] = [True] * 30        # 0:29  True; 30:199 False
pred = Simplex( dataFrame = df, lib = "1 100", pred = "101 195", E = 2, Tp = 1, 
                columns = 'x', target = 'y', validLib = validLib )
PlotObsPred( pred, "CE Partial Lib 1:30", 2, 1 )

```

--------------------------------

### MakeBlock Function

Source: https://sugiharalab.github.io/EDM_Documentation/makeBlock_

Creates a data block of time-delay embedding from each of the columnNames in the dataFrame.

```APIDOC
## MakeBlock Function

### Description
Creates a data block of time-delay embedding from each of the columnNames in the dataFrame.

### Method
N/A (This is a function description, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **DataFrame** (DataFrame) - DataFrame with embedded columns.

#### Response Example
N/A

### Parameters Table
| Parameter | Type | Default | Purpose |
|---|---|---|---|
| dataFrame | pyEDM: pandas DataFrame<br>rEDM: data.frame | None | Input DataFrame |
| E | int | 0 | Embedding dimension |
| tau | int | -1 | Embedding shift. Negative: lag, positive: future |
| columnNames | [] | "" | List of column names |
| deletePartial | bool | False | Remove rows with NaNs from embedding |

### Notes
- Refer to the parameters table for general parameter definitions.
- The `columnNames` is a list of column names.
- The time column is not included in the returned DataFrame.
- The `MakeBlock` function is a low-level function that does not perform error checking. The `Embed` function provides error checking and file-based input.
```

--------------------------------

### Solve for Model Weights using Least Squares (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Solves for the weights of the autoregressive model using the least squares method. This is necessary because the solution for the weights may not be unique. The function returns the constant term and the coefficients for the model.

```python
# solve for our weights (least squares since non-unique solution)
solution = np.linalg.lstsq( model, response_vec, rcond=None )[0]
model_const, model_func = solution[0], solution[1:]
```

--------------------------------

### SMap Projection Function Signature (Python, R)

Source: https://sugiharalab.github.io/EDM_Documentation/smap_

Defines the SMap projection function signature for both Python (pyEDM) and R (rEDM) libraries. It outlines the various parameters available for configuring the SMap analysis, including data input, embedding parameters, prediction settings, and output options.

```python
SMap(dataFrame=None, columns='', target='',
lib='', pred='', E=0, Tp=1, knn=0, tau=-1,
theta=0, exclusionRadius=0, solver=None, embedded=False,
validLib=[], noTime=False, ignoreNan = True,
showPlot=False, verbose=False, returnObject=False)
```

```r
SMap(pathIn="./", dataFile="", dataFrame=NULL,
lib="", pred="", E=0, Tp=1, knn=0, tau=-1,
theta=0, exclusionRadius=0, columns="", target="", 
embedded=FALSE, verbose=FALSE, validLib=vector(), 
ignoreNan=TRUE, generateSteps=0, parameterList=FALSE,
showPlot=FALSE, noTime=FALSE)
```

--------------------------------

### Predict Next State-Space Point (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Applies the computed model function to a query point to predict the next state-space point. It then calculates the error between the predicted point and the true point, demonstrating the accuracy of the prediction.

```python
# apply our computed model function to our query point to get our next point
pred_pt = model_const + np.dot(query_pt, model_func)
error   = pred_pt - truth_pt
print("true point {}, predict {}, error {}".format(
    round(pred_pt[0],4), round(truth_pt[0],4), round(error[0],5)))
```

--------------------------------

### Importing sklearn Linear Models for pyEDM SMap

Source: https://sugiharalab.github.io/EDM_Documentation/solvers_demo

Imports necessary linear model classes from scikit-learn for use with pyEDM's SMap function. These classes allow for custom regularization of the SMap's linear fit.

```python
from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.linear_model import RidgeCV, LassoCV, ElasticNetCV
import pyEDM
```

--------------------------------

### Multiview Embedding and Forecasting (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/multiview_

Implements Multiview embedding and forecasting for a given DataFrame. It requires specifying the target variable and can be configured with various parameters for embedding dimension, prediction interval, and nearest neighbors. The function returns a dictionary containing prediction results and view information.

```python
Multiview(dataFrame=None, columns='', target='',
lib='', pred='', D=0, E=1, Tp=1, knn=0, tau=-1,
multiview=0, exclusionRadius=0, trainLib=True,
excludeTarget=False, verbose=False,
verbose=False, numProcess=4, mpMethod=None,
chunksize=1, showPlot=False, returnObject=False )
```

--------------------------------

### Multiview Embedding and Forecasting (R)

Source: https://sugiharalab.github.io/EDM_Documentation/multiview_

Provides Multiview embedding and forecasting capabilities for R data frames or files. Users can specify input data, target column, and various parameters to control the embedding dimension, prediction interval, and nearest neighbors. The function returns a named list containing prediction and view data frames.

```r
Multiview(pathIn="./", dataFile="", dataFrame=NULL,
lib="", pred="", D=0, E=1, Tp=1, knn=0,
tau=-1, columns="", target="", multiview=0,
exclusionRadius=0, trainLib=TRUE,
excludeTarget=FALSE, parameterList=FALSE,
verbose=FALSE, numThreads=4, showPlot=FALSE, noTime=FALSE)
```

--------------------------------

### Simplex Projection API

Source: https://sugiharalab.github.io/EDM_Documentation/simplex_

Performs Simplex projection on input data, embedding time series and making predictions.

```APIDOC
## Simplex Projection API

### Description
Simplex projection of the input data file or DataFrame. This function embeds time series data using time-delay embedding and generates predictions.

### Method
This documentation describes a function call rather than a traditional HTTP API endpoint.

### Endpoint
N/A (Function Call)

### Parameters
#### General Parameters
- **dataFrame** (pandas DataFrame or data.frame) - Optional - Input DataFrame. For Python, `pyEDM: pandas DataFrame`. For R, `rEDM: data.frame`.
- **columns** (string or []) - Optional - Column names for the library. Defaults to "".
- **target** (string) - Optional - Prediction target column name. Defaults to "".
- **lib** (string or []) - Optional - Pairs of library start stop row indices.
- **pred** (string or []) - Optional - Pairs of prediction start stop row indices.
- **E** (int) - Optional - Embedding dimension. Defaults to 0.
- **Tp** (int) - Optional - Prediction Interval. Defaults to 1.
- **knn** (int) - Optional - Number nearest neighbors. If 0, it is set to E+1. Defaults to 0.
- **tau** (int) - Optional - Embedding time shift (time series rows). Defaults to -1.
- **exclusionRadius** (int) - Optional - Prediction vector exclusion radius. Defaults to 0.
- **embedded** (bool) - Optional - Is data an embedding? If False, embed to E. Defaults to False.
- **verbose** (bool) - Optional - Echo messages. Defaults to False.
- **showPlot** (bool) - Optional - Plot results (pyEDM, rEDM). Defaults to False.
- **validLib** (bool []) - Optional - Conditional embedding. A boolean vector the same length as the number of time series rows. A `false` entry means that the state-space vector derived from the corresponding time series row will not be included in the state-space library. Defaults to [].
- **noTime** (bool) - Optional - Do not require the first data column to be time or index. Defaults to False.

#### Python Specific Parameters
- **returnObject** (bool) - Optional - Return the Simplex class object with all data and variables. Defaults to False.

#### R Specific Parameters
- **pathIn** (string) - Optional - Input data file path. Defaults to "./".
- **dataFile** (string) - Optional - Data file name.
- **pathOut** (string) - Optional - Output file path. Defaults to "./".
- **predictFile** (string) - Optional - Prediction output file.
- **const_pred** (bool) - Optional - Include non projected forecast data. Defaults to False.
- **generateSteps** (int) - Optional - Number of recursive time step predictions. Defaults to 0.
- **generateLibrary** (bool) - Optional - Add generated data to library. Defaults to False.
- **parameterList** (bool) - Optional - Include parameter dictionary in return. Defaults to False.

### Notes
- If `embedded` is false (default), the data `columns` are embedded to dimension `E` with time shift `tau`. If `knn` = 0, it is set to E+1.
- Version 1.x: `nan` values are passed through all numeric computations. Any prediction row (`pred`) with `nan` will result in `nan` simplex prediction. Any library vector with a `nan` will result in `nan` simplex prediction.
- Version 2.x: `nan` values are removed from the data unless `ignoreNan = True`.
- `validLib` implements conditional embedding (CE).
- If `generateSteps` > 0, `Simplex` operates in feedback generative mode. The values of `pred` are overridden to start at the end of the data. At each step, one prediction is made, added to the `columns` data, a new time-delay embedded is created, and the cycle repeated for `generateSteps`. Feedback generation only operates on a univariate time series that is time-delay embedded. The `columns` and `target` variables must be the same.

### Returns
- **Version 1.x**: If `parameterList = False` (default), returns a DataFrame with 3 columns: "Time", "Observations", "Predictions". If `parameterList = True`, returns a list with `predictions`, `parameters`.
- **Version 2.x**: Returns a DataFrame with 3 columns: "Time", "Observations", "Predictions". If `returnObject = True`, returns the Simplex class object with all data and variables.

### Request Example (Python)
```python
import pandas as pd
from pyEDM import Simplex

data = pd.read_csv("your_data.csv")

# Example 1: Basic Simplex projection
predictions_df = Simplex(dataFrame=data, columns="x1", target="x2", E=2, Tp=1)

# Example 2: With time delay embedding and prediction interval
predictions_df_advanced = Simplex(dataFrame=data, columns="x1", target="x2", E=3, Tp=2, tau=1)

# Example 3: Feedback generative mode
generated_data = Simplex(dataFrame=data, columns="x1", target="x1", E=2, Tp=1, generateSteps=10)
```

### Request Example (R)
```R
# Assuming your data is in a file named 'your_data.csv'

# Example 1: Basic Simplex projection
predictions_df <- Simplex(dataFile="your_data.csv", columns="x1", target="x2", E=2, Tp=1)

# Example 2: With time delay embedding and prediction interval
predictions_df_advanced <- Simplex(dataFile="your_data.csv", columns="x1", target="x2", E=3, Tp=2, tau=1)

# Example 3: Using a data frame directly
data_frame <- read.csv("your_data.csv")
predictions_df_direct <- Simplex(dataFrame=data_frame, columns="x1", target="x2", E=2, Tp=1)
```

### Response Example (Success)
```json
{
  "Time": [1, 2, 3, 4, 5],
  "Observations": [10, 12, 15, 13, 16],
  "Predictions": [11, 13, 14, 15, 17]
}
```
```

--------------------------------

### Create Time-Delay Embedding Data Block (MakeBlock)

Source: https://sugiharalab.github.io/EDM_Documentation/makeBlock_

The MakeBlock function generates a data block for time-delay embedding from specified columns in a dataframe. It supports Python and R, with parameters for embedding dimension (E), lag (tau), column selection, and handling of partial data.

```python
MakeBlock(dataFrame, E=0, tau=-1, columnNames=[], deletePartial=False)
```

```r
MakeBlock(dataFrame, E = 0, tau = -1, columns = c(), deletePartial = FALSE)
```

--------------------------------

### Calculate Distances for S-map Localization (Python)

Source: https://sugiharalab.github.io/EDM_Documentation/SMap_Demo

Calculates the Manhattan distance from each state-space vector to the query point and scales it. This distance is a key component in determining the weights for the S-map localization.

```python
# for every vector in the library (all points), set dist from the query point 
for idx, row in lorenz.iterrows():
    # Manhatten distance, could be Euclidean or other
    lorenz['dist'].iloc[idx-1] = np.sum(np.abs( row - query_pt ))
dist_scale = np.sum( lorenz['dist'].iloc[:] ) / N
```

--------------------------------

### Convergent Cross Mapping (CCM) Function Signature - Python and R

Source: https://sugiharalab.github.io/EDM_Documentation/ccm_

This snippet shows the function signatures for CCM in both Python and R. It outlines the primary parameters used for configuring the cross mapping analysis, such as data input, column selection, embedding dimensions, and sampling methods. Note that parameter names and availability may differ slightly between the two languages.

```python
CCM(dataFrame=None, columns='', target='', 
libSizes='', sample=0, E=0, Tp=0, knn=0, tau=-1, 
exclusionRadius=0, seed=0, embedded=False, 
includeData=False, noTime=False, ignoreNan=True,
mpMethod=None, sequential=False,
verbose=False, showPlot=False, returnObject=False)
```

```r
CCM(pathIn="./", dataFile="", dataFrame=NULL, E=0, 
Tp=0, knn=0, tau=-1, exclusionRadius=0,
columns="", target="", libSizes="", sample=0,
random=TRUE, seed=0, embedded=FALSE, includeData=FALSE,
parameterList=FALSE, verbose=FALSE, showPlot=FALSE, noTime=FALSE)
```

--------------------------------

### Create Time-Delay Embedding Data Block (Python, R)

Source: https://sugiharalab.github.io/EDM_Documentation/embed_

Creates a data block of time-delay embedding from columns in a CSV file or DataFrame. Supports specifying input data, embedding dimension (E), time shift (tau), and column selection. The 'includeTime' parameter in Python and 'verbose' in R control additional output. Refer to the parameters table for general definitions.

```python
Embed(dataFrame=None, E=0, tau=-1, columns='', includeTime=False, pathIn='./', dataFile=None, )
```

```r
Embed(path = "./", dataFile = "", dataFrame = NULL, E = 0, tau = -1, columns = "", verbose = FALSE)
```

--------------------------------

### Simplex Projection Function Definition (Python and R)

Source: https://sugiharalab.github.io/EDM_Documentation/simplex_

Defines the Simplex projection function for both Python (pyEDM) and R (rEDM) libraries. These functions project input data to predict future values based on nearest neighbors in the reconstructed state space. They accept various parameters to control embedding, prediction, and data handling.

```python
Simplex(dataFrame=None, columns='', target='', 
lib='', pred='', E=0, Tp=1, knn=0, tau=-1, 
exclusionRadius=0, embedded=False, validLib=[], 
noTime = False, verbose=False, showPlot=False, 
ignoreNan = True, returnObject=False)
```

```r
Simplex(pathIn="./", dataFile="", dataFrame=NULL, 
pathOut="./", predictFile="", lib="", pred="", 
E=0, Tp=1, knn=0, tau=-1, exclusionRadius=0, 
columns="", target="", embedded=FALSE, 
const_pred=FALSE, verbose=FALSE, validLib=vector(), 
generateSteps=0, parameterList=FALSE, 
showPlot=FALSE, noTime=FALSE)
```

--------------------------------

### CCM Function Documentation

Source: https://sugiharalab.github.io/EDM_Documentation/ccm_

Convergent cross mapping between `columns` and `target`. This section details the parameters and behavior of the CCM function available in both Python and R.

```APIDOC
## CCM Function Documentation

### Description
Convergent cross mapping between `columns` : `target`; and, reverse mapping between `target` : `columns`.

### Method
N/A (Function Documentation)

### Endpoint
N/A (Function Documentation)

### Parameters
#### General Parameters
- **dataFrame** (pyEDM: pandas DataFrame | rEDM: data.frame) - None - Input DataFrame.
- **columns** (string or []) - "" - Column name(s) for library.
- **target** (string) - "" - Prediction target column name.
- **libSizes** (string) - "" - CCM library sizes. Can be a list of values or a string of whitespace/comma-separated library sizes. If the string has 3 values, they are interpreted as "start stop increment".
- **sample** (int) - 0 - CCM number of random samples.
- **E** (int) - 0 - Embedding dimension.
- **Tp** (int) - 0 - Prediction Interval.
- **knn** (int) - 0 - Number nearest neighbors (if 0 then set as E+1).
- **tau** (int) - -1 - Embedding time shift (time series rows).
- **exclusionRadius** (int) - 0 - Prediction vector exclusion radius.
- **seed** (unsigned) - 0 - RNG seed, 0 = random seed.
- **embedded** (bool) - False - Is data an embedding? If False, embed to E.
- **includeData** (bool) - False - Include output statistics on all predictions.
- **noTime** (bool) - False - Do not require the first data column to be time or index.
- **verbose** (bool) - False - Echo messages.
- **showPlot** (bool) - False - Plot results (pyEDM, rEDM).
- **returnObject** (bool) - False - If True, returns the CCM class object with all data and variables (Version 2.x).

#### Python Specific Parameters
- **mpMethod** (string) - None - Multiprocessing context start method.
- **sequential** (bool) - False - Disable multiprocessing.

#### R Specific Parameters
- **pathIn** (string) - "./" - Input data file path.
- **dataFile** (string) - "" - Data file name.
- **random** (bool) - True - CCM use random samples? (Version 1.x behavior differs).
- **parameterList** (bool) - False - Include parameter dictionary in return.

### Notes
- Normally, one column and one target are specified. The column time series is time-delay embedded to dimension `E`, then cross mapped with the target time series. In a separate thread, the target time series is embedded to `E` and cross mapped against the column acting as the "target".
- If there are multiple `columns` and `embedded` is false, each column is time-delay embedded to dimension `E` creating an N-columns * E dimensional "mixed" embedding. If `embedded` is true, no time-delay embedding is done, creating a multivariate embedding of the specified columns. The same logic applies if multiple targets are specified for the "reverse" mapping.
- If `embedded` is false for multiple targets, each target is time-delay embedded to dimension `E` creating an N-target * E dimensional "mixed" embedding cross mapped to _only the first column_ as the cross map target. If `embedded` is true, no time-delay embedding is done, creating a multivariate embedding of the specified target(s).
- `libSizes` interpretation: If the string has 3 values, and the third value is less than the second, the three values are interpreted as a sequence generator specifying "start stop increment" row values (e.g., "10 80 10" will evaluate library sizes from 10 to 80 in increments of 10).
- Version 1.x `random` parameter: If `random` is true, sample observations are randomly selected from the subset of each library size. If `random` is false, sample is ignored and contiguous library rows up to the current library size are used (this is not convergent cross mapping).
- If `seed=0`, a random seed is generated for the random number generator. Otherwise, `seed` is used to initialize the random number generator.

### Returns
- **If `includeData` is `False`**: Returns a DataFrame with 3 columns: `LibSize`, Pearson correlation coefficient for `column` : `target`, and Pearson correlation coefficient for `target` : `column`.
- **If `includeData` is `True`**: Returns a list containing the above DataFrame and a DataFrame of all Simplex projection statistics. If `parameterList = True`, a dictionary of `parameters` is also included.
- **Version 2.x**: If `returnObject = True`, returns the CCM class object with all data and variables.

### Request Example (Python Signature)
```python
CCM(dataFrame=None, columns='', target='', libSizes='', sample=0, E=0, Tp=0, knn=0, tau=-1, exclusionRadius=0, seed=0, embedded=False, includeData=False, noTime=False, ignoreNan=True, mpMethod=None, sequential=False, verbose=False, showPlot=False, returnObject=False)
```

### Request Example (R Signature)
```R
CCM(pathIn="./", dataFile="", dataFrame=NULL, E=0, Tp=0, knn=0, tau=-1, exclusionRadius=0, columns="", target="", libSizes="", sample=0, random=TRUE, seed=0, embedded=FALSE, includeData=FALSE, parameterList=FALSE, verbose=FALSE, showPlot=FALSE, noTime=FALSE)
```
```

--------------------------------

### Simplex Prediction with No Library Conditions

Source: https://sugiharalab.github.io/EDM_Documentation/cond_emb_demo

Performs a Simplex prediction using the entire library (time points 1 to 100) without any conditional filtering. This serves as a baseline for comparison with conditional embedding methods.

```python
pred = Simplex( dataFrame = df, lib = "1 100", pred = "101 195", E = 2, Tp = 0, 
                columns = 'x', target = 'y', validLib = [] )
PlotObsPred( pred,  "Normal Lib 1:100", 2, 1 )

```

--------------------------------

### Simplex Prediction with Conditions y < x and Time > 50

Source: https://sugiharalab.github.io/EDM_Documentation/cond_emb_demo

Performs Simplex prediction where the library is constructed only from data points satisfying the conditions `y < x` and `Time > 50`. This showcases conditional embedding based on multiple variable relationships and time.

```python
validLib = df.eval( "y < x & Time > 50" )
pred = Simplex( dataFrame = df, lib = "1 100", pred = "101 195", E = 2, Tp = 1, 
                columns = 'x', target = 'y', validLib = validLib )
PlotObsPred( pred, "CE Partial Lib y < x and Time > 50", 2, 1 )

```

--------------------------------

### PredictInterval Function (R)

Source: https://sugiharalab.github.io/EDM_Documentation/predictInterval_

The R PredictInterval function assesses Simplex prediction skill for forecast intervals. It can read data from a file or use a data frame and offers parameters for specifying library and prediction ranges, embedding dimensions, and output options.

```r
PredictInterval(pathIn="./", dataFile="", dataFrame=NULL,
pathOut="./",  predictFile="", lib="", pred="",
maxTp=10, E=1,  tau=-1, exclusionRadius=0, columns="",
target="", embedded=FALSE, verbose=FALSE,
validLib=vector(), numThreads=4, showPlot=TRUE, noTime=FALSE)
```

--------------------------------

### PredictNonlinear Function Signature (R)

Source: https://sugiharalab.github.io/EDM_Documentation/predictNonlinear_

Defines the signature for the PredictNonlinear function in R. It accepts a data frame and various parameters to configure the prediction, such as input/output paths, target column, embedding parameters, and thread count.

```r
PredictNonlinear(pathIn="./", dataFile="", dataFrame=NULL, 
pathOut="./", predictFile="", lib="", pred="", theta="",
E=1, Tp=1, knn=0, tau=-1, exclusionRadius=0,
columns="", target="", embedded=FALSE, verbose=FALSE,
validLib=vector(), ignoreNan=TRUE, numThreads=4,
showPlot=TRUE, noTime=FALSE)
```

--------------------------------

### PredictInterval Function

Source: https://sugiharalab.github.io/EDM_Documentation/predictInterval_

Evaluates Simplex prediction skill for forecast intervals from 1 to maxTp. This function is available in both Python and R.

```APIDOC
## PredictInterval

### Description
Evaluate Simplex prediction skill for forecast intervals from 1 to maxTp.

### Method
N/A (Function documentation)

### Endpoint
N/A (Function documentation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
**Python:**
```python
PredictInterval(dataFrame=None, columns='', target='', lib='', pred='', maxTp=10, E=1, tau=-1, exclusionRadius=0, embedded=False, validLib=[], noTime=False, ignoreNan=True, verbose=False, numProcess=4, mpMethod=None, chunksize=1, showPlot=True)
```

**R:**
```R
PredictInterval(pathIn="./", dataFile="", dataFrame=NULL, pathOut="./",  predictFile="", lib="", pred="", maxTp=10, E=1,  tau=-1, exclusionRadius=0, columns="", target="", embedded=FALSE, verbose=FALSE, validLib=vector(), numThreads=4, showPlot=TRUE, noTime=FALSE)
```

### Parameters Table
| Parameter | Type | Default | Purpose |
|---|---|---|---|
| dataFrame | pyEDM: pandas DataFrame<br>rEDM: data.frame | None | Input DataFrame |
| columns | string or [] | "" | Column names for library |
| target | string | "" | Prediction target column name |
| lib | string or [] | "" | Pairs of library start stop row indices |
| pred | string or [] | "" | Pairs of prediction start stop row indices |
| maxTp | int | 10 | Evaluate forecast with Tp up to maxTp |
| E | int | 0 | Embedding dimension |
| tau | int | -1 | Embedding shift (time series rows) |
| exclusionRadius | int | 0 | Prediction vector exclusion radius |
| embedded | bool | False | Is data an embedding? |
| validLib | bool [] | [] or None | Conditional embedding |
| noTime | bool | False | Do not require first data column of time or index |
| verbose | bool | False | Echo messages |
| numThreads | int | 4 | Number of threads to use (Version 1.x) / Number of processes (Version 2.x) |
| showPlot | bool | True | Show plot of E vs Rho (pyEDM, rEDM) |
| pathIn | string | "./" | Input data file path |
| dataFile | string | "" | Data file name |
| mpMethod | string | None | multiprocessing context start method |
| chunksize | int | 1 | multiprocessing chunksize |

### Notes
Version 1.x: `numThreads` defines the number of worker threads for the `maxTp` embeddings.
Version 2.x: `numProcess` defines the number of processes for the `maxTp` embeddings.

### Returns
DataFrame with columns `Tp` and `rho`.

### Response Example
**Success Response (200):**
```json
{
  "Tp": [1, 2, 3, ...],
  "rho": [0.9, 0.85, 0.8, ...]
}
```
```
Tokens:
Raw