Metadata-Version: 2.4
Name: asim
Version: 26.2.5
Summary: Automatic simulation system powered by neural networks
Keywords: simulation
Requires-Python: >=3.12
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: torch>=2.8.0
Requires-Dist: lightning>=2.5.5
Requires-Dist: casadi>=3.7.2
Provides-Extra: dev
Requires-Dist: matplotlib; extra == "dev"
Dynamic: license-file

# Automatic simulation system powered by neural networks

## Installation

```bash
pip install asim
```

## What is asim

- Physical field modeling with automatic constraint enforcement
- Flexible data grouping and normalization
- Built-in support for recurrent architectures
- Export/import of trained models

## Using asim

```python
import matplotlib.pyplot as plt
import pandas as pd
from asim import Vt, Vu, Vx
from asim.dataset import PhysicalDataManage
from asim.explainer import Explainer
from asim.model import PhysicalFieldModel
from asim.optimizer import OffPolicyOptimizer
from asim.simulator import PhysicalSimulator
from asim.tool import DummyDatasets

# 1. Define data and structure
df = DummyDatasets.boiler_minimum(size=10000)  # pd.read_csv("demo.csv")
cols = [
    Vt(label="ts"),
    Vu(group="boiler", label="heat_power1", minmax=(1.0, None), union="kw", enable=True),
    Vu(group="boiler", label="heat_power2", minmax=(None, 90), union="kw", enable=True),
    Vx(group="boiler", label="heat_temp", minmax=(0.0, None), union="kj", enable=True),
]
dm = PhysicalDataManage(df, columns=cols, batch_size=64, seq_size=5)

# 2A. Select the model, define the parameters, train and save
fm = PhysicalFieldModel(dm, lr=0.001)
fm.fit(epochs=200)
fm.export("demo.sim.onnx")

# 2B. Check model
explainer = Explainer(fm, dm)
explainer.checkGrad()

# 2C. Use a simulator to simulate the operation
sim = PhysicalSimulator("demo.sim.onnx", dm=dm)
sim_df = df[0:1440].copy()
sim_df.index = pd.to_datetime(sim_df["ts"], unit="s", utc=True).dt.tz_convert("Etc/GMT-8")
sim_df = sim.steps(sim_df, x0={"heat_temp": sim_df["heat_temp"].iloc[0]})
sim.plots(sim_df)
plt.show()

# 3A. Build the optimizer
lTerm = lambda x, u, p: (x - p) ** 2 + 0.5 * (u[0] ** 2 + u[1] ** 2)
mTerm = lambda x, u, p: (x - p) ** 2
opt = OffPolicyOptimizer("demo.sim.onnx", dm=dm, lTerm=lTerm, mTerm=mTerm)
opt.fit(epochs=100)
opt.export("demo.opt.onnx")

# 3B. Use the optimizer
opt_df = opt.steps(df[0:360].copy(), interval=5)
opt.plots(opt_df)
plt.show()
```
