Many thanks! I see that around line 174, there are some more statements after the return where the variables x are not undefined.

There are also some tiny differences between the v4 and v5 implementations regarding the STFT class.

Fixed the error in L174, the difference in STFT is based on the original implementation parameters, this is not actual STFT to be accurate but I kept the naming convention of the original models

Thanks!

I think there are still some glitches in V4: single_step_forward does not seem to be defined and also self.num_samples

Fixed them, these methods were directly ported from V5, I didn't test them well because they are not used, I only used the forward method

Thanks a lot. I dont think v4 has the context concatenated to input, does it? Is the forward method and how you export the model at the end with input size of (512+64) are still correct?

It does concatenate the context, you can refer to the onnx example on the original repo and in faster-whisper before v5 implementation

I'm really not sure. All I see is that inputs are the chunks and the states are updated through h and c
https://github.com/snakers4/silero-vad/blob/915dd3d639b8333a52e001af095f87c5b7f1e0ac/utils_vad.py#L86

(I'm not talking about the internal concatenation of x_feature and its normalized version btw)

I didn't check the decoder part yet but the VadModel class should be sth like the following:

class VadModel(nn.Module):
    def __init__(self):
        super(VadModel, self).__init__()

        self.encoder = Encoder()
        self.decoder = Decoder()

    def get_initial_states(self, batch_size: int, device: torch.device):
        h = torch.zeros((2, batch_size, 64), dtype=torch.float32, device=device)
        c = torch.zeros((2, batch_size, 64), dtype=torch.float32, device=device)
        return h, c

    def forward(self, x):
        bsz = x.size(0)
        h, c = self.get_initial_states(bsz, device=x.device)

        x = self.encoder(x).reshape(bsz, -1, 64, 2)

        decoder_outputs = []
        for window in x.unbind(1):
            out, h, c = self.decoder(window, h, c)
            decoder_outputs.append(out)

        out = torch.stack(decoder_outputs, dim=1).squeeze(-1)

        return out.mean(dim=-1)

and then the outputs of the encoder can be validated as follows:

    # sample input
    x = torch.randn(1, 512, dtype=torch.float32)

    # validate encoder outputs
    jit_out = model.forward(x)
    x0 = model.feature_extractor(x)
    norm = model.adaptive_normalization(x0)
    x1 = torch.cat([x0, norm], 1)
    x2 = model.first_layer(x1)
    enc = model.encoder(x2)

    vad_enc = new_model.encoder(x)
    assert torch.allclose(enc, vad_enc, atol=1e-5)

I revised the implementation again and fixed your notes, also supported variable num_samples and 8KHz