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