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/

I’m trying to compare the predictive accuracy of few regression models. For simplicity, let’s say that I have a polynomial of degree 6 and a GAM model with many knots. One simple approach would be to compare the RMSE and/or MAE. In this case, the GAM model has a lower RMSE and MAE than those of the polynomial model, but the difference is small. Now based on the RMSE and MAE values, I should choose the GAM model, but the small difference is making me question whether it makes sense to take the GAM model over the simpler polynomial model.

Searching around, I found that one can use the Diebold-Mariano (or the similar HLN) test to compare the predictive accuracy of two forecasts in time series. The DM/HLN tests determine whether there is any significant difference between the forecasts. However, I think it would not be appropriate to use the DM/HLN-test in my case, since the tests compute autocovariance at lags in order to derive the test-statistic and that would make little sense in the context of non-time series forecasts.

Are there any similar tests that can be used for non-time series forecasts?

I’ve recently encountered some of the point cloud to persistence diagram representations in time series analysis, and they seem very interesting, if not familiar to those of us who ended up here from a computational/algorithmic background.

I’ve so far primarily encountered these topics written on in, naturally, topology and analysis settings, but was wondering if there’s yet been heavy adaptation in the ML sphere? With an influx of interest in geometric/topological domains these days, I would think this would be a popular topic.

So I suppose that my objective is to learn from more informed people on some of the relevant existing work in ML, as well as what we know of the strengths and criticisms regarding these representations of time series.

I have a project to detect if myself or guests are present in a given room using a picamera. Does anyone know of any pretrained human presence detection models available?