Question about excluding Module members from auto generated Record

[med1844]

I have a use case where I need to mark certain Module members as "constants" that shouldn't be included in the corresponding Record. In my case, such members are a custom struct containing multiple constant tensors.

Currently, I see that:

1. We have Param<Tensor<B, D>> to explicitly mark tensors as parameters
2. But there doesn't seem to be a way to do the reverse - marking members to be excluded from Record

Questions:

1. Is there an existing way to exclude Module members from Record?
2. If not, does this mean we need to manually define the Record and implement load_record/into_record?

Alternative Design Suggestion

It might be more intuitive if:

• Tensor<B, D> was treated as a parameter by default
• We had something like Const<T> to mark any type T as "constant that can be recreated when instantiating a module"
  • This would work for both tensors and custom modules

Would love to hear if there are existing solutions I missed, or any guidance on implementing this functionality.

[laggui]

I think Ignored<T> should do the trick here. Also seems very similar in spirit to your suggested Const<T>.

[med1844]

One question, I tried to use it, but rustc complains:

21 |     spec_transform: Ignored<LogMelSpectrogram<B>>,
   |     ^^^^^^^^^^^^^^ expected associated type, found type parameter `B`
   |
   = note: expected struct `Ignored<LogMelSpectrogram<<B as AutodiffBackend>::InnerBackend>>`
              found struct `Ignored<LogMelSpectrogram<B>>`

However, if the type passed into Ignored has no generic parameter B, then it works. No idea why this happens.

[laggui]

Ahhh it seems that the proc macro breaks when using Ignored for modules.

Let's take a simple example:

#[derive(Module, Debug)]
struct InnerModule<B: Backend> {
    lin: Tensor<B, 2>,
}

#[derive(Module, Debug)]
struct MyModel<B: Backend> {
    linear: Linear<B>,
    ign: Ignored<InnerModule<B>>,
}

It breaks within generated AutodiffModule implementation :

impl<B: Backend> burn::module::AutodiffModule<B> for MyModel<B>
where
    B: burn::tensor::backend::AutodiffBackend,
    <B as burn::tensor::backend::AutodiffBackend>::InnerBackend: Backend,
{
    type InnerModule = MyModel<B::InnerBackend>;
    fn valid(&self) -> Self::InnerModule {
        let linear = burn::module::AutodiffModule::<B>::valid(&self.linear);
        let ign = burn::module::AutodiffModule::<B>::valid(&self.ign);
        Self::InnerModule { linear, ign }
    }
}

The valid(&self.linear) returns Linear<<B as AutodiffBackend>::InnerBackend> (as expected), but the valid(...) implementation for Ignored doesn't seem to handle modules with backend generics.

[med1844]

Oh ok! Should we file an issue for this then? Or this is the expected behavior?

[laggui]

I think the initial addition for Ignored<T> didn't take this into account, so you could file an issue to expand the support :)