How to Run a Custom Version of Python on Windows without Administrative Access

As a Python developer, I often receive questions about how to run a custom version of Python on a Windows machine without administrative access. In this blog post, I will detail the steps to download and install a portable version of Python on Windows, update the PATH environment variable, and install dependencies using pip.

Step 1: Download Python

To start, head to the official Python download page and click on the appropriate link for your version of Python (in this case, Python 3.x). Once the download is complete, extract the contents of the .zip file to a folder.

Step 2: Delete the _pth File

Before we can use the portable version of Python, we need to delete the file ending in ._pth. The exact name changes depending on the Python release you have downloaded, but in general, it will be in the form python3XX._pth, where XX will be the same digits from above. This file is used by Python to locate modules on Windows.

Step 3: Update the PATH Environment Variable

Now that Python is downloaded and prepared, we need to update the PATH environment variable. When you type a command into the command prompt (e.g., python), the command line interpreter will search all of the directories listed in PATH (semicolon-separated on Windows, colon-separated on Linux and macOS) to find that executable. This is also used by Python to locate modules on Windows.

To update the PATH variable, follow these steps:

a. Right-click on Computer or This PC (depending on your version of Windows) and select Properties.

b. In the Properties window, click on Advanced system settings.

c. In the System Properties window, click on Environment Variables.

d. In the Environment Variaries window, click on the New button.

e. Enter the name of the environment variable as PATH, and the value as the path to your Python executable (e.g., C:UsersYourUsernamePython38python.exe).

f. Click OK to save the changes.

Step 4: Install Dependencies Using pip

Now that we have set up the portable version of Python, we need to install any dependencies our code needs using pip. To do this, execute the following command:

pip –no-index –no-binary :all:

This command will install all available packages, including any dependencies required by your code.

Conclusion

In this blog post, we have covered how to download and install a portable version of Python on Windows, update the PATH environment variable, and install dependencies using pip. Please remember that if you are on a shared computer, you should be mindful of disk space usage and put your copy of portable Python on a USB flash drive, or otherwise delete it when you’re done. Additionally, keep your portable Python installation up to date by regularly checking the Python website for security updates.

Alternative methods for those with administrative access include package managers such as chocolately and scoop. If you have any questions or comments, please feel free to leave them below. I will do my best to respond promptly.

Automating Chromium Nightly Downloads on Ubuntu with a Shell Script

As a Linux user, I have to rely on Chrome (Chromium’s rendering engine) for some rare and limited but equally essential tasks. However, the default Chromium package in Ubuntu is now a snap, which complicates matters as snaps generally cause issues I’d rather not deal with on my system. This left me out of options until I found a solution – downloading Chromium Nightly as a .zip archive and automating the process with a shell script.

In this blog post, I’ll share the script I created to download and run Chromium Nightly on Ubuntu. I’ll break down each part of the script and explain how it works.

Before we begin, note that I will not provide support for this script or any issues that may arise from using it. Additionally, please do not ask me to provide assistance with installing or using snaps – I have no experience with them and cannot help you. If you have any questions about shell scripting or Linux in general, I’ll do my best to assist you.

Now, let’s get started!

Variables and Setup

———————

First, we need to define some variables and set up our environment:

“`bash

#!/usr/bin/env bash

set -e

“`

Let’s break down each part of this code:

* `!/usr/bin/env bash`: This tells Linux to run the script with Bash. This must be the first line of the file.

* `set -e`: This sets the exit flag, which means that if any errors occur during the execution of the script, it will exit immediately instead of trying to continue.

Creating a Temporary Directory

——————————

Next, we need to create a temporary directory:

“`bash

mkdir -p ~/tmp/chromium-nightly

“`

This creates a new directory in our home directory called `chromium-nightly`.

Checking if Chromium Nightly is Already Downloaded

———————————————–

Next, we need to check if we’ve already downloaded Chromium Nightly:

“`bash

if [ -x /usr/local/bin/chrome ]; then

echo “Chromium Nightly is already downloaded.”

exit 0

fi

“`

Here’s how this code works:

* `[ -x /usr/local/bin/chrome ]` checks if the `chrome` binary exists and is executable. If it does, the command returns a zero status code (indicating success).

* `if [ … ]` executes the code inside the if statement if the previous command returns a zero status code.

* `echo “Chromium Nightly is already downloaded.”` prints the message to standard output.

* `exit 0` exits the script with a zero status code.

Downloading Chromium Nightly

—————————–

Now that we’ve checked if Chromium Nightly is already downloaded, let’s download it:

“`bash

curl -O https://chromium.woolyss.com/nightly/Linux/x64/chrome.zip

“`

This downloads the latest version of Chromium Nightly as a .zip archive from the specified URL.

Extracting Chromium Nightly

—————————-

Next, we need to extract the downloaded archive:

“`bash

unzip chrome.zip -d ~/tmp/chromium-nightly

“`

This extracts the contents of the `chrome.zip` archive into the `chromium-nightly` directory.

Running Chromium Nightly

—————————

Finally, let’s run Chromium Nightly:

“`bash

cd ~/tmp/chromium-nightly

./chrome –new-window

“`

This changes our current working directory to the `chromium-nightly` directory and starts a new instance of Chromium Nightly using the `chrome` command.

The complete script is:

“`bash

#!/usr/bin/env bash

set -e

mkdir -p ~/tmp/chromium-nightly

if [ -x /usr/local/bin/chrome ]; then

echo “Chromium Nightly is already downloaded.”

exit 0

fi

curl -O https://chromium.woolyss.com/nightly/Linux/x64/chrome.zip

unzip chrome.zip -d ~/tmp/chromium-nightly

cd ~/tmp/chromium-nightly

./chrome –new-window

“`

I hope this script helps you automate the process of downloading and running Chromium Nightly on Ubuntu! Note that I will not provide support for this script or any issues that may arise from using it. If you have any questions about shell scripting or Linux in general, I’ll do my best to assist you.

This is a very detailed and well-structured blog post about the author’s process for reading research papers. Here are some key points and observations:

1. The author provides a list of steps they follow when reading a research paper, which includes:

* Filtering search engines based on relevance to their project

* Skimming introduction and conclusion

* Evaluating the authors’ background and expertise in the field

* Judging the quality of the publication outlet

* Checking for any conflicts of interest

* Gauging the paper’s novelty and impact

* Evaluating the methodology and approach

* Assessing the relevance to their research project

* Checking for any obvious errors or flaws in reasoning

1. The author emphasizes the importance of continually evaluating whether it is worth continuing to read the paper, as it is not always obvious which of these cases they find themselves in.

12. They mention that they employ a number of strategies to deal with difficult situations, such as having a PhD supervisor to discuss with, keeping in regular contact, summarizing what they’ve read and how it relates to their project and list of questions to ask, gathering their thoughts.

13. The author outlines their personal process for reading research papers, which includes:

* Preparation (background reading)

* Skimming and Scanning

* Evaluating relevance and quality

* Summarizing the paper’s content and relating it to their project

* Gauging their interest in and understanding of the topic

* Identifying any issues with the paper’s explanation or structure

* Judging the authors’ background and expertise in the field

13. The author notes that their method is not perfect either, and that it will likely evolve over time as they learn more.

In general, this post provides a detailed look into the author’s process for reading research papers and emphasizes the importance of continually evaluating whether it is worth continuing to read the paper. They also mention that their method may evolve over time and that they are still learning. The post concludes by outlining the rules for commenting on the site, which includes not following the rules, and provides information about the design and licensing of the content.

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!

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.

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.

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.