There is plenty of research on ML in signal processing. The majority of it, so it seams to me, is about showing feasibility of ML-based receivers (end-to-end or individual functional blocks of). To me, we are past that – pretty much everybody realizes that ML-based OFDM receiver is possible and can probably achieve comparable performance to that of a conventional receiver. Furthermore, even if/when someone manages to show some (probably marginal) performance gain, that would probably have academic value, but not much beyond that.

To me, there are two fundamental questions, for which I haven’t found answers in the literature and would really appreciate some pointers:

1. Can ML-based receiver achieve comparable performance with comparable complexity (to these of a conventional receiver)?
2. Beyond (probably marginal) performance gains, what can be commercial benefits of switching from a conventional receiver to an ML-based one?

Thanks!

(“More citations” is not an acceptable answer :P)

Just curious to see what people think would be most helpful (e.g. what resources/tools/etc don’t you have that you would like to have?). Let me know!

I have heard that GPUs love power of 2s, and that’s why embeddings and batch sizes are often seen as some power of 2, (64, 128, 256, 512, 1024, etc).

But I never have seen a concrete explanation for why this is.

Also, should a max batch size to be considered the biggest even number that the GPU memory can handle, or the biggest power of 2 that the GPU memory can handle?

Today I jump into the deep waters of research papers that are related to human pose estimation. This article is a sneek peak into what I found.

On:

https://github.com/openai/gym/blob/master/gym/envs/atari/atari_env.py

There seems to be a common list for every atari environment.

But if you use something like:

print(env.env.get_action_meanings())

It lists only a subsection of these options.

Could I use the same architecture for multiple games by using the “maximum” possible actions? Would the environment accept that?

Hey everyone, I was wondering if there were any resources on how to fine-tune GPT-2 on a custom corpus of data, for example, Shakespearean poems or Cornell Movie Dialogues.

Hi everyone,

My name is Dima and I wanted to tell you about an open-source library we work on called TamnunML.

Our goal is to provide an easy to use library (with sklearn interface) for complex model training and fine-tuning. For example, with tamnun you can train any pytorch module like this:

“`python from torch import nn from tamnun.core import TorchEstimator

module = nn.Linear(128, 2) clf = TorchEstimator(module, task_type=’classification’).fit(train_X, train_y) “`

or, you can fine tune BERT on your task as easy as: “`python from tamnun.bert import BertClassifier, BertVectorizer from sklearn.pipeline import make_pipeline

clf = make_pipeline(BertVectorizer(), BertClassifier(num_of_classes=2)).fit(train_X, train_y) predicted = clf.predict(test_X) “`

At the moment tamnun supports training (almost) any pytorch module using just a “fit” method, easy BERT fine-tuning and model distillation.

You can read more about how to train (almost) any pytroch module with tamnun here

The library github page.

The introduction to TamnunML of the library we published in our blog.