A Hands-on Demo on Autoencoders

TOGETHER WITH ASSEMBLYAI

​AssemblyAI Universal-2: Speech Recognition at Superhuman Accuracy​

It’s crazy hard to train reliable transcription models on speech/audio data since so many nuances go into the data, like accents, pauses, small utterances, murmurs, you name it.

​AssemblyAI​ first trained Universal-1 on 12.5 million hours of audio, outperforming every other model in the industry (from Google, OpenAI, etc.) across 15+ languages.

Now, they released ​Universal-2​, their most advanced speech-to-text model yet.

Here’s how ​Universal-2​ compares with Universal-1:

• 24% improvement in proper nouns recognition
• 21% improvement in alphanumeric accuracy
• 15% better text formatting

​Build flawless transcription apps with Universal-2 →

TODAY’S DAILY DOSE OF DATA SCIENCE

[Hands-on] Training Autoencoders

One can do so many things with Autoencoders:

• Dimensionality reduction.
• Anomaly detection where if reconstruction error is high, something’s fishy!
• Detect multivariate covariate shift, which we discussed ​here​.
• Data denoising (clean noisy data by training on noise).

They are simple yet so powerful!

At their core, Autoencoders have two main parts:

1. Encoder: Compresses the input into a dense representation (latent space).
2. Decoder: Reconstructs the input from this dense representation.

And the idea is to make the reconstructed output as close to the original input as possible:

On a side note, here's how the denoising autoencoder works:

• During training, add random noise to the original input, and train an autoencoder to predict the original input.

• During inference, provide a noisy input and the network will reconstruct it.

Coming back to the topic...

Below, let's quickly implement an autoencoder:

We'll use ​PyTorch Lightning​ for this.

First, we define our autoencoder!

Next, we define our dataset (MNIST):

Finally, we train the model in two lines of code with ​PyTorch Lightning​:

The Lightning Trainer automates 40+ training optimization techniques including:

• Epoch and batch iteration
• optimizer.step(), loss.backward() etc.
• Calling model.eval()
• enabling/disabling grads during evaluation
• Checkpoint saving and loading
• Multi-GPU
• 16-bit precision.

Since the model has been trained, we can visualize the performance.

Let's encode/decode an image using our trained model below:

Done!

And that's how you train an autoencoder.

As mentioned earlier, autoencoders are incredibly helpful in detecting multivariate covariate shifts.

This is important to address since almost all real-world ML models gradually degrade in performance due to covariate shift.

It is a serious problem because we trained the model on one distribution, but it is being used to predict on another distribution in production.

Autoencoders help in addressing this, and we discussed it ​here​.

👉 Over to you: What are some other use cases of Autoencoder?

IN CASE YOU MISSED IT

Build a Multi-agent Research Assistant With SwarmZero​

After using OpenAI’s Swarm, we realized several limitations.

One major shortcoming is that it isn’t suited for production use cases since the project is only meant for experimental purposes.

​​SwarmZero​​ solves this.

We recently shared a practical and hands-on demo of this.

We’ll build a PerplexityAI-like research assistant app that:

• Accepts a user query.
• Searches the web about it.
• And turns it into a well-crafted article, which can saved as a PDF, in a Google Doc, confluence page, and more.

​Learn how to build multi-agent applications with SwarmZero →