I seldom hear the triumphs and accomplishments of normalizing flows that I hear about from GANs, VAEs and even autoregressive generative models (like PixelCNN). Are the benefits of flows understated? What’s their future?

I’m trying to build a deep learning model for playing a particular game where previous action history is crucial in deciding future actions. I’m wondering if any of you have any tips for how best to encode this history of actions; for this example lets say that there are a set of actions that each player can perform, some of which have another player as a target, and some of which don’t. I was thinking about doing one-hot encoding for action type along with a static player ID number, then feeding the entire history into an LSTM. Are there any better ways?

My In-progress book aimed at implementation of deep learning use-cases using deeplearning4j, a JVM based deep learning library. If you wonder why Java or any JVM languages for this, you may read more about it here. Codebase is already setup here: https://github.com/rahul-raj/Java-Deep-Learning-Cookbook
Codebase gets updated as the book progress. We will add helpful comments in the code and push further optimizations before we release the book on this September. We’re welcoming feedback and still room for lots of improvements. Feel free to make a clone, run on your local and have fun 🙂

I’ve asked this question around long before I began working on this project and here’s a (non-exhaustive) list of answers I got:

1- Building ML models in Python is faster and easier

2- There’s absolutely no use-case where you might need to train in C++

3- If performance is what you’re after, why not train in Python then export your model for inference in C++

4- If you insist on C++, why not use caffe, mxnet or pytorch

And my answers are the following:

1- It’s easier if you’re comfortable with Python. Personally, I hate Python and I am never comfortable working with untyped languages. I may be old school but I have 15+ years of C++ experience and that makes it easier and faster for me.

2- Here’s a few use cases off the top of my head: – Using the library to perform tensor calculations on the GPU, for non machine-learning uses (such as Audio DSPs, Ray Tracing, etc…) while still benefitting from TF’s optimizations and distributed graph computation capabilities – Training Unsupervised ML models with data read from physical sensors in realtime – Training models that require some lengthy data preprocessing or postprocessing that need to be done on CPU – Online-Training models on devices that are memory or battery constrained where having a Python interpreter and a webserver to serve the inference model would be wasteful

3- See #2 There are many cases where this assumption doesn’t hold

4- I tried mxnet for a year before eventually giving up. The library is so unstable and buggy it’s barely usable. Also tensorflow is truly remarkable when it comes to its distributed graph computation capabilities and seems to be the most evolved in terms of portability. It works across OSs, GPUs, TPUs, different CPU arch, etc… Not to mention the large community and active Google support

With all that being said, I’m interested to know what everyone thinks. I plan on Open-Sourcing the wrapper eventually but that would require some extra work on my behalf, proper documentation and working examples, etc… I’d push that further if I know there’s absolutely no interest in the project.

What are your thoughts?

Virtual Adversarial Training is an effective regularization technique which has given good results in supervised learning, semi-supervised learning, and unsupervised clustering. In this article, I give an overview of the technique and also dive into the implementation.

https://divamgupta.com/unsupervised-learning/semi-supervised-learning/2019/05/31/introduction-to-virtual-adversarial-training.html

​

Link to my jupyter notebook:

https://gist.github.com/divamgupta/c778c17459c1f162e789560d5e0b2f0b

Hi everyone, the Github link below is my PyTorch implementation of GANsynth paper from magenta which published at ICLR’19. Now the repo only supports the best setting of the original paper. I will finish the rest of the code in a few weeks.

Link: https://github.com/ss12f32v/GANsynth-pytorch

Hello everyone! Could someone recommend a good state-of-the-art paper and/or dataset for image classification using context information or metadata in general? I have been trying to get into the topic but there isn’t much relevant research in that particular field yet and I am still looking for a good entry point.