SysIdentPy

https://github.com/wilsonrljr/sysidentpy
Admin
A Python package for system identification using NARMAX models with support for classical approaches...
Tokens:246,382
Snippets:2,354
Trust Score:8.9
License:BSD-3-Clause
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install from Git

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/getting-started/getting-started.md

Installs the latest version directly from the Git repository.

```bash
pip install git+https://github.com/wilsonrljr/sysidentpy.git
```

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

### Install Specific Version

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/getting-started/getting-started.md

Installs a specific version of SysIdentPy (e.g., 0.5.3).

```bash
pip install sysidentpy=="0.5.3"
```

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

### Install with Neural NARX Support

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/getting-started/getting-started.md

Installs SysIdentPy with all optional dependencies, including those for Neural NARX models.

```bash
pip install sysidentpy["all"]
```

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

### Installation

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/getting-started/quickstart-guide.md

Installs sysidentpy and pandas, with an optional installation for all features including neural networks.

```bash
pip install sysidentpy pandas
# Optional: For neural networks and advanced features
pip install sysidentpy["all"]
```

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

### Install Docs Extras

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Command to install the necessary extras for working with the documentation.

```bash
pip install -e ".[docs"]
```

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

### Install SysIdentPy

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/README.md

The recommended way to install SysIdentPy is using pip.

```console
pip install sysidentpy
```

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

### sktime models - Setup

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/10-Case-Studies.md

Initial setup for using sktime models, including loading data, splitting it into training and testing sets, and plotting the series.

```python
y = load_airline()
y_train, y_test = temporal_train_test_split(y, test_size=23) 
# 23 samples for testing
plot_series(y_train, y_test, labels=["y_train", "y_test"])
fh = ForecastingHorizon(y_test.index, is_relative=False)
```

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

### Full Code Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/getting-started/quickstart-guide.md

A comprehensive code example demonstrating the entire process from data generation to residual analysis.

```python
import pandas as pd

from sysidentpy.utils.generate_data import get_siso_data
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.metrics import root_relative_squared_error
from sysidentpy.utils.display_results import results
from sysidentpy.utils.plotting import plot_results
from sysidentpy.utils.plotting import plot_residues_correlation
from sysidentpy.residues.residues_correlation import (
    compute_residues_autocorrelation,
    compute_cross_correlation,
)

```

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

### Install Packages

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/tutorials/m4-benchmark.md

Command to install all the required packages using pip after creating a requirements.txt file.

```bash
pip install -r requirements.txt
```

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

### Run Local Server

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Command to start the local MkDocs development server.

```bash
mkdocs serve
```

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

### Install Required Packages

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/tutorials/coupled-eletric-device.md

This snippet shows how to create a requirements.txt file and install the necessary packages for the case study.

```text
sysidentpy==0.4.0
pandas==2.2.2
numpy==1.26.0
matplotlib==3.8.4
nonlinear_benchmarks==0.1.2
```

```bash
pip install -r requirements.txt
```

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

### Complete example of parameter estimation using Extended Least Squares (ELS)

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/how-to/use-extended-least-squares.md

A simple yet complete code example demonstrating parameter estimation using the Extended Least Squares (ELS) algorithm. Simulated data is used for illustrative purposes.

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.stats import gaussian_kde

from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares
from sysidentpy.utils.generate_data import get_siso_data

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=True, sigma=0.2, train_percentage=90
)

basis_function = Polynomial(degree=2)
estimator = LeastSquares(unbiased=True)
parameters = np.zeros([3, 50])

for i in range(50):
    x_train, x_valid, y_train, y_valid = get_siso_data(
        n=3000, colored_noise=True, train_percentage=90
    )

    model = FROLS(
        order_selection=False,
        n_terms=3,
        ylag=2,
        xlag=2,
        elag=2,
        info_criteria="aic",
        estimator=estimator,
        basis_function=basis_function,
    )

    model.fit(X=x_train, y=y_train)
    parameters[:, i] = model.theta.flatten()

plt.figure(figsize=(14, 4))

# Compute and plot KDE for each parameter using scipy's gaussian_kde
x_grid = np.linspace(np.min(parameters), np.max(parameters), 1000)

for i, label in enumerate(["Parameter 1", "Parameter 2", "Parameter 3"]):
    kde = gaussian_kde(parameters[i, :])
    plt.plot(x_grid, kde(x_grid), label=label)

# Plot vertical lines where the real values must lie
plt.axvline(x=0.1, color="k", linestyle="--", label="Real Value 0.1")
plt.axvline(x=0.2, color="k", linestyle="--", label="Real Value 0.2")
plt.axvline(x=0.9, color="k", linestyle="--", label="Real Value 0.9")

plt.xlabel("Parameter Value")
plt.ylabel("Density")
plt.title("Kernel Density Estimate of Parameters (Matplotlib only)")
plt.legend()
plt.show()
```

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

### Requirements

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/how-to/create-custom-basis-function.md

Lists the required packages for the project and provides a command to install them.

```bash
sysidentpy
numpy
matplotlib
```

```bash
pip install -r requirements.txt
```

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

### Case Study Setup

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/4-Model-Structure-Selection.md

Imports necessary libraries and loads dataset for a case study on DC motor modeling.

```python
import numpy as np
import pandas as pd
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares
from sysidentpy.utils.display_results import results
from sysidentpy.utils.plotting import plot_results

df1 = pd.read_csv("examples/datasets/x_cc.csv")
df2 = pd.read_csv("examples/datasets/y_cc.csv")
```

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

### Initial Setup and Imports

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/tutorials/load-forecasting-benchmark.md

Imports necessary libraries for SysIdentPy, plotting, data handling, and NeuralProphet, and sets up plotting and error handling.

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

from sysidentpy.model_structure_selection import FROLS, AOLS, MetaMSS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares
from sysidentpy.utils.plotting import plot_results
from sysidentpy.metrics import mean_squared_error

from sktime.datasets import load_airline
from neuralprophet import NeuralProphet
from neuralprophet import set_random_seed

simplefilter("ignore", FutureWarning)
np.seterr(all="ignore")

%matplotlib inline

loss = mean_squared_error
```

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

### Get SysIdentPy version

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/examples/array-api-benchmark.ipynb

This code snippet retrieves and displays the installed version of the sysidentpy library.

```python
import sysidentpy

sysidentpy.__version__
```

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

### Polynomial NAR Model Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/2-NARMAX-Model-Representation.md

This code snippet illustrates the setup for a polynomial NAR model, specifying model_type as "NAR" and unbiased=False in the LeastSquares estimator.

```python
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares

basis_function = Polynomial(degree=2)
model = FROLS(
	basis_function=basis_function,
	estimator=LeastSquares(unbiased=False),
	model_type="NAR"
)
```

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

### Setup

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/how-to/array-api-benchmark.md

Imports necessary libraries for data generation, model configuration, benchmarking, and visualization.

```python
import time
import warnings
from collections import defaultdict

import numpy as np
import matplotlib.pyplot as plt

from sysidentpy import config_context
from sysidentpy.model_structure_selection import FROLS, AOLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares, RidgeRegression
from sysidentpy.metrics import root_relative_squared_error
from sysidentpy.utils.generate_data import get_siso_data, get_miso_data

warnings.filterwarnings("ignore")
```

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

### Predicting with initial conditions

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/tutorials/your-first-model.md

This example demonstrates how to use the predict method with only the necessary initial conditions for prediction, and calculates the Root Relative Squared Error (RRSE).

```python
yhat = model.predict(
    X=x_valid, y=y_valid[: model.max_lag] 
)  # passing only the 2 initial values which will be used as initial conditions
rrse = root_relative_squared_error(y_valid, yhat)
print(rrse)
```

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

### 1-step ahead prediction example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/9-Validation.md

Illustrative example of 1-step ahead prediction calculation.

```python
y_initial = yhat(0) = 8
yhat(1) = 1*8 + 2*1 = 10
yhat(2) = 1*9 + 2*2 = 13
yhat(3) = 1*10 + 2*3 = 16
yhat(4) = 1*11 + 2*4 = 19
and so on
```

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

### Translator Note Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Example of how to add a translator note using an HTML comment.

```markdown
<!-- Translator note: keep the term "NARMAX" in English. -->
```

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

### Bayesian NARX Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/overrides/home.html

Example of using the NARX estimator with a BayesianRidge base estimator for system identification.

