https://thegradient.pub/leveraging-learning-in-robotics-rss-2019-highlights/

I recently wrote a blog post, summarizing interesting works presented at the Robotics Science and Systems Conference. Would love your feedback!

https://deepkit.ai

Hi guys, I’m the founder of Deepkit. An app that helps you visualize, debug, track, and run ML/DL experiments, directly on your workstation or on your own servers, in your LAN or in the cloud. Deepkit will be free for individual users and available in all app stores. You can use the app alone or use the real-time collaborative features within a team using the Deepkit team server.

We’re are looking for alpha users that want to help us building a better, cheaper and more efficient way of doing ML/DL experiments. If you’re interested, please register at the website directly or use this link. We currently only support MacOS, but Windows & Linux will follow. Follow us on Twitter @deepkitAI to get notified once we release the public version.

If you got any questions, I’m happy to answer in the comments.

Hi! We have done some interesting research on breaking the current best public Face ID system – ArcFace – using the adversarial attack technique. It’s quite ordinary but what we succeed is to do it in the real world (i.e. made it not in digital domain only): someone can print the color sticker and stick it to a hat, and after that the similarity with the ground truth drops significantly. Even some sort of attack transferability to other top Face ID models from insightface exists.

Paper: https://arxiv.org/abs/1908.08705

Code: https://github.com/papermsucode/advhat

Video demonstration: https://www.youtube.com/watch?v=a4iNg0wWBsQ

Any comments are welcome!

I’m using LSTM in deep learning to predict indexes.

​

I used MinMaxSacler(0~1) and The lowest MSE obtained through the model is 0.000003

​

However, there is a big difference between the predicted price and the real price.

​

I wonder if it is possible to bridge this gap.

​

If I can, I wonder which method I should use.

​

Your valuable opinions and thoughts will be very much appreciated.

I have been working on classification of variable stars using light curves. However, the curves have different number of data points, from 40 data points up to 100. I have been training my network by randomly removing points until having about 50 points per star, and also augmented the data with different combination of eliminated points, but it seems to introduce a lot of loss.

​

I am interested in different approaches or ideas on how to handle the irregularity.

Hi everyone,

We are pleased to announce the Call for Papers for the 3rd Workshop on Emergent Communication to be held at NeurIPS 2019 on Dec 13 or 14 at Vancouver, Canada.

We invite submissions from researchers both inside and outside the machine learning community in the following areas:

– multi-agent communication
– grounding emergent protocols to natural language
– compositionality in emergent/natural languages
– linguistic generalization
– learning cognitive skills through language
– language evolution
– deep multi-agent learning
– any other area related to the subject of the workshop

Submission Format:
The submitted work should be an extended abstract not exceeding 4 pages (excluding references and supplementary material). The submission should be in pdf format and should follow the style guidelines for NeurIPS 2019. The review process is double-blind. The submissions should not have been previously published in any ML conference nor have appeared in the NeurIPS main conference. We do however appreciate submitting published work from other non-ML conferences. Work currently under submission to another conference is also welcome. We discourage submitting the same work to other NeurIPS workshops. There will be no formal publication of workshop proceedings. However, the accepted papers will be made available online on the workshop website as non-archival reports to allow submissions to future conferences/journals.

Workshop Website: https://sites.google.com/view/emecom2019/
Submissions Link: https://cmt3.research.microsoft.com/emecom2019/

Important Dates:
Submissions Open: Aug 15
Submissions Deadline: Sep 15
Accepted papers notification: Sep 30
Camera ready Deadline: Nov 15
Upload poster/video (optional): Dec 7
Workshop Date: Dec 13 or 14

(All deadlines expire at 11:59pm AoE on the respective dates)

For any queries, reach out to us at [emecomworkshop@gmail.com](mailto:emecomworkshop@gmail.com). We look forward to receiving your submissions!

On behalf of all organizers, Cheers!

Abhinav Gupta (Mila)
Michael Noukhovitch (Mila)
Cinjon Resnick (NYU)
Natasha Jaques (MIT)
Angelos Filos (Oxford)
Marie Ossenkopf (Uni Kassel)
Jakob Foerster (FAIR)
Angeliki Lazaridou (DeepMind)
Ryan Lowe (Mila)
Douwe Kiela (FAIR)
Kyunghyun Cho (NYU/FAIR)

This is a place to share machine learning research papers, journals, and articles that you’re reading this week. If it relates to what you’re researching, by all means elaborate and give us your insight, otherwise it could just be an interesting paper you’ve read.

Please try to provide some insight from your understanding and please don’t post things which are present in wiki.

Preferably you should link the arxiv page (not the PDF, you can easily access the PDF from the summary page but not the other way around) or any other pertinent links.

Previous weeks :

Most upvoted papers two weeks ago:

/u/Cantrill1758: Anomaly Detection Using Autoencoders with Nonlinear Dimensionality Reduction

/u/lysecret: https://arxiv.org/abs/1904.01681

Besides that, there are no rules, have fun.

Since both libraries use cuDNN under the hood, I would expect the individual operations to be similar in speed. However, TensorFlow (in graph mode) compiles a graph so when you run the actual train loop, you have no python overhead outside of the session.run call. In PyTorch, you are in Python a lot due to the dynamic graph, so I would expect that to add some overhead. Not to mention the fact that having a static graph means you can graph optimizations like node pruning and ordering operations. But in many benchmarks I see online, PyTorch has no problems keeping up with TensorFlow on GPUs.

A specific example is the Adam implementations in both libraries:

https://github.com/pytorch/pytorch/blob/master/torch/optim/adam.py

https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/training/adam.py

PyTorch has all the ops as you would expect. For TensorFlow in the {_resource}_apply_dense case (which is the common case, AFAIK), TensorFlow has a dedicated C++ implementation. So here, TensorFlow does not spend extra time in Python AND it has an optimized implementation in C++. In this case, why isn’t the TensorFlow version straight up faster?

​

I’ve heard that PyTorch is better optimized on the cuDNN level. Can anyone provide more details about this? What’s preventing TensorFlow from doing the same thing? The only optimization I know of is that PyTorch uses the NCHW format (which is better optimized for cuDNN) whereas TensorFlow by default uses NHWC.

​

I saw these two discussions but did not see a satisfactory answer:

https://www.reddit.com/r/MachineLearning/comments/7ujc6y/d_can_someone_give_a_technical_explanation_as_to/

https://www.reddit.com/r/MachineLearning/comments/8iguaw/d_why_is_tensorflow_so_slow/

https://video.twimg.com/tweet_video/ECqxU2AU0AAkBwc.mp4

To enable wider use of this powerful deep learning architecture, we propose two new methods. The first, adaptive attention span is a way to make Transformer networks more efficient for longer sentences. With this method, we were able to increase the attention span of a Transformer to over 8,000 tokens without significantly increasing computation time or memory footprint. The second, all-attention layer is a way to simplify the model architecture of Transformer networks. Even with a much simpler architecture, our all-attention network matched the state-of-the-art performance of Transformer networks.

https://ai.facebook.com/blog/making-transformer-networks-simpler-and-more-efficient/