I’m taking up a project on machine learning for game playing, where my aim is to build a computer player for any game. I’ve considered board games and simple video games, but nothing really sticks out in my mind. Has anyone got any ideas for a game (one that’s not overdone to death like Go or Chess, or extremely complicated like an open-world game) that would work well for this project?

Can anyone share the lecture videos from Machine Learning CS189 from Berkeley. The youtube links in the course webpage are not available. I was wondering if someone would be willing to share it? =)

As part of MITRE’s “Generation Ai Nexus” effort bringing machine learning education to people at all levels of the work force, they have partnered with George Mason to create a curriculum blending AI & Systems Engineering. So far they created a pilot for a Risk Management course including students with no prior ML experience. The goal is to have students learn how to apply machine learning tools and methodologies to real world data to create more “meaningful” predictions, especially for emerging technologies.

Learn more and listen to the Interview here: https://kde.mitre.org/blog/2019/07/15/interview-with-dr-philip-barry-on-blending-ai-and-education/

While deep learning and embedding techniques are getting increasingly popular for tasks related to (knowledge) graphs, they often suffer from being not interpretable, which is key in critical domains such as health care. We propose a simple technique called KG Path Tree which is competitive to current state-of-the-art while being interpretable (we compare it to RDF2Vec and (Relational) Graph CNN).

​

A KG Path Tree is a single decision tree in which each internal node tests for the presence of a certain walk in a sample’s graph neighborhood. Our walks are of a specific form: a walk of length `l` starts with a root, followed by `l – 2` wildcards (`*`) and then a named entity. An example could be: `root -> * -> * -> * -> Ghent` which would match the walk `Gilles Vandewiele –> studiedAt –> Ghent University –> locatedIn –> Ghent` when classifying `Gilles Vandewiele`. The final decision tree can then be used for classification of unseen samples. The path from the root to the prediction can easily be displayed (local explanation) and the model can be inspected (global explanation).

​

All code can be found on Github.

In the time series classification domain, shapelets are small subseries that are discriminative for a certain class. It has been shown that by projecting the original dataset to a distance space, where each axis corresponds to the distance to a certain shapelet, classifiers are able to achieve state-of-the-art results on a plethora of datasets. In order to find these shapelets, the current state-of-the-art (in terms of predictive performance) performs a brute-force search that quickly becomes intractable for larger datasets.

​

Therefore, we propose a genetic algorithm that searches for an entire set of shapelets directly. This results in a more scalable algorithm that is competitive to the current state-of-the-art. Moreover, the number of shapelets needed to achieve this competitive performance is several orders of magnitude smaller than the current sota.

​

The implementation follows the sklearn interface. You can just simply use `fit` and `transform` methods. There are docs.

​

You can find the code (with an example notebook and tutorial) on Github.

After Faces in the Wild, some researchers published ‘Primate Face Identification in the Wild’.
https://arxiv.org/pdf/1907.02642.pdf

They share 3 datasets:
-Rhesus Macaque Dataset (7679 images of 93 individuals)
-Chimpanzee Dataset C-ZOO (2109 images for 24 identities) of better quality that the following one
-Chimpanzee Dataset C-Tai (5057 images for 66 identities)

The TL;DR of what they say:
“`
We developed a novel face identification approach that is capable of learningpose invariant features, thus allowing to generalize well across poses without the re-quirement of a face alignment step. Additionally, the proposed approach leverages thepairwise constraints to capture underlying data semantics enabling it to perform effec-tively for unseen classes
“`

Pre-trained models are beautiful. They save your time, energy and/or money. You can obtain several pre-trained machine translation models for mostly European languages here. In this project, I add six other models: Korean <-> English, Chinese, Japanese as I failed to find publicly available ones. Not surprisingly, the biggest challenge in training NMT models for those language pairs is the lack of large parallel corpora. I decided to use both public data (OpenSubtitles) and private data) to overcome the difficulties. Overall, each of their performance may not so impressive, but you can keep training it with your own data, if necessary.

https://github.com/Kyubyong/cjk_trans

I recently re-implemented RDF2VEC completely in Python due to the fact that the provided code in that paper is partially written in Java. RDF2Vec is an unsupervised, task-agnostic algorithm that creates an embedding for different nodes in a Knowledge Graph that can be used for further downstream tasks (such as classification or link prediction). To do this, RDF2Vec first creates “sentences” which can be fed to Word2Vec by extracting random walks of a certain depth from the Knowledge Graph. To create a random walk, we initialize its first hop to be one of the specified training entities in our KG. Then, we can iteratively extend our random walk by sampling out of the neighbors from the last hop of our walk.

​

The code can be found on Github.

​

Original paper: here (other, open versions can be found)

Original code (java for walks, python/gensim for word2vec): here

I recently stumbled upon a very interesting blog post, by Gregory Plumb, which introduces a new technique that can generate a local explanation (that captures global patterns and is based on neighboring examples). The intuition/idea is really simple (which makes it even more awesome). For each of the (testing) points for which you want to generate a prediction, you train a linear model where each training sample gets a different weight. In order to calculate the weight of a training sample, you check how “similar” it is to the sample for which you want to predict by looking into a created decision tree ensemble.

​

Since the technique is that simple (but effective!), I decided to re-implement it (with an interface similar to sklearn) and reproduce the experiment where they compare it to RF. While initial results are slightly different (due to doing less runs), we still see that MAPLE produces better predictive performances than the Random Forest on which it is based, while being interpretable (we can provide a linear model for each prediction, which can give a local explanation).

​

The code itself can be found on Github. Hope it is of use to any of you!

​

Original paper: here

Original code: here