I am working on a project which requires action recognition in videos, specifically short ~10 second YouTube clips. Ideally I want to start with a pre-trained network which can be fine-tuned so as to avoid training cost.

AFAIK the SOTA is widely accepted as DeepMind’s I3D, for which pre-trained checkpoint models exist. Are there any interesting papers which challenge this approach, specifically those which can also use a pre-training approach?

Hi! First author here –

In this paper we tackle the problem of audio and speech denoising. Given an audio stream of noisy speech, which is a mixture of speech and noisy background, we would like to filter out the speech signal. While most of the methods utilize supervised deep learning, we decided to use only the noisy sample without any learned model or additional dataset, presenting fully unsupervised method.

To accomplish that, we train an autoencoder to fit the noisy signal from random noise input.

We observed that modeling noise in the signal is harder than the “clean” part in the signal. During the fitting process we observe fluctuations in different stages of the train.

Utilizing that, we calculate the amount of difference between different network outputs in the time-frequency domain we create a robust spectral mask used for denoising the noisy output.

We tested this algorithm on other audio domains rather than only speech, and it shows the same effect: denoising or filtering the main data in a signal using only the noisy signal itself.

You can listen to samples and a comparison with traditional unsupervised methods can be found here

Check out our paper for the full details. In addition, our PyTorch code is available on Github.

Feel free to ask any questions.

Lc0 Wins Computer Chess Championship, Makes History

The machine-learning chess engine Lc0 won the Chess.com Computer Chess Championship last weekend, making history as the first neural-network project to take the title. Lc0, which taught itself how to play chess, is now at the game’s pinnacle as the champion computer engine.

More details:

https://www.chess.com/news/view/lc0-wins-computer-chess-championship-makes-history

Helloooooo, First time poster. I just finished programming my first decision tree model on the Titanic data set starting to learn about the random forest on, supper excited to keep learning more !!

My question is what is the proformance losses or gains on having 2 1070s in nvlink or sli vs a 1080ti
For training machine learning models. I’ve read that GPU v-ram can be a limitation the 1080ti would have 11-12 gb of v-ram and the 2 1070s would have 8+8 = 16. Does the math work out like that ?

Also is it even worth it to have a desktop for machine learning projects ? Is AWS and other services like that that much better what do you think ?

Hi, I’m Myeongjun Kim. I am a graduate student in computer vision research. I realized the importance of paper implementation. So I implemented this paper. I wrote the code with my friend Taehun Kim, I used pytorch, and Taehun Kim wrote the code with tensorflow. Others were experimenting with ImageNet datasets. Therefore, the experiment was carried out using CIFAR datasets. There is no experiment on CIFAR datasets in the paper, but we implemented the network by putting hyper-parameters similar to the paper. There are a lot of deficiencies in the paper implementation for the first time. we are little nervous because it’s the first time we post. But we ask for a lot of feedbacks. Thank you so much for reading the long paragraph.

CIFAR-10, Accuracy: 92.65%

CIFAR-100, Accuracy: 72.92%

Pytorch version Github URL, https://github.com/leaderj1001/RandWireNN

Tensorflow version Github URL, https://github.com/swdsld/RandWire_tensorflow

