Heya! It’s been a moment since my last update, but I have some exciting news to share with you all! As you might have guessed by the cool new banner, I have had a paper accepted for the Northern Lights Deep Learning Conference 2024! The conference will be held on 9th – 11th January 2024 in Tromsø, Norway, and I have every intention of attending in person to present my rainfall radar research. ️

The paper’s title is “Towards AI for approximating hydrodynamic simulations as a 2D segmentation task”, and I can’t wait to share more about it with you all soon! However, I’m not sure if I’m allowed to share the paper just yet, so please bear with me while I figure that out.

In the meantime, I do have a Cool Poster that I’ll be sharing here after the event, so keep an eye out for it in the new Research section of my main homepage! I’m super excited to share all my NLDL 2024 updates with you all, and I hope this cool new banner gets some use bringing you more posts about (and, hopefully, from!) NLDL 2024!

Oh, and before I forget, please note that comments that don’t follow these rules may be deleted and could result in a ban for the offending user. These rules may also be amended without notice, so please check them often. Thank you for your understanding!

That’s all for now, but I’ll be back soon with more updates and shares from NLDL 2024! Thanks for reading, and have a great day!

Heya! Got another short port for you here. You might notice that on all posts now there’s a new share button (those buttons that take you to difference places with a link to this site to share it elsewhere) that looks like this: If you haven’t seen it before, this is the logo for the Fediverse, a decentralized network of servers and software that all interoperate (find out more here: ).

Since creating my Mastodon account, I’ve wanted some way to allow everyone here to share my posts on the Fediverse if they feel that way inclined. Unlike other centralized social media platforms like Reddit etc., the Fediverse doesn’t have a ‘central’ server that you can link to. To this end, you need a landing page to act as a middleman.

There are a few options out there already (e.g. share2fedi), but I wanted something specific and static, so I built my own solution. It looks like this: (Above: A screenshot of Share2Fediverse.) It’s basically a bit of HTML + CSS for styling, a splash of JavaScript to make the interface function, and remember the instance + software you select for next time via local storage. Check it out at this demo link: /#text=The%20fediverse%20is%20cool!%20%E2%9C%A8

Currently, it supports sharing to Mastodon, GNU Social, and Diaspora. As it turns out, finding the share URL (e.g., for Mastodon on fediscience.org, it’s ) is more difficult than it sounds, as I haven’t found it to be well advertised. I’d love to add e.g., Pixelfed, Kbin, GoToSocial, Pleroma, and more…. but I need the share URL!

If you know the share URL for any piece of Fediverse software, please do leave a comment below. If you’re interested in the source code, you can find it here: …if you’d really like to help out, you could even open a pull request! The file you want to edit is src/lib/software_db.mjs – though if you leave a comment here or open an issue, I’ll pick it up and add any requests.

See you on the Fediverse! o/

Any comments that are seen to not follow these rules will probably be deleted. It may also result in a ban for the offending user such that they are unable to view the site for an arbitrary length of time.

These rules may also be amended without notice, so please check them often.

Your email address, should you choose it, is used to send you notifications of replies to your comment(s). It is used to display your Gravatar.

Your email address will be kept securely on the server and will not be given to anyone else. You will not receive any spam either.

If you do not wish to receive emails anymore, please contact me (you can find my email address at the bottom of every page) and I will prevent emails from being sent to your email address. I will eventually write an automated system to handle this but for now, I will deal with requests manually. I should get back to you within 48 hours. Note that your (gr)avatar will also disappear and be replaced by an identicon.

Built by Starbeamrainbowlabs. Feedback can be sent to feedback at starbeamrainbowlabs dot com. Comments can be made on all blog posts. Some icons from the awesome Open Iconic icon set.

Privacy Policy | Terms of Service | Licensing Information

Blog post content available under

Design © Mythdael 2024. More information available on the licensing page.

As a researcher in the field of artificial intelligence, I often find myself needing to modify existing npm packages to fit my specific needs. However, monkeypatching these packages can be a delicate task, as it can easily lead to unintended consequences and make the package unusable. In this blog post, I want to share a clever hack I used to disable gamepad support in the Babylon.js library, which is a popular JavaScript framework for building 3D experiences.

Background

———-

Babylon.js is a powerful tool for building 3D experiences on the web. However, its gamepad support is horribly broken, and I needed to disable it for my demo. Unfortunately, monkeypatching the library is not straightforward, as it can easily lead to unintended consequences and make the package unusable.

The Solution

————-

To disable gamepad support in Babylon.js, I used a tool called patch-package. Patch-package is a lovely little tool that enables you to generate patch files simply by editing a given npm package in-situ. It also automatically and transparently applies the generated patch files on npm install, requiring no additional setup steps.

Here’s how I used patch-package to disable gamepad support in Babylon.js:

1. Install patch-package:

“`bash

npm install patch-package

“`

2. Edit the Babylon.js package:

First, I had to switch from the main Babylon.js package to @babylon/core, which contains the source code. Unfortunately, the official documentation for Babylon.js is rather inconsistent, which can lead to confusion using the latter. However, once I figured out how the imports worked, it all came out in the wash.

Next, I directly edited the files associated with the target package in node_modules/. To do this, you need to open the package’s directory in your code editor and edit the files directly.

3. Generate the patch file:

Once you’ve made the desired changes to the package, generate the patch file like so:

“`bash

patch-package –package-name @babylon/core –write-patches

“`

This should create a patch file in the directory patches/ alongside your package.json file.

4. Apply the patch:

To apply the patch, open up your package.json file for editing and add the following to the scripts object:

“`json

“scripts”: {

“patch”: “patch-package –package-name @babylon/core”

}

“`

This will automatically apply the generated patch file on npm install.

5. Commit the changes:

Finally, commit your changes to your Git/Mercurial/whatever repository. It’s important to keep a record of your modifications, especially if you plan to reuse this hack in future projects.

Conclusion

———-

In this blog post, I shared a clever hack for disabling gamepad support in Babylon.js using patch-package. This technique can be useful when you need to modify existing npm packages without monkeypatching them. Just keep in mind that monkeypatching can still have unintended consequences, so always make sure you understand the risks before proceeding.

This is a blog post about a research project on social media flooding, and it provides an overview of the demo that was presented at a conference. The author discusses how they used Babylon.js to create the graphics for the demo and how they optimized the location polling using an octree. They also explain how they implemented the memory pool for the textures and how they monkeypatched the npm package to disable the inbuilt support for gamepads. The post provides a detailed explanation of the techniques used to create the demo and the challenges that were faced during its development.

The author begins by describing the research project on social media flooding and how it was visualized using Babylon.js. They then discuss how they implemented the graphics, including the use of an octree for location polling and a memory pool for textures. The author also explains how they monkeypatched the npm package to disable the inbuilt support for gamepads.

The post provides a detailed explanation of the techniques used to create the demo and the challenges faced during its development. The author emphasizes the importance of using Babylon.js for graphics and optimizing location polling using an octree, as well as the need for monkeypatching the npm package to disable inbuilt support for gamepads.

Overall, this post provides a comprehensive overview of the research project on social media flooding and how it was visualized using Babylon.js. The author’s use of technical terms and their detailed explanations of the techniques used make the post more suitable for readers with a technical background. However, the post may be too dense for casual readers, as the author assumes a certain level of prior knowledge about the topics discussed.

Hello there! On Saturday, September 9th, 2023, I was on the supercomputing stand for the Hull Science Festival with a cool demo that showcases how artificial intelligences understand and process text. Today, I’m excited to announce that the demo is now available online here on my website!

In this blog post, I’ll provide a quick explanation of what you’re looking at, but if you’re impatient, you can just find the demo here: .

All artificial intelligences (AIs) currently developed are essentially complex parametrised mathematical models. We train these models by updating their parameters little by little until the output of the model is similar to the output of some ground truth label. In other words, an AI is just a bunch of math!

So, how does it understand text? The answer lies in converting text to numbers – a process often called ‘word embedding’. This is done by splitting an input sentence into words, and then individually converting each word into a series of numbers, which is what you’ll see in the demo. Similar sorts of words will have similar sorts of numbers (or positions in 3D space in the demo).

In the demo, you’ll see clouds of words processed from Wikipedia. I downloaded a bunch of page abstracts for Wikipedia in multiple languages, extracted a list of words, converted them to numbers using GloVe and then plotted them in 3D space. Can you identify every language displayed here?

If you were one of the lucky people who saw my demo in person, you may notice that this online demo looks different from the one I originally presented at the science festival. That’s because the in-person demo uses data from social media, but this one uses data from Wikipedia to preserve privacy.

I hope you enjoy the demo! Time permitting, I’ll be back with more posts soon to explain how I did this and the AI/NLP theory behind it at a more technical level. Some topics I want to talk about include:

* How word embedding works

* The theory behind the GloVe algorithm

* How to create your own word embeddings using Python

Until next time, I’ll leave you with two pictures I took on the day: .

Edit 2023-11-30: Oops! I forgot to link to the source code….! If you’d like to take a gander at the source code behind the demo, you can find it here:

Please note that comments that do not follow these rules will be deleted, and may result in a ban for the offending user. These rules may also be amended without notice, so please check them often.

Hey there! I’m super excited to share with you all that I recently submitted a paper to the Northern Lights Deep Learning Conference (NLDL) – my very first conference submission, no less! As some of you may know, I’ve been working on this research project for quite some time now, and it’s amazing to see it finally come together in a tangible form.

So, what’s the paper about? Well, as many of you know, my research focuses on using rainfall radar data to predict floods. It may sound a bit complicated, but the basic idea is that I’m trying to train a machine learning model to recognize patterns in rainfall data that could indicate a high risk of flooding. ️❓

The paper I submitted is titled “Towards AI for approximating hydrodynamic simulations as a 2D segmentation task,” and it’s all about how I’ve been using image segmentation techniques to improve the accuracy of my flood predictions.

Now, I know some of you might be thinking, “But wait, haven’t you already talked about this research in your PhD update blog posts?” And you would be correct! As some of you may know, I’ve been sharing updates on my research journey for quite some time now, and the paper I submitted is essentially an expanded version of one of those updates.

However, there are a few key differences between the blog posts and the paper I submitted. For one thing, the paper includes more formal language and rigorous mathematical proofs, whereas the blog posts were more casual and conversational.

Additionally, the paper includes some new results and insights that I haven’t shared publicly before, so even if you’ve been following my research journey from the beginning, there’s still some fresh content to explore!

Of course, as with any academic submission, there’s always a chance that the paper might be rejected. But I’m keeping my fingers crossed that it will be accepted, and I’ll get the opportunity to present my research at the conference!

In any case, I’ll be sure to keep you all updated on my progress, whether it’s through this blog post or future PhD update posts. Thanks for following along on this journey with me, and I look forward to sharing more of my research with you soon!