```python
from sysidentpy.utils.generate_data import get_siso_data
from sysidentpy.general_estimators import NARX
from sklearn.linear_model import BayesianRidge
from sysidentpy.basis_function import Polynomial

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=False, sigma=0.0001, train_percentage=90
)

BayesianRidge_narx = NARX(
    base_estimator=BayesianRidge(),
    xlag=2,
    ylag=2,
    basis_function=Polynomial(degree=2),
    model_type="NARMAX",
)

BayesianRidge_narx.fit(X=x_train, y=y_train)
yhat = BayesianRidge_narx.predict(X=x_valid, y=y_valid)
```

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

### Static System Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/1-Introduction.md

Demonstrates a static system where the output `y` directly follows the input `u`. The input `u` is a square wave representing a binary switch, and the output `y` is set equal to `u`.

```python
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal

t = np.linspace(0, 30, 500, endpoint=False)
u = signal.square(0.2*np.pi * t)
u[u < 0] = 0
# In a static system, the output y directly follows the input u
y = u

```

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

### Serve documentation locally

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/CONTRIBUTING.md

Command to serve the MkDocs documentation locally for development, showing an example console output with a browser connection message.

```console
$ mkdocs serve

INFO     -  [13:25:00] Browser connected: http://127.0.0.1:8000
```

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

### Fourier NARX Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/overrides/home.html

Example of using the FROLS estimator with a Fourier basis function for system identification.

```python
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Fourier
from sysidentpy.utils.generate_data import get_siso_data

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=False, sigma=0.0001, train_percentage=90
)

basis_function = Fourier(degree=2)
model = FROLS(ylag=2, xlag=2, basis_function=basis_function)

model.fit(X=x_train, y=y_train)
yhat = model.predict(X=x_valid, y=y_valid)
```

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

### Legendre NARX Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/overrides/home.html

Example of using the FROLS estimator with a Legendre basis function for system identification.

```python
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Legendre
from sysidentpy.utils.generate_data import get_siso_data

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=False, sigma=0.0001, train_percentage=90
)

basis_function = Legendre(degree=2)
model = FROLS(ylag=2, xlag=2, basis_function=basis_function)

model.fit(X=x_train, y=y_train)
yhat = model.predict(X=x_valid, y=y_valid)
```

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

### Polynomial NARX Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/overrides/home.html

Example of using the FROLS estimator with a Polynomial basis function for system identification.

```python
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.basis_function import Polynomial
from sysidentpy.utils.generate_data import get_siso_data

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=False, sigma=0.0001, train_percentage=90
)

basis_function = Polynomial(degree=2)
model = FROLS(ylag=2, xlag=2, basis_function=basis_function)

model.fit(X=x_train, y=y_train)
yhat = model.predict(X=x_valid, y=y_valid)
```

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

### n-steps ahead prediction example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/9-Validation.md

Illustrative example of n-steps ahead prediction calculation with steps_ahead=2.

```python
y_initial = yhat(0) = 8
yhat(1) = 1*8 + 2*1 = 10
yhat(2) = 1*10 + 2*2 = 14
yhat(3) = 1*10 + 2*3 = 16
yhat(4) = 1*16 + 2*4 = 24
and so on
```

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

### MISO benchmark setup

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/examples/array-api-benchmark.ipynb

Sets up and runs the benchmark for MISO data with different backends and configurations.

```python
x_train_np.shape
```

```python
MISO_SIZES = [5_000, 10_000, 25_000]

miso_frols_kwargs = dict(
    ylag=10,
    xlag=[10, 10],
    order_selection=True,
    n_info_values=10,
    basis_function=Polynomial(degree=4),
    estimator=LeastSquares(),
)

miso_results = defaultdict(dict)

for n in MISO_SIZES:
    print(f"\n--- MISO n = {n:,} ---")
    x_train_np, x_valid_np, y_train_np, y_valid_np = get_miso_data(
        n=n, colored_noise=False, sigma=0.001, train_percentage=80
    )

    # No dispatch
    t = benchmark_fit(
        FROLS, miso_frols_kwargs, x_train_np, y_train_np, "NumPy", n_runs=N_RUNS
    )
    miso_results["NumPy (no dispatch)"][n] = t
    print(f"  NumPy (no dispatch): {t:.4f}s")

    # With dispatch
    t = benchmark_fit(
        FROLS,
        miso_frols_kwargs,
        x_train_np,
        y_train_np,
        "NumPy",
        n_runs=N_RUNS,
        dispatch=True,
    )
    miso_results["NumPy (with dispatch)"][n] = t
    print(f"  NumPy (with dispatch): {t:.4f}s")

    # PyTorch CPU
    if "PyTorch CPU" in BACKENDS:
        xt, _, yt, _ = to_backend(
            x_train_np, x_valid_np, y_train_np, y_valid_np, "PyTorch CPU"
        )
        t = benchmark_fit(
            FROLS, miso_frols_kwargs, xt, yt, "PyTorch CPU", n_runs=N_RUNS
        )
        miso_results["PyTorch CPU"][n] = t
        print(f"  PyTorch CPU:          {t:.4f}s")

    # PyTorch CUDA
    if "PyTorch CUDA" in BACKENDS:
        free_gpu_memory()
        xt, _, yt, _ = to_backend(
            x_train_np, x_valid_np, y_train_np, y_valid_np, "PyTorch CUDA"
        )
        warmup = FROLS(**miso_frols_kwargs)
        with config_context(array_api_dispatch=True):
            warmup.fit(X=xt, y=yt)
        torch.cuda.synchronize()

        t = benchmark_fit(
            FROLS, miso_frols_kwargs, xt, yt, "PyTorch CUDA", n_runs=N_RUNS
        )
        miso_results["PyTorch CUDA"][n] = t
        print(f"  PyTorch CUDA:         {t:.4f}s")
        del xt, yt, warmup
        free_gpu_memory()
```

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

### Folder Layout Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Illustrates the expected folder structure for translated documentation, mirroring the English structure.

```markdown
/docs
  en/
    developer-guide/
    getting-started/
    user-guide/
  <locale>/
    (mirrors the structure you translate)
```

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

### Example test results

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/contribute.md

Example output from running pytest, showing the test session details and results.

```console
========== test session starts ==========

platform linux -- Python 3.7.6, pytest-5.4.2, py-1.8.1, pluggy-0.13.1

rootdir: ~/sysidentpy

plugins: cov-2.8.1

collected 12 items

tests/test_regression.py ............ [100%]

========== 12 passed in 2.45s ==================
```

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

### Data Generation Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/README.md

Example of generating a dataset for a simulated dynamical system using SysIdentPy.

```python
from torch import nn
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sysidentpy.metrics import root_relative_squared_error
from sysidentpy.utils.generate_data import get_siso_data


# Generate a dataset of a simulated dynamical system
x_train, x_valid, y_train, y_valid = get_siso_data(
  n=1000,
  colored_noise=False,
  sigma=0.001,
  train_percentage=80
)
```

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

### Building Linear Mapping for Multiobjective Estimation

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/5-Multiobjective-Parameter-Estimation.md

Example showing how to build the linear mapping (R and qit matrices) for multiobjective parameter estimation.

```python
R, qit = mo_estimator.build_linear_mapping()
print("R matrix:")
print(R)
print("qit matrix:")
print(qit)
```

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

### Install development and documentation dependencies

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/CONTRIBUTING.md

Command to install SysIdentPy with development and documentation dependencies using pip.

```sh
pip install "sysidentpy[dev, docs]"
```

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

### Data Loading and Preparation Snippet

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/examples/PV-forecasting-benchmark.ipynb

This snippet shows the initial data loading and preparation steps, including creating a time series DataFrame and splitting it into training and validation sets. It's a common setup for time series forecasting tasks.

```python
set_random_seed(42)
raw = pd.read_csv(
    "https://raw.githubusercontent.com/wilsonrljr/sysidentpy-data/refs/heads/main/datasets/san_francisco_pv_ghi/SanFrancisco_PV_GHI.csv"
)
df = pd.DataFrame()
df["ds"] = pd.date_range("1/1/2015 1:00:00", freq=str(60) + "Min", periods=8760)
df["y"] = raw.iloc[:, 0].values

df_train, df_val = df.iloc[:7008, :], df.iloc[7008:, :]

y = df["y"].values.reshape(-1, 1)
y_train = df_train["y"].values.reshape(-1, 1)
y_test = df_val["y"].values.reshape(-1, 1)

x_train = df_train["ds"].dt.hour.values.reshape(-1, 1)
x_test = df_val["ds"].dt.hour.values.reshape(-1, 1)


```

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

### AOLS Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/10-Case-Studies.md

Example of using the AOLS model for system identification with polynomial basis functions.

```python
set_random_seed(42)
files = ["\SanFrancisco_PV_GHI.csv", "\SanFrancisco_Hospital.csv"]
raw = pd.read_csv(data_location + files[0])
df = pd.DataFrame()
df["ds"] = pd.date_range("1/1/2015 1:00:00", freq=str(60) + "Min", periods=8760)
df["y"] = raw.iloc[:, 0].values
df_train, df_val = df.iloc[:7008, :], df.iloc[7008:, :]
y = df["y"].values.reshape(-1, 1)
y_train = df_train["y"].values.reshape(-1, 1)
y_test = df_val["y"].values.reshape(-1, 1)
x_train = df_train["ds"].dt.hour.values.reshape(-1, 1)
x_test = df_val["ds"].dt.hour.values.reshape(-1, 1)

basis_function = Polynomial(degree=1)
sysidentpy_AOLS = AOLS(
    ylag=24, xlag=24, k=2, L=1, model_type="NARMAX", basis_function=basis_function
)

sysidentpy_AOLS.fit(X=x_train, y=y_train)
x_test = np.concatenate([x_train[-sysidentpy_AOLS.max_lag :], x_test])
y_test = np.concatenate([y_train[-sysidentpy_AOLS.max_lag :], y_test])
yhat = sysidentpy_AOLS.predict(X=x_test, y=y_test, steps_ahead=1)
aols_loss = loss(
    pd.Series(y_test.flatten()[sysidentpy_AOLS.max_lag :]),
    pd.Series(yhat.flatten()[sysidentpy_AOLS.max_lag :]),
)
print(aols_loss)
plot_results(y=y_test[-104:], yhat=yhat[-104:])
```

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

### Relative Path Matching Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Demonstrates how relative paths for translated files should match the English source path.

```markdown
English: docs/en/developer-guide/how-to-add-a-translation.md
Spanish: docs/es/developer-guide/how-to-add-a-translation.md
French:  docs/fr/developer-guide/how-to-add-a-translation.md
```

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

### Neural NARX Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/overrides/home.html

Example of using the NARXNN estimator with a custom PyTorch neural network for dynamic modeling.

```python
from torch import nn
from sysidentpy.neural_network import NARXNN

from sysidentpy.basis_function import Polynomial
from sysidentpy.utils.generate_data import get_siso_data

x_train, x_valid, y_train, y_valid = get_siso_data(
    n=1000, colored_noise=False, sigma=0.01, train_percentage=80
)

class NARX(nn.Module):
    def __init__(self):
        super().__init__()
        self.lin = nn.Linear(4, 30)
        self.lin2 = nn.Linear(30, 1)
        self.tanh = nn.Tanh()

    def forward(self, xb):
        z = self.lin(xb)
        z = self.tanh(z)
        z = self.lin2(z)
        return z


narx_net2 = NARXNN(
    net=NARX(),
    ylag=2,
    xlag=2,
    basis_function=Polynomial(degree=1),
    optimizer="Adam",
    optim_params={
        "betas": (0.9, 0.999),
        "eps": 1e-05,
    },
)

narx_net2.fit(X=x_train, y=y_train)
yhat = narx_net2.predict(X=x_valid, y=y_valid)
```

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

### Import necessary libraries

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/user-guide/tutorials/multiobjective-parameter-estimation-overview.md

Imports essential libraries for system identification, parameter estimation, and plotting.

```python
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sysidentpy.model_structure_selection import FROLS
from sysidentpy.multiobjective_parameter_estimation import AILS
from sysidentpy.basis_function import Polynomial
from sysidentpy.parameter_estimation import LeastSquares
from sysidentpy.utils.display_results import results
from sysidentpy.utils.plotting import plot_plotting
from sysidentpy.metrics import root_relative_squared_error
from sysidentpy.utils.narmax_tools import set_weights
```

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

### Internal Link Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/developer-guide/how-to-add-a-translation.md

Example of a relative internal link that the i18n plugin will rewrite for different languages.

```markdown
See the [Contribute guide](contribute.md).
```

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

### Fundamental Basis Example

Source: https://github.com/wilsonrljr/sysidentpy/blob/main/docs/en/book/4-Model-Structure-Selection.md

An example demonstrating the use of the fundamental basis with a simple numpy array for the output 'y'.

```python
import numpy as np

y = np.array([3, 7, 8])

```
Tokens:
Raw