Hi Subhra, thanks for clarifying. Testing the model locally or in Colab before opening a new PR is the right workflow.

I checked the latest main and also tested the ELM implementation from your previous branch. After registering it correctly, a forward/backward check and a one-epoch CPU train_pa -> train_dpd -> run_dpd smoke run completed successfully. One epoch verifies integration only; it does not establish model quality.

1. Start from the latest `main` and install from source

Please develop on a feature branch in your fork, rather than directly on main:

git clone https://github.com/girisubhra/OpenDPD.git
cd OpenDPD
git remote add upstream https://github.com/lab-emi/OpenDPD.git
git fetch upstream
git switch -c feature/elm upstream/main

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip

# CPU example; install the appropriate PyTorch build instead if using CUDA.
python -m pip install torch --index-url https://download.pytorch.org/whl/cpu
python -m pip install -e ".[dev]"

The editable install is important: pip install opendpd installs the released version and will not contain your new source file.

2. Add and register the backbone

Add backbones/elm.py, including your author, affiliation, license, and optional contact information.

The backbone contract is:

subclass torch.nn.Module;
accept I/Q input x shaped (batch, time, 2);
implement forward(self, x, h_0=None) because CoreModel always passes h_0 (a non-recurrent model may ignore it);
return a finite tensor shaped (batch, time, 2) on the same device/dtype;
retain a differentiable path to at least one trainable parameter for the existing optimizer.

Then register it in models.py before the final else:

elif backbone_type == "elm":
    from backbones.elm import ELM
    self.backbone = ELM(
        input_size=self.input_size,
        hidden_size=self.hidden_size,
        output_size=self.output_size,
        num_layers=self.num_layers,
    )

Add "elm" to the --DPD_backbone choices in arguments.py. Add it to --PA_backbone only if it is also intended and validated as a PA behavioral model.

No packaging change is needed; backbones.* is already included. If the model introduces new hyperparameters, add their CLI arguments and pass them through every relevant model-construction path.

3. Add tests

Add "elm" to IMPLEMENTED_BACKBONES in tests/test_backbones.py and "backbones.elm" to CORE_MODULES in tests/test_imports.py. A targeted test should also confirm output shape/finiteness and that backward propagation produces a gradient for the trainable output weights.

python -m pytest tests/test_imports.py tests/test_backbones.py tests/test_cli.py -q
python -m pytest tests/ -m "not extended" -q

4. Run a short local end-to-end check

DPA_200MHz is included in the repository, so no dataset download is required. Run these commands from the repository root and keep the identifying settings consistent between stages because checkpoint paths are derived from them.

python main.py --dataset_name DPA_200MHz --step train_pa \
  --accelerator cpu --seed 0 --n_epochs 1 \
  --frame_length 50 --frame_stride 16 \
  --batch_size 64 --batch_size_eval 256 \
  --PA_backbone gru --PA_hidden_size 8 --PA_num_layers 1

python main.py --dataset_name DPA_200MHz --step train_dpd \
  --accelerator cpu --seed 0 --n_epochs 1 \
  --frame_length 50 --frame_stride 16 \
  --batch_size 64 --batch_size_eval 256 \
  --PA_backbone gru --PA_hidden_size 8 --PA_num_layers 1 \
  --DPD_backbone elm --DPD_hidden_size 8 --DPD_num_layers 1

python main.py --dataset_name DPA_200MHz --step run_dpd \
  --accelerator cpu --seed 0 --frame_length 50 \
  --PA_backbone gru --PA_hidden_size 8 --PA_num_layers 1 \
  --DPD_backbone elm --DPD_hidden_size 8 --DPD_num_layers 1

Checkpoints and results will appear under save/DPA_200MHz/, log/DPA_200MHz/, and dpd_out/. For a real evaluation, increase the epoch count, tune the model, and compare NMSE/ACLR/EVM over multiple seeds.

5. Run the same branch in Colab

First push feature/elm to your fork. In a Colab notebook:

!git clone --branch feature/elm https://github.com/girisubhra/OpenDPD.git
%cd OpenDPD
!python -m pip install -e ".[dev]"

import torch
accelerator = "cuda" if torch.cuda.is_available() else "cpu"
print("Using:", accelerator)

Then run the same three commands above in notebook cells with !python main.py ... and --accelerator {accelerator}. Select a GPU runtime before running the installation cell if you want CUDA. Colab storage is temporary, so copy save/, log/, and dpd_out/ to Google Drive if you need to retain them.

ELM-specific note

Your earlier implementation is compatible with OpenDPD's current optimizer because its output weights are trained by gradient descent. A classical ELM normally solves those weights analytically (for example by least squares/pseudoinverse); supporting that would require a custom fitting path in addition to forward(). The current implementation also processes each time sample independently, so it is memoryless and does not use num_layers; please document that choice or add temporal context if the target PA has memory.

Uh oh!

How to add a new model #18

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions