I am Niels, 25 years old, living in Belgium.
I studied Business and Information Systems Engineering (a Master of Science) at KU Leuven. I graduated magna cum laude (83%). This programme is a more technical version of Business Engineering. Besides business-oriented courses like management accounting, economics, and finance, I got technical courses including introduction to object-oriented programming, operating systems, computer networks, and so on.
During my masters, I discovered deep learning by watching this wonderful video (and the subsequent ones) by 3Blue1Brown. I immediately fell in love with the way neural networks work and how they are able to recognize handwritten digits without being explicitly programmed. It felt like magic to me :) I also really liked the fact that they involve linear algebra, which was one of my favorite courses during my first year at university. A bit later, pure out of interest, I discovered and followed the lectures of Andrej Karpathy in his cs231n course thaught at the University of Stanford. This course gave me the foundations to understand deep learning, to understand the forward pass, backward pass of neural networks, and so on. To me, cs231n (and especially the courses given by Karpathy) is a gem. All assignments are in Python (first in pure Numpy, later in Tensorflow/PyTorch).I highly recommend it!
At the same time, I had the opportunity to follow a specialization as part of my masters called Architecture, Infrastructure and Big Data, and it included courses such as machine learning, data mining and natural language processing. When I discovered natural language processing, I also immediately fell in love with it. I got introduced to things like dependency parsing, constituency parsing, semantic role labeling (more traditional NLP) and the wonderful SpaCy package. It was also in the NLP course that I was introduced to the Transformer, a “new architecture by Google” that replaced a lot of the complexity of RNNs by a stack of encoder layers relying on a thing called self-attention. I immediately wanted to know more about this architecture, so I read the paper and the wonderful blog post by Jay Allamar.
My master thesis was about deep learning and natural language processing (my two favorite topics combined!). We investigated the applicability of deep learning to automatically construct (BPMN-like) business process flowcharts based on textual process descriptions. As I really wanted to use the Transformer as part of my master thesis and HuggingFace Transformers did not yet exist, we used the tensor2tensor package by Google Brain to train a Transformer on Google Cloud. The project was a success, and we got a grade of 18 out of 20. You can find our paper and source code here.
As I wanted to dive more deeply into the technical bits of deep learning, I decided to start working as an Applied AI Researcher at Howest, where I apply state-of-the-art deep learning algorithms (mostly NLP) for all kinds of business cases. I’m involved in several projects supported by VLAIO, the Flemish Institute for Innovation and Entrepreneurship. Besides this, I’m consulting several companies to assist them in applying NLP.
During my projects at Howest, I used HuggingFace Transformers more and more. However, I didn’t fully understood the library and how the models/tokenizers are to be used. In August 2020, as a summer project (and as a learning opportunity), I decided to challenge myself: implement TAPAS, an algorithm built by Google, and port it to HuggingFace Transformers to make it available for everyone. This was quite a challenge, as the original algorithm was written in Tensorflow 1 and had lots of utility files. Moreover, the data format that was used by the Google authors of TAPAS were Protocol Buffers, which is not the easiest format. My goal was to implement the algorithm in PyTorch. However, after several months of coding, diving into the Github repo, I was satisfied with my implementation and opened up a pull request on the Transformers repo. After some time, my PR got merged! Moreover, HuggingFace released a new version of the Transformers repo (4.1.1) with TAPAS on the frontpage. They also mentioned my name on their social media, stating “incredible implementation of the model and tokenizer by NielsRogge” :) Moreover, the people of HuggingFace asked me to become part of the core contributors team of HuggingFace :) After that, I worked on several other models, including improving LayoutLM by Microsoft Research, adding the Vision Transformer (ViT) by Google AI and adding Data-efficient Image Transformers (DeiT) by Facebook AI to the library.
Update: I’ve now also added the following algorithms to the library:
- LUKE by Studio Ousia, capable of doing state-of-the-art relation extraction and other tasks involving reasoning about entities in text
- DEtection TRansformers (DETR) by Facebook AI, the first successful approach of applying Transformers at the task of object detection/panoptic segmentation
- CANINE by Google AI, a tokenizer-free model (a Transformer which directly operates at a character level)
- BEiT by Microsoft Research, a self-supervised Vision Transformer (by cleverly combining it with the encoder of the VQ-VAE of OpenAI’s DALL-E)
- LayoutLMv2 by Microsoft Research, an improved version of LayoutLM, a Transformer capable of understanding scanned documents such as invoices, forms, handwritten text
Technologies
At the time of writing, I’m mostly working with:
- Programming languages: Python
- Tools (libraries): PyTorch, HuggingFace Transformers, Flair NLP (I do know the basics of Tensorflow and JAX/FLAX)
- IDEs: Visual Studio Code, Google Colab, Jupyter Notebook
Contact me
You can contact me on the following email address: