This repo contains a pytorch implementation of the auto segmentation criterion (ASG), introduced in the paper Wav2Letter: an End-to-End ConvNet-based Speech Recognition System by Facebook.

As mentioned in this blog post by Daniel Galvez, ASG, being an alternative to the connectionist temporal classification (CTC) criterion widely used in deep learning, has the advantage of being a globally normalized model without the conditional independence assumption of CTC and the potential of playing better with WFST frameworks.

Unfortunately, Facebook's implementation in its official wav2letter++ project is based on the ArrayFire C++ framework, which makes experimentation rather difficult. Hence we have ported the ASG implementation in wav2letter++ to pytorch as C++ extensions.

Our implementation should produce the same result as Facebook's, but the implementation is completely different. For example, in their implementation after doing an alpha recursion during the forward pass, they just brute force the back-propagation during the backward pass, whereas we do a proper alpha-beta recursion during the forward pass, and during the backward pass there is no recursion at all. Our implementation has the benefit of much higher parallelism potential. Another difference is that we try to use pytorch's native functions as much as possible, whereas Facebook's implementation is basically a gigantic hand-written C code working on raw arrays.

In the doc folder, you can find the maths derivation of our implementation.

• CPU (openmp) implementation
• GPU (cuda) implementation
• testing
• performance tuning and comparison
• Viterbi decoders
• generalization to better integrate with general WFSTs decoders

Ensure pytorch > 1.01 is installed, clone the project and in terminal do

cd torch_asg
pip install .

Tested with python 3.7.1. You need to have suitable C++ toolchain installed. For GPU, you need to have an nVidia card with compute capability >= 6.

Then in your python code:

import torch
from torch_asg import ASGLoss


def test_run():
    num_labels = 7
    input_batch_len = 6
    num_batches = 2
    target_batch_len = 5
    asg_loss = ASGLoss(num_labels=num_labels,
                       reduction='mean',  # mean (default), sum, none
                       gpu_no_stream_impl=False, # see below for explanation
                       forward_only=False # see below for explanation                      
                       )
    for i in range(1):
        # Note that inputs follows the CTC convention so that the batch dimension is 1 instead of 0,
        # in order to have a more efficient GPU implementation
        inputs = torch.randn(input_batch_len, num_batches, num_labels, requires_grad=True)
        targets = torch.randint(0, num_labels, (num_batches, target_batch_len))
        input_lengths = torch.randint(1, input_batch_len + 1, (num_batches,))
        target_lengths = torch.randint(1, target_batch_len + 1, (num_batches,))
        loss = asg_loss.forward(inputs, targets, input_lengths, target_lengths)
        print('loss', loss)
        # You can get the transition matrix if you need it.
        # transition[i, j] is transition score from label j to label i.
        print('transition matrix', asg_loss.transition)
        loss.backward()
        print('transition matrix grad', asg_loss.transition.grad)
        print('inputs grad', inputs.grad)

test_run()

There are two options for the loss constructor that warrants further explanation:

• gpu_no_stream_impl: by default, if you are using GPU, we are using an implementation that is highly concurrent by doing some rather complicated CUDA streams manipulation. You can turn this concurrent implementation off by setting this parameter to true, and then CUDA kernel launches are serial. Useful for debugging.
• forward_only: by default, our implementation does quite a lot of work during the forward pass concurrently that is only useful for calculating the gradients. If you don't need the gradient, setting this parameter to true will give a further speed boost. Note that the forward-only mode is automatically active when your model is in evaluation mode.

Compared to Facebook's implementation, we have also omitted scaling based on input/output lengths. If you need it, you can do it yourself by using the None reduction and scale the individual scores before summing/averaging.