As Stanford Course(CS231n) (http://cs231n.github.io/understanding-cnn/), they have carried visualization of filters and first layer weights for images using Convolutional Neural Network (CNN). How can I create similar visualization of the same for audio with Matplotlib using WaveNet? I want visualisation of samples after causal and dilated CNN. Are there any better tools for visualization of the same?

I am not an expert at either neural nets in general or RNN’s but I have a data set that I would like to experiment with that is mostly time series in nature. I have roughly 30 different time series variables that I would like to use as my input in order to predict the classification of several classes

​

As i’ve been looking into RNN’s, I only recently came across the concept of a GRU and from my initial thoughts it seems better suited to my particular task as I can specify which of the variables need something like a GRU unit and which do not. Is that even possible? For the variables that do not have a GRU I would like the longer term dependency to decay over the time series, thus I think I want to avoid LSTM.

​

I am curious to hear if there are any best practices for using GRU or even deep RNN in general on time series classification. A lot of what I am reading re:RNN is related to NLP, which is an area I also like but quite different vs time series modelling.

Quick summary: Imitation learning for self-driving cars is confounded by the DAgger problem, but this problem is in principle soluble by scaling up training data, as AlphaStar has demonstrated. Another proposed solution is to allow the agent to sample a human demonstration whenever it makes an error it can’t recover from. Tesla appears to be trying both solutions right now with ~450,000 drivers.

Ever since DeepMind showed with AlphaStar that you can get to human-level performance on StarCraft with imitation learning alone, I’ve been obsessed with the idea of applying imitation learning to self-driving cars on a similar scale.

Waymo has experimented with imitation learning on a very small scale (just ~1,400 hours of driving). (blog post | paper) Waymo’s experiment with their imitation network, ChauffeurNet, felt like a Rorschach test. Some deep learning/autonomous vehicle people on Twitter interpreted it as showing that imitation learning doesn’t work. Others reacted the opposite way, seeing it as a promising direction for future R&D.

Large-scale imitation learning is more exciting to me because AlphaStar is such a compelling proof of concept. Alex Irpan, a reinforcement learning researcher, has a great explanation on his blog:

One of the problems with imitation learning is the way errors can compound over time. I’m not sure if there’s a formal name for this. I’ve always called it the DAgger problem, because that’s the paper that everyone cites when talking about this problem (Ross et al, AISTATS 2011).

… This problem means mistakes in imitation learning often aren’t recoverable, and the temporal nature of the problem means that the longer your episode is, the more likely it is that you enter this negative feedback loop, and the worse you’ll be if you do. …

Due to growing quadratically in T, we expect long-horizon tasks to be harder for imitation learning. A StarCraft game is long enough that I didn’t expect imitation learning to work at all. And yet, imitation learning was good enough to reach the level of a Gold player.

… If you have a very large dataset, from a wide variety of experts of varying skill levels (like, say, a corpus of StarCraft games from anyone who’s ever played the game), then it’s possible that your data already has enough variation to let your agent learn how to recover from several of the incorrect decisions it could make.

So, AlphaStar has shown us that one potential solution to the compounding errors that arise with supervised imitation learning/behavioural cloning (the DAgger problem) is to collect a massive and highly varied dataset that includes a lot of errors, and a lot of recovering from errors. Counterintuitively, humans are teaching the AI by doing it wrong!

It was recently reported in The Information that Tesla is taking a behavioural cloning approach to self-driving. Tesla has around 450,000 drivers with the latest generation of sensor hardware, which includes eight cameras covering 360 degrees around the car. Here’s what The Information said:

Tesla’s cars collect so much camera and other sensor data as they drive around, even when Autopilot isn’t turned on, that the Autopilot team can examine what traditional human driving looks like in various driving scenarios and mimic it, said the person familiar with the system. It uses this information as an additional factor to plan how a car will drive in specific situations—for example, how to steer a curve on a road or avoid an object.

Such an approach has its limits, of course: behavior cloning, as the method is sometimes called, cannot teach an automated driving system to handle dangerous scenarios that cannot be easily anticipated. That’s why some autonomous vehicle programs are wary of relying on the technique.

But Tesla’s engineers believe that by putting enough data from good human driving through a neural network, that network can learn how to directly predict the correct steering, braking and acceleration in most situations. “You don’t need anything else” to teach the system how to drive autonomously, said a person who has been involved with the team. They envision a future in which humans won’t need to write code to tell the car what to do when it encounters a particular scenario; it will know what to do on its own.

Another potential solution is to give the imitation agent access to an expert/human demonstrator when it makes an error and doesn’t know how to recover. If a vehicle drives up onto a sidewalk, and there was never any sidewalk state-action pairs in its training dataset, then you can get a human to demonstrate what to do in that situation. The problem is this is obviously very labour intensive. You need a lot of demonstrators ready to take over when an error occurs.

Strikingly, this seems to be exactly what Tesla is doing. Elon Musk recently described something that sounds like this solution to the DAgger problem:

Well, there’s a lot of things that are learnt. There are certainly edge cases where say somebody’s on Autopilot and they take over. And then, okay, that’s a trigger that goes into our system that says, okay, did they take over for convenience, or did they take over because the Autopilot wasn’t working properly.

There’s also like, let’s say we’re trying to figure out what is the optimal spline for traversing an intersection. Then, the ones where there are no interventions are the right ones. So you then say okay, when it looks like this, do the following. And then you get the optimal spine for navigating a complex intersection.

Elon later said on Twitter:

Your interventions do train the NN [neural network]

This sounds like the neural network is sampling human demonstrations when it makes an error. In theory, it could be reinforcement learning rather than imitation/apprenticeship learning. Any thoughts on whether it would make sense to use RL instead of IL here?

A totally different approach is to use a GAN and do generative adversarial imitation learning (GAIL). In one paper, GAIL did worse than behavioural cloning on short time scales (~2 seconds) but better over long time scales. There’s also inverse reinforcement learning. So, there are a bunch of different ideas to explore in this area.

So, to summarize:

• AlphaStar showed behavioural cloning can solve a complex, tactical, multi-agent task with an astronomically large, continuous action space — like driving! The solution is a massive and highly varied dataset with a lot of human errors.

• When behavioural cloning falls short, another potential solution is to allow the neural network to ask a human for a demonstration when it makes an error.

• Tesla appears to be collecting a massive and highly varied dataset with a lot of human errors for behavioural cloning of the driving task.

• Tesla also appears to allowing its NN to sample human demonstrations when the NN makes an error, unless this is actually reinforcement learning.

This is so exciting to me. The only big difference I can think of between StarCraft and driving is the obvious one: AlphaStar just plugged into the game’s API, whereas to deploy a self-driving car you need to solve computer vision. Besides that, I can’t think of anything. Can y’all?

One way in which driving is actually easier than StarCraft is the time horizon. Driving is a sequence of short time horizon tasks. For example, the time horizon for navigating an intersection is short. Once a car is through the intersection, its actions don’t depend on its past actions or previously observed states.

Before AlphaStar, imitation learning felt a lot more dubious. Now it feels like a proven solution. We might be within spitting distance of honest-to-God self-driving cars.

Either I’m way too optimistic about this, or a lot of people are missing something big. So, which is it? Am I overlooking important differences between StarCraft and driving? Is it wrong to assume the difference between ChauffeurNet and AlphaStar is just scale?