Exploring hackathons as creative playgrounds for musicians, composers, and music technologists

More often than not, hackathons are associated with advanced experience in coding and software architecture, expressed through non-stop, caffeine-fueled writing of code. Whilst this is a fully valid approach to competing at a hackathon, framing these events as an opportunity to collaborate and expand your creative practice is often overlooked.

In this article we will focus on what hackathons can offer to students from the field of music. This will include insights from Steven Bradley, a Professor at the Department of Computer Science here at Durham, with a particular interest in computational approaches to music theory.

It’s Not Just Code

Hackathons are commonly framed as technical competitions, but at their core, they are fast-paced creative labs with the ability to bring different disciplines together to solve problems. Rather than rewarding polished final products, hackathons prioritise experimentation and collaboration above all.

For music students, this environment should feel surprisingly familiar. Workshops and rehearsals carry similar constraints: limited time, evolving ideas and requirements, as well as constant feedback.

Most importantly, hackathons do not require every participant to be an expert programmer. The most successful teams are built on the intersection of various disciplines. This leads to projects that excel in every field, not just the code. From sound design to the final presentation, a project is judged for far more than its coding complexity, and teams often benefit from assigning design-based tasks to those with a background in the field. We’ve had a solid understanding of this concept for quite some time:

“The society that separates its scholars from its warriors will have its thinking done by cowards and its fighting by fools” (Thucydides, ~400BC)

Whilst Thucydides had minimal software engineering experience, his ideas align with what makes a great hackathon team: Talented coders, innovative designers, creative minds, and well-defined leaders in each area. Music students, far from being out of place, bring a uniquely valuable creative perspective to any team.

Past Musical Projects at DurHack

For some inspiration, and to demonstrate some wonderful examples of intersecting programming and music, let’s take a look at some past DurHack projects that center themselves around music through the medium of coding.

Echo: Turning Stories into Soundscapes

One of the most compelling examples of music-led innovation at DurHack is Echo, a project that reimagines what it means to experience a story. Awarded 2nd place (Solar Spark) at DurHack X (2025), Echo demonstrates how musical thinking can drive technically sophisticated and conceptually original ideas.

At its core, Echo begins with a simple but powerful question: why is reading silent? While film and games rely heavily on sound to shape emotion, books remain largely auditory blank spaces. Echo challenges this by transforming written text into adaptive soundscapes that evolve alongside the narrative.

The system works by analysing a story page by page, identifying key elements such as setting and emotional tone. This information is then structured into data that can be used to generate a dynamic soundtrack. A calm scene might be accompanied by soft environmental ambience, while rising tension could introduce darker, more intense sonic textures.

What makes this particularly interesting is not just the technical implementation, but the musical sensitivity behind it. The project relies on an understanding of how sound interacts with narrative, something music students are uniquely equipped to contribute.

Technically, Echo uses a multi-agent AI system to break down and interpret text. But one of the biggest challenges the team faced was controlling the system’s creativity. Left unchecked, it would invent details or over-describe scenes.

Their solution highlights a key parallel with music, that creativity often thrives within constraints, not without them. This is a familiar concept to composers working within harmonic systems, stylistic rules, or formal structures. The same principle applies here, where carefully designed limitations lead to more meaningful and usable outputs.

Overall, Echo is a clear example of how music students can shape hackathon projects beyond surface-level contributions. While the technical stack is impressive, the project’s success ultimately depends on its creative direction. Without that, it would simply be text analysis, not an immersive storytelling tool.

Clap Collider: Making Movement Musical

If Echo explores how music can enhance storytelling, Clap Collider flips the relationship entirely by turning physical movement into the source of music itself. Winner of first place (Legacy Luminary) at DurHack X (2025), this project embodies the idea of “bridging between worlds” by connecting gesture, space, and sound.

Rather than asking users to interact with pre-existing music, Clap Collider invites them to create it through movement:

• Clapping or raising hands triggers a looping drum beat
• Swiping gestures switch modes or introduce melodic layers
• The body becomes both the controller and the performer

This transforms music-making into something immediate and embodied. There’s no need for traditional instruments or interfaces, just motion, rhythm, and interaction. For music students, this idea resonates strongly with practices in improvisation, performance, and experimental composition.

Technically, the project was divided into three key components:

• Frontend: handling the user interface and real-time interaction
• Pose estimation: tracking body movement and interpreting gestures
• Music generation: translating those gestures into rhythmic and melodic loops

One of the most significant challenges the team faced was integrating new musical layers into an ongoing loop, and how to introduce a new instrument mid-cycle without breaking the rhythm. This is both a technical and musical issue. Questions of timing, phrasing, and continuity are central to performance and composition, so solving this problem required thinking like musicians as much as programmers.

What stands out about Clap Collider is how closely the final result aligned with the team’s original vision. In a hackathon setting, where ideas often need to be scaled back or simplified, successfully realising a concept like this is a significant achievement.

Clap Collider reinforces the idea that hackathons are spaces to prototype new forms of creative expression, not just programs and software.

Professor Steven Bradley on Music and Coding

To better understand the relationship between music and hackathons, I spoke with Professor Steven Bradley from Durham University’s Department of Computer Science, whose work explores computational approaches to music theory. His perspective highlights a crucial point: music and programming are far less separate than they might initially appear. This interview included an amazing story of making a custom electric hurdy gurdy, one so awe-inspiring that it deserves its own article entirely.

One of the strongest overlaps between music and computing, Bradley explains, is pattern recognition. Musicians are constantly identifying, interpreting, and reproducing patterns, whether harmonic, rhythmic, or structural. This same skill lies at the heart of programming. Beyond this, he emphasises a mindset that applies equally to both disciplines:

“One of the biggest predictors of whether you can be good at writing programs is whether you think that you will be able to do it if you keep on trying.”

For music students, this idea should feel familiar. Progress in music is iterative, often requiring significant effort before results become visible. As Bradley puts it:

“One of the issues with music is that you have to put a lot into it to get something out.”

This persistence translates directly into hackathons, where experimentation, failure, and rapid iteration are part of the process.

Bradley strongly challenges the idea that music students lack technical relevance in hackathon settings. Instead, he points to a range of transferable skills that are often underutilised:

• Creative problem-solving
• Iterative development through feedback
• Collaboration in ensemble settings
• Communication and presentation

“There are lots of important transferable skills that are often not routinely applied that music students bring.”

When combined with any degree of programming ability, these skills become particularly powerful.

“Music provides a lot of soft skills, and combining this with the ability to write programs to solve specific problems in your field can be really powerful.”

Solving Human Problems Via Domain Expertise

A key advantage music students bring to hackathons is domain knowledge. While programmers may excel at building systems, musicians understand the real-world challenges those systems might address. Bradley notes:

“Bringing their domain expertise in can aid in identifying and solving problems that affect humans.”

This is especially relevant in creative and human-centred projects, where understanding user experience, emotion, and interaction can define a project’s success.

Modules Exploring Music and Programming

At Durham, this intersection is already being explored through modules such as Introduction to Music Computing and Advanced Music Computation, the latter taught by Bradley himself. These courses demonstrate how programming can become a creative medium by:

• Analysing musical structures computationally
• Building systems that interact with musical ideas
• Exploring computational creativity, where code functions as an instrument

As Bradley puts it, treating a programming language like an instrument opens new creative possibilities.

“If you can explore music spaces more quickly, then you can engage creativity more.”

What This Means For Hackathons

Bradley’s insights reinforce a central idea: hackathons are both technical challenges and creative ecosystems. Music students already possess many of the cognitive and collaborative tools needed to thrive in them.

Rather than starting from scratch, they are extending an existing skill set into a new medium. And in doing so, they carry the potential to reshape what hackathon projects can be.

Check out this article on Designspark!

DurHack X was the 10th edition of Durham University’s annual student hackathon, where students come together from all over the UK to build creative tech projects. Hardware projects are a big part of what makes DurHack so exciting - there is something particularly special about seeing an idea turn into a real, working device. RS is a global supplier of electronics and engineering components that supports students and professionals with the tools they need to build and experiment. For DurHack X, RS played an integral role in making that possible for our hackers.

How Hardware Sponsorship Enables Inclusion

For many students, hardware hacks can feel intimidating or be too expensive. Backing from RS allowed us to launch a Hardware Library to give everyone the chance to try something hands-on. A lot of teams told us that without this support, they would not have attempted a hardware project at all.

Support like this does more than make projects easier. It helps create a space where creativity feels possible for everyone from a variety of backgrounds and skill levels. This sense of inclusivity is what makes hackathons like DurHack special and we are extremely grateful to RS for helping us achieve this.

When the tools are there, the ideas get bolder.

As our hardware sponsor, RS supplied the components and equipment that teams relied on throughout the weekend. Microcontrollers, sensors, prototyping tools and other essentials were all available from the RS Hardware Library. This meant participants could focus on building and experimenting instead of worrying about missing parts or the reliability of gear.

At DurHack X, teams put together a wide range of creative hardware hacks that blended AI, electronics and clever problem solving. One group, Niche Machine, built a 3D-printed crystal ball that predicts which songs are about to trend using TikTok data - earning them G-Research’s Prize. Another project that stood out was Smart Tongs, a pair of sensored kitchen tongs with an LCD screen for real-time safety information, which won Hackathon UK’s Hackiest Hack. The team behind 3rd Eye built a smart camera that follows your head movements and describes what it sees in simple language, using a laptop to track your face and a Raspberry Pi to move the camera and process the video. There was even an Animated Debug Duck, a Raspberry Pi–powered version of the classic rubber duck that uses simple machine-learning models to support programmers like an interactive assistant. Each project came with its own hurdles, but the teams pushed through and produced highly inventive, fully working prototypes that showed just how fun and accessible hardware hacking can be.

Beyond DurHack: Hardware That Keeps on Building

DurHack X’s theme was Legacy, and one of the ways the event will continue to support technology sustainably into the future is the donation of the hardware provided by RS to Durham Robotics. Weekly sessions in electronics, CAD and 3D printing give students the chance to learn new skills and apply them to long-term projects, with plenty of tools and guidance available. It’s a space where members can keep experimenting, building and improving their hardware projects well beyond the hackathon weekend. By reusing components and extending the lifespan of hardware introduced at DurHack, the society also encourages more resource-conscious and sustainable engineering practices, continuing our legacy of sustainability.

The use cases of neural networks are growing at an astounding rate. In this post, we will be looking into the inner workings of Neural Networks and how they can be used to build an Image Classification application in Python.

What is a Neural Network?

At their core, neural networks recognise patterns. They are built from simple units, called “neurons’, organised in layers. Each neuron performs small calculations and passes its output to the next layer.

The first layer in a neural network is called the “input layer”, this layer takes in the raw data (for us this will be RGB pixel information). Hidden layers then transform that information, ultimately trying to learn patterns and features from the data. Finally, the “output layer” produces a prediction (for us this prediction will be the name of the class that the image belongs to).

To train a neural network, we show it a very large number of labelled examples, our dataset. We measure how far the predictions are from the correct answer (this is called the “loss”) and adjust the connections between neurons to hopefully decrease the average loss, resulting in a more accurate neural network.

What Is a Neural Network? | IBM

Preparation

We will need to install certain python packages before we begin. These include: PyTorch, Pandas, NumPy and SkLearn

Install these packages by opening command line and, in your project repository, running:

pip install torch pandas scikit-learn numpy

Once you have created a new python file, we need to import all of the packages that we have just installed, so that we are able to use them within this project. As well as importing these packages, we will also be importing specific functions and classes from these packages.

import torch
from torchvision import transforms
from torch.utils.data import Dataset, DataLoader
import pandas as pd
import torchvision.transforms as transforms
import numpy as np
import os
from sklearn.model_selection import train_test_split
import torch.nn as nn
import torch
import torch.optim as optim
import torch.nn.functional as F
from PIL import Image
from sklearn.metrics import precision_score, recall_score, f1_score

Choosing a dataset

Here is where the fun starts!

For this project, you can either download an existing dataset from online or go one step further and build a custom dataset!

If you choose to work with an existing dataset, some excellent datasets are listed below:

MNIST — contains 60,000 training images of handwritten digits 0–9

mnist | TensorFlow Datasets

CIFAR-10 — contains 5,000 training images per class (10 classes). Classes consists of animals and everyday items (airplane, cat, horse, truck etc…)

cifar10 | TensorFlow Datasets

CIFAR-100 — similar structure to CIFAR-10, yet contains training images for 100 classes, grouped into 20 superclasses

cifar100 | TensorFlow Datasets

If you choose to create a custom dataset, you will need to source both training and testing photos of each classification (e.g. rock, paper, scissors). To reduce the amount of photos needed, I advise you choose a few simple classes, examples could include:

• Pen, pencil
• Different keyboard keys
• Facial expressions
• Cups, bottles
• Images taken inside, images taken outside
• Hand gestures
• Different fabrics
• Rock, paper, scissors

The more complex classifications you aim to use, the larger your dataset will need to be! To make the dataset effective, despite a limited size, consider the tips listed below.

• Keep the background simple, if applicable
• Use good lighting
• Ensure the classes look visually different and are easily distinguishable
• Keep the number of photos per class roughly the same
• Capture different angles of each class
• Use the same pixel dimensions for every image

While collecting these images, all images of each classification should be stored in a separate folder, within a dataset folder. The name of each sub folder should be the name of each classification.

Creating our transform object

Before we begin loading our images, it is important that we initialise our transform object. This will scale the RGB values in our photos to a range of [-1,1] instead of [0,255]. This is incredibly useful as neural networks converge faster when their input is zero-centered. We will use this transform object later in our project for this reason.

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

Loading images for training

It is now time to load our images! We need to define the path to the folder containing our images. This folder should contain individual sub-folders for each class of images, as previously explained.

We then define a list for our images, as well as a list of labels. This means that the first label will be the name of the classification of the first image, second label will be the name of the classification of the second image, etc. The example below shows “Rock”, ”Paper”, ”Scissors” being used, however, this should be the list of titles of the classifications you are using (and must match the names of your sub-folders)!

train_data_path = ".../dataset" # Path to your dataset

image_list = []
label_list = []

class_list_ = ["Rock","Paper","Scissors"] # Our list of classifications

for category in class_list_:
    for image in os.listdir(f"{train_data_path}{category}"):
        image_list.append(f"{train_data_path}{category}/{image}")
        label_list.append(f"{category}")

Define the data frame

We now need to define the data frame that our neural network will use to train. To do this, we use the image_list and label_list from earlier.

df = pd.DataFrame()

df["image"] = image_list
df["label"] = label_list

Split the dataset

Our dataset needs to be split into two sections, images to be used for training and images to be used for testing. We can define the ratio that this split will follow.

• TIP: Once you have trained your initial model, you can try adjusting this ratio to see its affect on accuracy!

ratio = 0.20 #20% of data will be for testing

train_df, test_df = train_test_split(df, test_size=ratio, stratify=df["label"], random_state=42)

Augmenting data

Larger datasets can lead to higher levels of accuracy! To make use of this fact, we are going to transform our relatively small data set into a HUGE dataset (without the need to manually collect more images)!

Here, we are going to first define the image size we want to normalise our images to. Using a smaller number will pixelate the images before they are used for training, this removes some data but will allow us to train our model a lot quicker.

We the transform each image in both our training ad testing sets into multiple images, applying various transformations. These transformations could include altering any combination of: brightness, contrast, rotation, zoom, saturation etc. This simulates a much larger dataset than we previously had.

image_size = 28

training_transform = transforms.Compose([transforms.Resize((image_size, image_size)),
                                            transforms.RandomRotation(10),
                                             transforms.ToTensor(),
                                         transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])
test_transform = transforms.Compose([transforms.Resize((image_size, image_size)),
                                             transforms.ToTensor(),
                                     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])])

Custom Training Data Class

This is where the magic truly begins (and we use our transform object from earlier)! We need to define the class that is used for our training data. First, we define BATCH_SIZE, this determines the amount of images processed in each batch of training. Again, feel free to experiment with adjusting the batch size, observing how this can affect accuracy.

Once we have defined our class, we use it to define our train/ test data object and data loaders.

BATCH_SIZE = 10

class CustomTrainingData(Dataset):
    def __init__(self, csv_df, class_list, transform=None):
        self.df = csv_df
        self.transform = transform
        self.class_list = class_list
    def __len__(self):
        return self.df.shape[0]
    def __getitem__(self, index):
        try:
            image_path = self.df.iloc[index]["image"]
            image = Image.open(image_path).convert('RGB')
        except Exception as e:
            return self.__getitem__((index + 1) % len(self.df)) 
        label = self.class_list.index(self.df.iloc[index]["label"])
        if self.transform:
            image = self.transform(image)
        return image, label
    
train_data_object = CustomTrainingData(train_df, class_list_, training_transform)
test_data_object = CustomTrainingData(test_df, class_list_, test_transform)
train_loader = DataLoader(train_data_object, batch_size=BATCH_SIZE, shuffle=True, num_workers=0)
test_loader = DataLoader(test_data_object, batch_size=BATCH_SIZE, shuffle=False, num_workers=0)

Early Stopping and Overfitting

Overfitting can be a major issue when training a neural network. This is when our model begins to “memorise” training data, rather than learning general patterns that can then be applied to unseen data. As a result, our model ends up performing incredibly well on training data, but poorly on unseen/ testing data. As our model trains, overfitting can be detected by looking for big drops in performance and accuracy.

Below is an IBM article exploring overfitting in greater detail, including links to current research on the topic:

What is Overfitting? | IBM

Whilst there are many ways to combat overfitting, we are going to explore early stopping. Early stopping is a technique where we will stop training after detecting a noticable drop in performance on our testing data. To implement this, we define the class below — EarlyStopping. This class keeps track of the accuray for each round of training. If the accuracy does not improve within 3 rounds (defined by patience=3), we stop the training and save the most accurate model!

class EarlyStopping:
    def __init__(self, patience=3, delta=0):
        self.counter = 0
        self.best_model_state = None
        self.patience = patience
        self.delta = delta
        self.best_score = None
        self.early_stop = False

def __call__(self, val_loss, model):
        score = -val_loss
        if self.best_score is None:
            self.best_score = score
            self.best_model_state = model.state_dict()
        elif score < self.best_score + self.delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_score = score
            self.best_model_state = model.state_dict()
            self.counter = 0
    def load_best_model(self, model):
        model.load_state_dict(self.best_model_state)

Neural Network Structure

This is core of our project — this is where we define HOW data travels through our neural network. We do this by defining the types and combinations of layers we are using.

There are many types of layers that each serve a unique purpose. These layers work together to pass data through the neural network in each round of training, hopefully increasing the accuracy each time.

This GeeksForGeeks article provides a brilliant breakdown of the purpose of different types of layers and is an excellent, informative read…

Layers in Artificial Neural Networks (ANN) - GeeksforGeeks

class ImageClassifier(nn.Module):
    def __init__(self, num_classes, input_size=(image_size, image_size), channels=3): 
        super(ImageClassifier, self).__init__()

        self.input_size = input_size
        self.channels = channels

        # Convolutional layers
        self.conv1 = nn.Conv2d(channels, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)
        self.conv4 = nn.Conv2d(128, 256, kernel_size=3, padding=1)

        # Batch normalization layers
        self.bn1 = nn.BatchNorm2d(32)
        self.bn2 = nn.BatchNorm2d(64)
        self.bn3 = nn.BatchNorm2d(128)
        self.bn4 = nn.BatchNorm2d(256)

        # Max pooling layer
        self.pool = nn.MaxPool2d(2, 2)

        # Dropout layer
        self.dropout = nn.Dropout(0.5)

        # Calculate the size of the flattened features
        self._to_linear = None
        self._calculate_to_linear(input_size)

        # Fully connected layers
        self.fc1 = nn.Linear(self._to_linear, 512)
        self.fc2 = nn.Linear(512, num_classes)
        
    def _calculate_to_linear(self, input_size):
        # This function calculates the size of the flattened features
        x = torch.randn(1, self.channels, *input_size)
        self.conv_forward(x)

    def conv_forward(self, x):
        x = self.pool(F.relu(self.bn1(self.conv1(x))))
        x = self.pool(F.relu(self.bn2(self.conv2(x))))
        x = self.pool(F.relu(self.bn3(self.conv3(x))))
        x = self.pool(F.relu(self.bn4(self.conv4(x))))

        if self._to_linear is None:
            self._to_linear = x[0].shape[0] * x[0].shape[1] * x[0].shape[2]
        return x

    def forward(self, x):
        x = self.conv_forward(x)

        # Flatten the output for the fully connected layer
        x = x.view(-1, self._to_linear)

        # Fully connected layers with ReLU and dropout
        x = self.dropout(F.relu(self.fc1(x)))
        x = self.fc2(x)

        return x

Hyper Parameters and Initialisation

Now that we have defined the layers and structure of our neural network, we need to some more steps before defining our training loop. Below, we define some hyper parameters that are used in this training loop. We define the following:

• Epochs — The number of “rounds” of training
• Learning rate — Determines how quickly the neural network learns from data
• Num Classes — The number of classifications we have (e.g. rock, paper, scissors)
• Input Size — The pixel dimensions of the images we are inputting for training
• Channels — Represents the pieces of data for each pixel (3 for RGB)

We then check if the program has access to a faster processor (e.g. a GPU), and use this if possible.

Finally, we initialise the model using our customised ImageClassifier class from earlier (our neural network structure)!

EPOCHS = 100
LEARNING_RATE = 0.001
NUM_CLASSES = len(class_list_)
INPUT_SIZE = (image_size, image_size)
CHANNELS = 3

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

# INIT MODEL
model = ImageClassifier(NUM_CLASSES, INPUT_SIZE, CHANNELS).to(device)

Loss and Early Stopping

The final step before defining our training loop is to define our loss function and implement or early stopping class from earlier. The loss function is the metric that early stopping will use to decide if our model is making progress or should be halted.

# LOSS FUNCTION
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)

early_stopping = EarlyStopping()

The Training Loop

We have finally reached the point where we can define the loop that will be training our model, bringing together all of our hard work so far! A lot is happening here but below is a summary of each step that this code takes in each epoch of training.

1. model.train() passes data through the model, attempting to learn patterns to improve accuracy
2. The loss is calculated for that epoch of training and is printed to the console
3. The model is evaluated for accuracy
4. EarlyStopping decides whether the model is making progress or should be halted.
5. The metrics that describe the current accuracy and performance of the model are calculated and printed to the console.

Once the training loop ends — meaning either 100 epochs have run or early stopping has halted the training — the program lets us know by printing “Training finished!” to the console.

# Training loop
for epoch in range(EPOCHS):
    model.train()
    running_loss = 0.0
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()
        outputs = model(images)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f'Epoch [{epoch+1}/{EPOCHS}], Loss: {running_loss/len(train_loader):.4f}')
    
    # Validation
    model.eval()
    all_predictions = []
    all_labels = []
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            all_predictions.extend(predicted.cpu().numpy())
            all_labels.extend(labels.cpu().numpy())
        early_stopping(running_loss, model)
        if early_stopping.early_stop:
            print("Early stopping")
            break
    early_stopping.load_best_model(model)
    
    # Calculate metrics
    accuracy = 100 * sum(np.array(all_predictions) == np.array(all_labels)) / len(all_labels)
    precision = precision_score(all_labels, all_predictions, average='weighted')
    recall = recall_score(all_labels, all_predictions, average='weighted')
    f1 = f1_score(all_labels, all_predictions, average='weighted')

    # Print metrics
    print(f'Epoch [{epoch+1}/{EPOCHS}]')
    print(f'Accuracy on test set: {accuracy:.2f}%')
    print(f'Precision: {precision:.4f}')
    print(f'Recall: {recall:.4f}')
    print(f'F1 Score: {f1:.4f}')

print('Training finished!')

Saving the Model

Congrats!! You have succesfully built a neural network in python that classifies images! Now we simply save the model and then it can be used to predict the classification of new images.

# Save the model
torch.save(model.state_dict(), 'classifier.pth')

Making Predictions — The Result!

Finally, our hard work has paid off! In a new file, we can use the below code to use our model to make predictions on new images. We have successfully built an image classification neural network, which can now be incorprated into larger projects. Well done!

# LOAD THE MODEL

model = ImageClassifier(num_classes=3, input_size=(128, 128))
model.load_state_dict(torch.load('classifier.pth'))
model.eval()  # Evaluation Mode

# PREPARE THE IMAGE

img = Image.open('test.jpg')  # Load a new, unseen image from your file system

transform = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor()
])
image_tensor = transform(img).unsqueeze(0)

# MAKE PREDICTION

with torch.no_grad():
    outputs = model(image_tensor)
    _, predicted = torch.max(outputs, 1)
    prediction = class_names[predicted.item()]

print(f"Predicted class: {prediction}") # Outputs the predicted classification of the unseen image

Written by Oscar Ryley

Contents

• Why Godot?
• Getting Started
• Creating your Environment
• Get Moving in Godot!
• Troubleshooting your Project
• Game Development Inspiration

Why Pick Godot for Game Development?

Godot is a free, open-source game engine that can be used to make 2D and 3D games and experiences; it has risen in popularity since the removal of support for Adobe Flash at the beginning of 2021 and the Unity payment change announced in September 2023 that would charge creators per installation of their games.

Godot is a wonderful resource for someone wanting to get into Game Development; it has actively updated documentation and a growing number of success stories, including ‘Brotato’ which was nominated for the Steam Award for “Best Steam Deck Game” in 2023.

If you want to pick up Game Development for a Hackathon or learn more about it through a Hackathon project I would highly recommend it. Godot is great for beginners and professionals alike, keep reading to learn more about how to get started with Godot and start thinking about what game you’re going to make.

It is clear from this Chart that someone starting in Independent Game Development would choose to learn the Godot Game Engine.

Do you need to have lots of Programming Experience to get started with Godot?

Whilst Godot isn’t one of the few no/low code platforms (eg. Scratch) for Game development, it is very accessible for first time programmers.

And if you have programming experience, it’s still a fun challenge.

Godot is interesting in the fact that it uses its own, custom-built, programming language called GDScript. This is a Pythonic Language that incorporates the Object-Oriented nature of C# for the necessity of how Game Design Works.

If you have any previous knowledge in Python, or in Object-Oriented Programming (in C# or otherwise) then GDScript will look quite familiar to you. If you don’t, or you’d like to start with a refresher, here are some resources for both Python and C#.

GDScript

The Basics of GDScript can be found on the following page of the documentation. This Example syntax is a great start to begin understanding how your program code will look in Godot’s Scripts and for each Node.

If you don’t feel like having to learn a new language for your project, you can develop Godot Games using C#, but I would recommend giving GDScript a chance before you do.

Getting started with Godot

You can download the latest version of Godot from their website here: https://godotengine.org/

On this site you can also find examples of projects made by the Godot community and the latest updates about how to use and what is in the current version of Godot.

Your first Godot Project

When you first open Godot, a window that looks like this will open up, start by clicking the button in the top left corner to create a new project!

You’ll then see this window where you can name your new project, choose the folder where the Godot Project will be stored and be able to choose the renderer.

I’d recommend Forward+ or Compatibility for a Desktop Project that can be easily put onto Itch.io so that people can play it for a Hackathon. but you can also make Mobile Apps with Godot as seen below.

I’d recommend keeping the version control as Git, and using GitHub Desktop to save your project and collaborate with your team. You can learn more about GitHub and IDEs with our other HackPack by Kaal Sahele.

Press Create & Edit to Start creating with Godot.

After starting your blank project you’ll be greeted by this screen, your workspace.

You can begin by either making a 2D or a 3D Scene (Click your option on the panel on the left), for more information on how to begin your 2D or 3D Game, go to the 2D vs 3D Section of this HackPack!

When you first start your Scene (2D is this instance) you’ll see a blank project that looks like this:

You can then press the plus button under ‘Scene’ in the top left corner to add new Nodes to the scene. Godot’s system is based on Scenes that are made up of these Nodes and the Scripts which you then attach to them.

Creating your Environment

The big question, do you want to make a 2D or 3D Game?

Godot supports both 2D and 3D game development, so this will be the first thing you’ll need to decide on before you start creating your first game with Godot. Either way, I’d suggest beginning with some basic player movement so that you have something built that you can modify from there.

The following are two tutorials, one for creating your initial scene for 2D and the other for 3D. I’ve then linked to my video workshop/ GitHub on Godot Movement that you can follow at the beginning stages of your project.

2D

The 2D side of Godot is also far more approachable than immediately going into 3D project development. If you’d prefer to use the documentation you can start with the basic 2D Godot game tutorial from the documentation. For now, I’ll walk you through the 2D elements of my Godot Movement tutorial from GitHub/ DurJam workshop.

After starting your main 2D scene, create a seperate scene named ‘Character’ — you’ll need to create an instance of this scene in your main scene.

Add nodes to this scene so that it has the following structure:

• Node2D (‘Character’)
  - CharacterBody2D
  - CollisionShape2D
  - Sprite2D

Go to Project Settings -> Input Map (2nd tab) and add the following actions, pressing the + button to attach keys to them, “Left”, “Right”, “Up”, “Down”. Traditionally WASD or the arrow keys are used, but sometimes the space bar acts as the jump button in 2D platformers, where your up direction is a jump and down is for crouching.

Attach a script to the Character’s CharacterBody2D Node, and add the following GDScript Code:

extends CharacterBody2D

@export var speed = 400
@export var jump_velocity = -800 # Jumping, for projects with gravity
@export var gravity = 2000 # Gravity downward force

func get_input():
 var input_direction = Input.get_vector("Left", "Right", "Up", "Down")
 velocity.x = input_direction.x * speed
 # velocity.y = input_direction.y * speed 
    # Up & Down movement, for projects without gravity

 # Gravity, for projects like 2D platformers
 if (Input.is_action_just_pressed("Jump") 
             or Input.is_action_just_pressed("Forward")) and is_on_floor():
  velocity.y = jump_velocity

func _physics_process(delta):
 # Handling a constant Gravity force
 if not is_on_floor():
  velocity.y += gravity * delta

 get_input()
 move_and_slide()

3D

I personally started with 3D in Godot with “Tutorial: First Person Movement In Godot 4” by the channel ‘Bramwell’. If you’d prefer to use the documentation to design your first 3D movement, you can find that page here. For now, I’ll walk you through the 3D elements of my Godot Movement tutorial from GitHub/ DurJam workshop.

After starting your main 3D scene, create a seperate scene named ‘Character’ — you’ll need to create an instance of this scene in your main scene.

Add nodes to this scene so that it has the following structure:

• Node3D (‘Character’)
  - CharacterBody3D
  - MeshInstance3D
  - CollisionBody3D
  - Node3D (‘Neck’)
  - Camera3D

Go to Project Settings -> Input Map (2nd tab) and add the following actions, pressing the + button to attach keys to them, “Left”, “Right”, “Forward”, “Back”, “Jump”. Traditionally people use WASD and space bar for these, but you can change them depending on what type of game you’re making.

You’ll need a surface in the 3D Scene to walk on, so add a surface mesh, MeshInstance3D with a cubic StaticBody3D & CollisionShape3D to stop your character from falling into the void. Use the following structure:

• MeshInstance3D
  - StaticBody3D
  - CollisionShape3D

Attach a script to the Character’s CharacterBody3D Node, and add the following GDScript Code:

extends CharacterBody3D

const speed = 7.0
const jump_velocity = 5.0
var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")


@onready var neck := $Node3D
@onready var camera := $Node3D/Camera3D

func _unhandled_input(event: InputEvent) -> void:
 if event is InputEventMouseButton:
  Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

 elif event.is_action_pressed("ui_cancel"):
  Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

 if Input.get_mouse_mode() == Input.MOUSE_MODE_CAPTURED:
  if event is InputEventMouseMotion:
   neck.rotate_y(-event.relative.x * 0.002)
   camera.rotate_x(-event.relative.y * 0.002)
   camera.rotation.x = clamp(camera.rotation.x, deg_to_rad(-90),  
                              deg_to_rad(60))


func _physics_process(delta): 
 if not is_on_floor():
  velocity.y -= gravity * delta

 if Input.is_action_just_pressed("Jump") and is_on_floor():
  velocity.y = jump_velocity

 var input_dir = Input.get_vector("Left", "Right", "Forward", "Back")
 var direction = (neck.transform.basis 
                    * Vector3(input_dir.x, 0, input_dir.y)).normalized()
 if direction:
  velocity.x = direction.x * speed
  velocity.z = direction.z * speed
 else:
  velocity.x = move_toward(velocity.x, 0, speed)
  velocity.z = move_toward(velocity.z, 0, speed)

 move_and_slide()

Get Moving with Godot Workshop

You can check out the full video of the above tutorials here:

All of the necessary code, as well as an archive of the Godot project files for 2D movement, 3D movement, and the Demo game can be found on the GitHub repository:

GitHub - Oscar-Ryley/Get-Moving-with-Godot-Workshop: Godot Workshop for DurJam 2025

Demo Game

You can play the demonstration project from the workshop from your browser on the Itch.io page:

Get Moving with Godot!

The Demo Game implements both 2D and 3D movement, with a 2D and 3D scene that you can toggle between to play different takes on the same game concept.

I sourced my 3D textures from Polyhaven, a great free resource for creating projects quickly at a Hackathon! I’d recommend using this YouTube tutorial on textures and meshes.

Troubleshooting your Godot Project

The Godot documentation is regularly updated for each engine version and is open to public contributions in order to keep it as accurate and up to date as possible.

Like most programming projects, as you work with the Godot Engine you will have questions that relate to how to achieve specific things. When I have done Google searches for some of my specific questions I have found good answers via the following resources:

• Quora (eg. https://www.quora.com/What-are-the-benefits-of-using-the-Godot-game-engine-over-Unity-or-Gamemaker)
• The Godot reddit, r/godot (https://www.reddit.com/r/godot/)
• The Godot Documentation’s Forum (https://forum.godotengine.org/)
• YouTube Tutorials, examples can be found throughout this Hack Pack.

Inspiration

Need help getting inspired for your game? Firstly I would encourage you to think about the kind of games that you enjoy playing. Next, take a look at the following incredibly successful games made with Godot.

Brotato is a top-down run and gun roguelite game developed by Blobfish. You play as a Potato that wields up to 6 weapons and defeats waves of enemies. It sold over a million copies during its early access and was nominated for “Best game on Steam Deck” in the 2023 Steam Awards.

Endoparasitic is a top-down survival horror game where you control your movement with only one arm. You can check out the dev’s YouTube for more Game Development inspiration. An Endoparasitic 2 has also been released that you can have a look at both on itch.io and their channel.

Cruelty Squad is a tactical first person shooter with an extreme low-poly aesthetic (WARNING: This game is not recommended for people with photosensitive epilepsy).

Sonic Colours: Ultimate is a remaster of Sonic Colours (2010). An official Sega property being developed using the open-source Godot Engine.

You can check out the latest releases and Showreels of games made with the Godot Engine on Godot’s showcase page! I’ve also made a few games, currently all created using Godot and available on my Itch.io page.

I’m happy to help! Whether it be Game Dev in Godot, or for other Hackathon projects. So feel free to come and talk to me at DurHack (or any other Hackathon)— Oscar :)

Sections of this Article were originally published as a HackPack for DurHack 2024 on Nov 3, 2024; and as a Tutorial & Workshop for DurJam 2025 on Jun 18, 2025.

Welcome to this guide to sentiment analysis using Python! This is made for beginners and advanced programmers alike, so feel free to grab what you need, or read through the explanations for more help. We’ll go through what you need to set up and building your own sentiment classifier.

The code snippets used here are taken from the Jupyter Notebook version of this tutorial available here.

1. Introduction

What is Sentiment Analysis?

Sentiment analysis is a natural language processing (NLP) technique used to determine whether data is positive, negative, or neutral.

It’s commonly used to understand customer feedback, monitor social media, and analyse survey results.

In this guide, we’ll:

• Clean and prepare text data
• Perform basic sentiment analysis using prebuilt tools
• Build a machine learning model to classify sentiment
• Test it with real and custom data

Let’s get started!

2. Prerequisites

We’ll use the following Python libraries:

• pandas, numpy – for data manipulation
• nltk, TextBlob, or VADER – for NLP tasks
• sklearn – for machine learning
• matplotlib, seaborn, wordcloud – for visualisation

# Environment Setup - if you're working in the Juypter notebook, you'll only need to run this once
!pip install pandas numpy matplotlib seaborn nltk textblob scikit-learn wordcloud

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from wordcloud import WordCloud
import nltk
from textblob import TextBlob
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
#NLTK resources
nltk.download('punkt')
nltk.download('stopwords')

3. Load Dataset

Use the file from the github repo linked above entitled ‘training.1600000.processed.noemoticon.csv’ if you’re just trying to play around with this, but you can always replace it with your data later on!

# this is just a bunch of tweets, but you can replace this with a file path to a csv file containing other data
df = pd.read_csv("training.1600000.processed.noemoticon.csv", encoding='latin1') #NB: the first line of the file should be the header for each row
df.head()

4. Explore the Dataset

We’re checking for missing values in the first line and the second makes a bar chart to see how many data points are positive/negative. Getting a sense of the balance in your data set is important — if you use it to predict or train a model using an unbalanced set, it could skew your results!

For our data set, the sentiment rating works like this: (0 = negative, 2 = neutral, 4 = positive). You should see that there are mostly negative tweets in this dataset.

df.info() #check for missing values
df['sentiment'].value_counts().plot(kind='bar', title=94'Sentiment Distribution') # this produces a bar chart

5. Text Cleaning and Preprocessing

Before we can do any analysis, we have to ‘clean’ the data — remove anything irrelevant. Here, we’re making everything lowercase, removing any links and stemming. Stemming means reducing words to their root form so suffixes like -ing don’t have an unwanted effect on our model.

# Text Cleaning + Preprocessing
import re
from nltk.corpus import stopwords
from nltk.stem import PorterStemmer

stop_words = set(stopwords.words('english'))
stemmer = PorterStemmer()

def clean_text(text):
    text = text.lower()
    text = re.sub(r'http\S+|@\w+|#\w+|[^a-z\s]', '', text)
    tokens = nltk.word_tokenize(text)
    tokens = [stemmer.stem(word) for word in tokens if word not in stop_words]
    return " ".join(tokens)

df['clean_text'] = df['text'].apply(clean_text)
df[['text', 'clean_text']].head()

6. Word Cloud

We can make a Word Cloud to see what words are the most frequent, which can tell us what people are interested in!

7. Sentiment Analysis with TextBlob

TextBlob is a library in python that helps with NLP tasks. In the function below, for each bit of text, TextBlob assigns a polarity score where >0 is positive, <0 is negative and 0 is neutral.

def get_sentiment(text):
    analysis = TextBlob(text)
    if analysis.sentiment.polarity > 0:
        return 'positive'
    elif analysis.sentiment.polarity == 0:
        return 'neutral'
    else:
        return 'negative'

df['blob_sentiment'] = df['text'].apply(get_sentiment)
df[['text', 'blob_sentiment']].head()

8. Machine Learning Based Classifier

We can train an ML model using labelled data.

1. Convert cleaned text into numeric form using TfidfVectorizer
2. Split data into testing/training sets
3. Train a model on the data
4. Evaluate the model

This is useful if we need our program to capture specific patterns from our data and adapt to context.

df['label'] = df['blob_sentiment'].map({'positive': 1, 'neutral': 0,'negative': -1})
X_train, X_test, y_train, y_test = train_test_split(df['clean_text'], df['label'], test_size=0.2, random_state=42)
vectorizer = TfidfVectorizer()
X_train_vec = vectorizer.fit_transform(X_train)
X_test_vec = vectorizer.transform(X_test)
print(X_train_vec.shape)
print(X_test_vec.shape)
model = MultinomialNB()
model.fit(X_train_vec, y_train)
y_pred = model.predict(X_test_vec)

print("Accuracy:", accuracy_score(y_test, y_pred))
print(confusion_matrix(y_test, y_pred))
print(classification_report(y_test, y_pred))

9. Test with Custom Text

def predict_sentiment(text):
    cleaned = clean_text(text)
    vec = vectorizer.transform([cleaned])
    pred = model.predict(vec)[0]
    return "Positive" if pred == 1 else "Negative"

# Try it!
predict_sentiment("I really hate this product, it's terrible!")

💡 Applications of Sentiment Analysis

• 📦 Product Reviews: Understand customer satisfaction
• 💬 Social Media: Monitor public opinion
• 🧠 Market Research: Identify trends
• 🏛️ Politics: Gauge speech or policy reception
• 📰 News: Understand article tone

🧭 Next Steps

• Explore deep learning models like LSTM or BERT
• Try multilingual datasets
• Learn about aspect-based sentiment analysis

Resources:

• https://textblob.readthedocs.io/
• https://github.com/cjhutto/vaderSentiment
• https://ai.stanford.edu/~amaas/data/sentiment/

Picture this:

The time is 23:59 — you have a minute to submit your coursework. You’ve spent months on this coursework, you pushed through the days and battled through the night, but it’s done. All that’s left is to submit.

So we’re just going to submit “Coursework_(final)”….

or was it “Coursework_(final)(final)” ….

or was it “Coursework_(FINAL VERSION SUBMIT THIS ONE)”…

maybe “Coursework_(NO DON’T SUBMIT THAT ONE, SUBMIT THIS ONE)”

But it’s too late. It’s midnight — time is up.

Well, fear not. Those days are over. There’s a bright new dawn on the horizon, and it’s name? Version control. Better yet: version control and software development with GitHub.

1 — Installation

1.1 — Create an account

If you don’t already have a GitHub account, go to GitHub’s website (https://github.com/) and sign up for a free account.

There may be an option to set up a student account but this will ask for verification so the best option for now is to just make a free one and then upgrade it later once you’re familiar with the workings of Git.

1.2 — Install Git

For a Windows

GitHub uses Git for version control. This is what does all the tracking of changes in code and then GitHub is a web-based hosting service to host these Git works. You can’t use GitHub without Git (hence the name).

Download Git from their website: https://git-scm.com/downloads

Then click “Next” on all the pop up pages until it starts installing.

For a Mac

Unfortunately, if you’re on a Mac, you have some extra steps. The easiest way to do this is via homebrew:

Click the link on the website for homebrew:

That will take you to this page:

Copy that line of code.

Then head to your launch pad and search for “terminal”. It will open up a scary looking application, but I promise it’s not scary. Paste that line of code into your terminal and press enter.

When you type in your password, it won’t show the characters being typed but this is for security reasons, it is in fact typing what you put in, so as soon as you type in your password, just press enter.

Run the two lines it tells you to run — first, run line 1, then run line 2. Then you will have successfully installed brew. Hooray — you just installed the thing that lets you install git!

Now that you have brew, you can run these three beautiful words:

And now you sit back and watch it work its beautiful magic and install git!

1.3 — Set Up Git

After installation, configure your Git identity by opening a terminal and entering the following commands:

Make sure you use the username and email that you created your github account with!

2 — Creating Your First Repository

2.1 — Create a New Repository on GitHub

Log in into your GitHub account and find the the “+” in the upper right corner and select “New Repository”:

You’ll be directed to a page that asks you to fill out some information, such as the name of the repo, whether you want it to be private or public etc.

For future reference, if you ever use GitHub for your university projects, always ensure they are private. If they are left public and a student in the future plagiarises off of you, you will be in equal trouble (!!)

2.2 — Clone the Repository

The following is an example of a repo I made. Use your own repo that you just made in the previous step for all of the following.

Note: If you are on Mac, choose SSH instead of HTTPS!

Then you can clone this repo by heading back to your terminal and copying in the following lines of shell script:

As such:

2.3 — Navigate to the Repository

Then use the cd command to navigate to your repository’s directory in your files:

3 — Using your repo from your IDE

3.1 Using Your IDE

IDEs are integrated development environments and, while aren’t crucial, make programming and software development projects so much easier. It’s practically impossible to code without them.

The most commonly used one is VS, which can integrate your GitHub repo to keep track of your changes.

First open VS code and locate your cloned repository and open it by going to:

File >> Open Folder >> (find your folder) >> Select Folder

Then whenever you make edits to files in this cloned repo via the IDE, it will show up via green and red indicators (indicating added lines and deleted lines):

The M here indicates modified. If you add a new file, you would see U for untracked, which means it’s a new file that hasn’t been added to your git space yet:

3.2 — Git Commit

To commit your new code you’ll need to follow the same steps every time:

1 — Make sure you are in the directory of your clond repo

2 — Git add [file name]

3 — Git commit -m [message]

4 — Git push

These changes will register in your repo as such:

You can actually see exactly what changed in a previous commit if you click on it. This is pretty useful as it allows for inspection of what’s changed:

3.3 — Git Branch

When team work becomes the dream work

Say you’re project is a web app, and you have someone working on front end and someone working on back end and you don’t want to mess up the working prototype you have in your main branch. You can start two separate branches for front and backend. This essentially makes a copy of everything in the main branch for you to toy around with without affecting the main branch!

If you want to make changes on your local machine, you can use branches to work on separate features or fixes.

You can create a new branch by:

Alternatively, you can re-clone the repository to your local PC (this only works for very small project — as soon as they become larger, this gets very impractical).

So now your project has the main branch, and the new branch. Once you’ve finished toying around with your version, you can merge back to the main branch.

If you’re working on a branch, any commits made to the main branch will not appear in your branch. It’s very important that when you work on a branch, you don’t work on it for too long so it doesn’t end up to far behind the main branch that it causes conflicts when you try and merge your changes back.

Find more information on branching here..

3.4 — Merging

Once you’ve made changes to your branch/ local copy, you’ll need to merge it back with the main branch. You can do so with:

If you’re only working from the one main branch, you don’t even need to specify the branch name, just use “git merge”.

Then to update your local repository with changes made on GitHub, use

Just ensure you’re in the directory of your repo and type the following command:

You’ll be able to see all the pull requests for a repo by selecting that tab:

Then it’s up to the owner to review and merge these pull requests into the main branch. This can be easily done by clicking the big green button:

If there are bugs in the code that makes it incompatible, it will through a merge conflict error so be weary of this.

Differences between Merge Commits

Those of you with particular eagle eyes will have noticed the different types of merges.A tl:dr way to remember which type of merge to use is the following:

Merge Commit

Your typical commit. Combines all changes from your branch branch-name into main, resulting in a new commit on main that represents this merge.

Squash Merge

Suppose you have a feature branch (feature-y) with 15 commits. When you squash merge into main, those 15 commits will be combined into a single commit and added to main. Use when you want to simplify the commit history and don’t care about traceability.

Rebase and Merge

Useful when you have a branch (feature-z) that is behind main by several commits. Rebasing updates the branch feature-z so that its base matches the latest state of main. Once rebased, the branch can be merged linearly without a merge commit. Useful when you want to replay your changes on top of the latest main to ensure a clean integration.

🎉🎉 And that’s all the basics — you should be able to hopefully manage a project on it. Congrats! You’re a software developer now :) 🎉🎉

Cool Fun Facts, Tips, Tricks and Advice with using GitHub

GitHub Desktop

If the command line scares you, you’re not alone. You can do everything we covered today on a much more friendly interface called GitHub desktop where rather than writing lines of code to commit, you just click the friendly green button:

Collaboration

GitHub allows for, and actually encourages, collaboration. To work with others on a repository, add them as a collaborator through the repo settings such that everyone can contribute to the development of a project.

Stars & Achievements

For each repository you make, you can collect stars and achievements (which potential employers love to see). These are given by other programmers on GitHub and can be for a range of reasons, even just having a pretty README.md

Profile READMEs

The same way your project can have READMEs, so can your profile. If you want to present yourself via a mini CV, this would be the perfect place to do so.

Adding Tags

Lets you add tags so people can find your project more easily

GitHub Profile Projects

They’re like Trello where you can split your tasks between done, currently doing, and done. Very useful for a hackathon.

And many other cool features :)))

If you get stuck

“terminal”, “repository”, “clone”, “commit”…. — the terminology sticks the more you use it!!.

Have a play around with it and give it a go. If you get stuck, head over to stack overflow or the GitHub help page. They’re incredibly well documented so just type your error into Google and have a look!

If you’re still stuck — come and look for an organiser in the beginner’s help area, or just around the TLC if you get stuck at any point in the hackathon — we’ll face the error messages together!

Happy hacking!

!! BONUS — Additional Video Content !!

Originally Published as a HackPack for DurHack 2024 on Oct 30, 2024, with video workshop recorded for DurJam 2025 on Jun 11, 2025

Hi DurHackers! So you want to make a machine learn, but don’t know where to start? Fear not, follow along with this hackpack to get started and if you come across any difficulties, head along to the beginner’s drop in area or the helpdesk to get some help, or find an organiser/volunteer who can help!

Purpose of this HackPack

This guide aims to provide beginners with practical steps to create machine learning models using popular libraries like TensorFlow and PyTorch. It focuses on hands-on expereince without diving deeply into theoretical concepts.

For more about the underlying theory, visit the resources at the bottom of this hackpack.

We’re going to build a DurHack Dino vs Barney classifier!!

To open this guide in CoLab head here:

GitHub - KaalkidanSahele/ML-HackPack

To start, run the following command:

!pip install tensorflow keras matplotlib numpy opencv-python

Installations

We begun by installing the necessary libraries for this project. The key tools include:

• NumPy for numerical operations (https://numpy.org/)
• OpenCV for image manipulation (https://opencv.org/)
• TensorFlow for building neural networks (https://www.tensorflow.org/guide)
• Keras for data augmentation (https://www.tensorflow.org/guide/keras)

Note: if you encounter warnings about floating-point round-off errors or missing GPU drivers, don’t worry! These warning are typical in machine learning tasks and won’t affect the main functionality of the project.

## Pre-Processing Imports

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import pyplot
import os
import cv2
from tqdm import tqdm
import random

## TensorFlow imports
from tqdm import tqdm
from keras.preprocessing.image import ImageDataGenerator

from numpy import expand_dims
from tensorflow.keras.preprocessing.image import load_img
from tensorflow.keras.preprocessing.image import img_to_array
from tensorflow.keras.preprocessing.image import ImageDataGenerator

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Activation, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D
# more info on callbakcs: https://keras.io/callbacks/ 
# model saver is cool too.
from tensorflow.keras.callbacks import TensorBoard
import pickle
import time

Define your categories here for the images you want to classify. In this HackPack, we’re differentiating between two variants of a purple dinosaur — Barney, and the DurHack Dino.

classes = ["dino", "barney"]
data_directory = 'data'
img_size = 150  # Resize images to uniform size for model input

def load_and_show_image(dino_barney_class, img_path):    
    img_array = cv2.imread(img_path) 
    # visualise the images so we can see if it's all right!
    plt.imshow(img_array) 
    plt.show()

def process_class_images(dino_barney_class):
    category_path = os.path.join(data_directory, dino_barney_class)
    for img_name in os.listdir(category_path):
        img_path = os.path.join(category_path, img_name)
        load_and_show_image(dino_barney_class, img_path)
        break  
        # we break here because we only want to see one image of each class

def visualize_images():
    for dino_barney_class in classes:
        process_class_images(dino_barney_class)

# call the visualization function
visualize_images()

Data Augmentation

Data augmentation is a technique used to artifically expand the size of a dataset by applying transformations (such as rotations, flips, or zooms). This helps prevent overfitting by allowing the model to generalise better.

Here, we’re going to augment our data!

Dino Data Augmentation:

data_directory = 'data'
max_augmentations = 750

def augment_image(image_path, datagen, save_dir, 
                  prefix, max_augmentations):
    img = load_img(image_path)  # Load image
    data = img_to_array(img)  # Convert to array
    samples = expand_dims(data, 0)  # Expand dimensions
    it = datagen.flow(samples, batch_size=1, save_to_dir=save_dir, 
save_prefix=prefix, save_format='jpg')

    # generate and save augmented images
    for i, batch in enumerate(it):
        if i >= max_augmentations:
            break
            
## now we use the function we just defined to augment all our images and 
## make our dataset!

def augment_images_in_category(category, datadir, augmented_dir, 
img_extension , max_augmentations):
    image_dir = os.path.join(datadir, category)
    my_images = os.listdir(image_dir)

    # Create the data generator
    datagen = ImageDataGenerator(rotation_range=90, horizontal_flip=True)  

    for image_name in my_images:
        # check for correct file extension
        if image_name.endswith(f'.{img_extension}'): 
            image_path = os.path.join(image_dir, image_name)
            augment_image(image_path, datagen, augmented_dir, 
prefix='dr', max_augmentations=max_augmentations)

Dino & Barney data augmentation:

Awesome! We’ve defined what we want our augmentation to do. Let’s run it on our original dino and Barney images (this part may take a while).

from tqdm import tqdm

# dino data augmentation
augmented_data_directory = 'augmented_data/dino'
img_extension = 'jpg'  # if your images are PNGs, put png here!!

# just wrapping the function call in a tqdm loop to display progress
for _ in tqdm(range(max_augmentations), desc="Augmenting Dino Images"):
    augment_images_in_category("dino", data_directory, 
augmented_data_directory, img_extension, 1)

# barney data augmentation
augmented_data_directory_2 = 'augmented_data/barney'
img_extension = 'png'

for _ in tqdm(range(max_augmentations), desc="Augmenting Barney Images"):
    augment_images_in_category("barney", data_directory, 
augmented_data_directory_2, img_extension, 1)

Data Pre-processing

Data preprocessing ensures that the input data is correctly formatted for model training. This step includes resizing images and converting them into arrays for easier manipulation by the model.

The following code processess both categories (dino and barney), resizes the images, and assigns each image a class label, where 0 is for dino, and 1 for Barney.

We also shuffle the data to ensure that the model doesn’t see all images from one class at once, which could bias training.

data_directory = "augmented_data"
training_data = []

#read and resize images to specified size for uniformity
def process_image(image_path, img_size):
    try:
        img_array = cv2.imread(image_path, cv2.IMREAD_COLOR)  
        resized_array = cv2.resize(img_array, (img_size, img_size))  
        return resized_array
    except Exception as e:
        print(f"Error processing {image_path}: {e}")  # Handle errors
        return None

#process images in given cateogry and append to training data
def process_category(category, datadir, img_size):
    path = os.path.join(datadir, category)  # path to category folder
    class_num = classes.index(category)  # class index for the category
    print(f"Processing category: {category}, class num: {class_num}")

    category_data = []  
    # iterate through images in the category
    for img in tqdm(os.listdir(path)):
        img_path = os.path.join(path, img)
        
        # skip non-image files or hidden directories like 
        # .ipynb_checkpoints
        # Add other valid formats as needed
        if not img.endswith(('.png', '.jpg', '.jpeg')): 
            continue
            
        processed_image = process_image(img_path, img_size)
        if processed_image is not None:
            category_data.append([processed_image, class_num])  

    return category_data

def create_training_data(categories, datadir, img_size):
    training_data = []
    for category in categories:
        category_data = process_category(category, datadir, img_size)
        # add category data to the main list
        training_data.extend(category_data) 
    return training_data

def shuffle_training_data(training_data):
    random.shuffle(training_data)
    return training_data

def display_sample_labels(training_data, num_samples=10):
    print(f"Displaying {num_samples} samples:")
    for sample in training_data[:num_samples]:
        print(f"Category (or class) label: {sample[1]}")

        
training_data = create_training_data(classes, data_directory, img_size)
print(f"In total, we have {len(training_data)} training samples! Nice!")  
training_data = shuffle_training_data(training_data)

# now let's visualise some data to make sure our
# dataset is augmented variations of our original data
display_sample_labels(training_data, num_samples=10)

Helpful Note: Make sure you can see variations of 0 and 1 in the samples, otherwise, it means one of your images aren’t being loaded properly!!

Feature and Label Extraction

We separate the features (X) and labels (y) for training and then use pickle to save the preprocessed data, so it can be easily reloaded for training without needing to process the images.

## putting the data into features and labels using list comprehensions
X, y = zip(*[(features, label) for features, label in training_data])

X = np.array(X).reshape(-1, img_size, img_size, 3)

## saving the data using context managers (with statements)
with open("X.pickle", "wb") as f_X, open("y.pickle", "wb") as f_y:
    pickle.dump(X, f_X)
    pickle.dump(y, f_y)

Visualise your augmented data!

def augment_and_plot(image_path, augmentation_params, num_samples=9):
    # load the image and convert it to a numpy array
    img = load_img(image_path)
    data = img_to_array(img)
    samples = expand_dims(data, 0)
    datagen = ImageDataGenerator(**augmentation_params)
    it = datagen.flow(samples, batch_size=1)

    # generate samples and plot
    fig, axs = pyplot.subplots(3, 3, figsize=(4, 4))
    axs = axs.flatten()
    
    # generate batch of images
    for i in range(num_samples):
        batch = it.next() 
        # convert to unsigned integers for viewing
        image = batch[0].astype('uint8') 
        axs[i].imshow(image)
        # hide axes for clarity
        # if you want the axis, you can comment this line out  
        axs[i].axis('off') 
    pyplot.tight_layout()
    pyplot.show()
# pick a random image from the ones you 
# generated when you were augmenting data
image_path = 'augmented_data/dino/dr_0_12.jpg'
augmentation_params = {'rotation_range': 90, 'horizontal_flip': True}
augment_and_plot(image_path, augmentation_params)

Model Architecture

We are using a convolutional neural network (CNN), which is ideal for image classification tasks. The model is designed with three convolutional layers and one dense layer for binary classification.

This CNN model is optimised for binary classification since we’re classifying images into two categories: Barney vs. DurHack Dino.

The TensorBoard callback is used for real-time monitoring of the model’s performance.

def load_data(pickle_files):
    data = []
    for file in pickle_files:
        with open(file, "rb") as f:
            data.append(pickle.load(f))
    return data

pickle_files = ["X.pickle", "y.pickle"]

X, y = load_data(pickle_files)
X = np.array(X)
y = np.array(y)

dense_layers = [0]
layer_sizes = [64]
conv_layers = [3]

## source - https://raihanrnj.medium.com/deep-learning-simple-image-
## classification-using-convolutional-neural-network-dog-and-cat
## -8c99aef29e8

for dense_layer in dense_layers:
    for layer_size in layer_sizes:
        for conv_layer in conv_layers:
            NAME = "{}-conv-{}-nodes-{}-dense-{}".format(conv_layer, 
layer_size, dense_layer, int(time.time()))
            print(NAME)

            model = Sequential()

            model.add(Conv2D(layer_size, (3, 3), input_shape=X.shape[1:]))
            model.add(Activation('relu'))
            model.add(MaxPooling2D(pool_size=(2, 2)))

            for l in range(conv_layer-1):
                model.add(Conv2D(layer_size, (3, 3)))
                model.add(Activation('relu'))
                model.add(MaxPooling2D(pool_size=(2, 2)))

            model.add(Flatten())

            for _ in range(dense_layer):
                model.add(Dense(layer_size))
                model.add(Activation('relu'))

            model.add(Dense(1))
            model.add(Activation('sigmoid'))

            tensorboard = TensorBoard(log_dir="logs/{}".format(NAME))

            model.compile(loss='binary_crossentropy',
                          optimizer='adam',
                          metrics=['accuracy'],
                          )

            model.fit(X, 
                      y,
                      batch_size=32,
                      epochs=25,
                      validation_split=0.3,
                      callbacks=[tensorboard])

Take a look at your model architecture!

model.summary()

Example model architecture:

Our model has convolutional layers conv2d_12, conv2d_13, conv2d_14 activation layers, ReLU, to help learn complex patterns, max pooling layers, MaxPooling2D, to rereduce spatial dimensions to down-sample the feature maps and reduce computational loads, flatten layers to flatern the vectors, and a dense layer .

So we have a fairly complex model which can capture intricate features. This, alongside a sufficiently large dataset can classify images rather well!

Helpful Note: We use accuracy as our performance metric, but take a look into some other performance metrics to really be sure your model works well.

model.save('Dino-Barney-CNN.model')

Making Predictions

In a new file, we’re now going to test our classification model by testing out whether it’s able to correctly classify some newly augmented images!

import cv2
import tensorflow as tf

class_category = ["Dino", "Barney"]
model = tf.keras.models.load_model('Dino-Barney-CNN.model')

IMG_SIZE = 150  # Target image size

# Modify this list according to your actual classes
class_category = ['Dino', 'Barney'] 

def prepare_image(filepath):
    img_array = cv2.imread(filepath)  # Load the image
    # Resize to expected dimensions
    resized_array = cv2.resize(img_array, (IMG_SIZE, IMG_SIZE))
    # Reshape for model input 
    return resized_array.reshape(-1, IMG_SIZE, IMG_SIZE, 3) 


def predict_image(filepath):
    prepared_image = prepare_image(filepath)  # Prepare the image
    prediction = model.predict(prepared_image)  # Get prediction
    img_array = cv2.imread(filepath)  # Read the original image for display
    predicted_class = class_category[int(prediction[0][0] > 0.5)]
    print(f"Prediction: {prediction[0][0]}\nClass: {predicted_class}\n")
    plt.imshow(img_array)
    plt.axis('off')
    plt.show()
    
    return prediction

predict_image('Test Images/barney - Copy.jpg')
predict_image('Test Images/durhack dino zoomed.JPG')

Nice! You’ve just built your first image classifier with a CNN!

For further resources, take a look at the following extra materials from 3Blue1Brown and IBM:

What are Convolutional Neural Networks? | IBM

Originally Published as a HackPack for DurHack 2024 on Oct 30, 2024

Last year, I participated in my first hackathon — ever.

DurHack 2024 was an amazing experience: I got to meet (and work with) enthusiastic, excited people, witness the creation of some truly fascinating projects and our team ended up winning 1st place overall!

For what? Oh, just a Computer Vision powered, dinosaur-themed personality quiz. Yeah, not the most serious project. It’s a great story, though, and if you want to find out more about it, read on here.

To sum it up, we used Python’s OpenCV library to recognise the user’s head and detect which way they were moving and used the input as movement to answer our quiz.

Later on in the year, I found that The Crown Estate was advertising a role for ‘Marine Engineering Intern’. I genuinely had no idea what that entailed — I pictured swimming with dolphins, repairing some kind of complicated deep-sea equipment, and then remembered my nautical skills (or lack thereof) would mean that I would probably be closer to ‘sleeping with the fishes’ by the end of my first day. But the description of the role was quite different to what I had imagined: “The Crown Estate is looking for a motivated problem solver who can help create digital solutions for the benefit of the UK’s net zero ambitions.. [to create a] machine-learning project focussed on optimising the use of the seabed.”

In particular, there was one phrase that really stood out to me: “The integration of machine learning will likely involve the practical use of computer vision..”.

Well, I had worked on a project involving Computer Vision, although perhaps it wasn’t the most practical use of it…

And so, I tailored my CV to put ‘Affirmasaurus’ as the second in my list of projects, because it seemed so relevant to the description, but I still wanted the reader to take me seriously.

All this to say, I got the internship.

When I started, I had no idea what I was supposed to be doing. By the end, I had collaboratively developed a unique solution using Computer Vision and Machine Learning aided by Python’s Keras and Sci-Kit libraries to optimise Off-Shore Wind leasing.

The existing system, herein referred to as the ‘Blob Solver’, assisted in deciding where new offshore wind farms should be located by taking
a cluster of seabed and deciding on the
best arrangement to maximise the space being used, following
constraints like how big the cluster is, how far each wind
farm must be from another and could also take a ‘seed number’ (number of desired wind farms) as input. It used an ‘un-informed, semi-exhaustive search’. To find the maximum occupancy, the Blob Solver started with an initial guess and then changed it to increase the occupancy until no further changes could be made. After calculating the maximum occupancy and the resulting arrangement of the wind farms in the cluster accordingly, it started from scratch again with the next cluster. Therefore, any insights learned about what types of arrangements worked best were lost when running it again. As you can imagine, this meant that the Blob Solver had to perform many iterations before finding the right answer.

In fact, a single run took up to 5 minutes, which doesn’t sound like much, but it took approximately 4 days to generate all the training data needed for our project. The goal? Investigate whether or not the application of Computer Vision could make it more efficient.

But what is Computer Vision?

Computer Vision is a specialised field within Machine Learning (which, itself, is a subset of Artificial Intelligence) that focuses on visual data. A very watered down explanation would be ‘teaching computers how to see’.

We used Neural Networks, which are models inspired by the human brain and its neural connections. These consist of an input layer, hidden layers and an output layer. During the training phase of these models, the weights and biases associated with each of the nodes in the hidden layers are tweaked to better reflect the complex relationship between the input and output data.

A diagram showing a Neural Network with one input node, one hidden layer with 3 nodes and an output layer with 2 nodes.

There were two key components of the structure of our model:

1. Convolutional Neural Network: this allowed the model to learn features from the images of the cluster we were using as input. This was done using a convolution kernel that slides across the image, multiplying corresponding elements. This also reduced the size of the image drastically, which meant that not only could the program run quicker, but that the model could make more accurate connections because the ‘irrelevant’ pixels were filtered out.

2. Dense Neural Network: these types of Neural Network are ‘fully connected’ meaning each node in a layer is connected to every node in the next layer. They’re used for making predictions and classification based on feature data from previous convolutional layers.

Results and Impact

Computer Vision enabled the Blob Solver to start with a more educated initial guess: the model was given the cluster, predicted the maximum occupancy and then the Blob Solver tried arrangements that satisfied this prediction.

Ultimately, our final version of the solution achieved a 15% absolute percentage error for occupancy prediction and 6% error for seed prediction. Efficiency was boosted by over 50% as you can see in the image below. The left hand side shows the un-informed Blob Solver’s approach to the problem, which it solved in 9 iterations, while the Computer Vision augmented version on the right only needed 4.

Conclusion

While the project I made at DurHack 2024 wasn’t the most useful, it undeniably helped me develop skills that were invaluable during my internship. My advice to anyone reading this is to sign up for the 10th iteration of DurHack, which is happening on 1st and 2nd November 2025, before it’s too late! It’s a fantastic opportunity to build a project, connections with our sponsors and long-lasting memories.

Hackathons are about more than just coding; they are a direct line to industry leaders. For you, the talented students, our sponsors are not just here to provide prizes and pizza, they are scouting for future interns and employees! Your ability to network is as crucial as your coding skills.

Here’s your ultimate guide to turning those sponsor interactions into real-world opportunities.

1. Pre-Hackathon Preparations

Engaging effectively starts before the hackathon begins.

• Review the sponsor list: Look at every company sponsoring the event, from the title sponsor to event partners. Don’t just look at the logo; click through to their careers page and their “About Us.”
• Identify their tech stack/industry: Which companies use the programming language or framework you love? Which ones are tackling a problem you’re passionate about?
• Formulate your connection with companies: Prepare a concise, one-sentence reason why you’re interested in their specific company. Examples: “I love how your company’s xxx is able to do xxx,” or “Your commitment to xxx really resonated with me!”

2. Make the Most of Workshops and Challenges

Sponsor workshops and challenges are designed to be engagement goldmines. Don’t skip them!

• Go to the source: Workshops are not just free lessons. Attend workshops hosted by companies you are genuinely interested in. This shows commitment and initiative.
• Ask smart questions: Don’t ask a question you could easily Google. Ask questions that show you have thought deeply about their technology or challenge. For example, instead of “What is this API?” ask, “How do you handle rate limiting on this API in a production environment?”
• Stick around: After the main presentation, politely approach the presenter. Thank them, introduce yourself, and maybe briefly mention how you might integrate their tech into your hackathon project!
• Tackle the sponsor’s challenges: If a sponsor you are interested in offers a specific challenge, use it as a framework for your project. This is a direct portfolio piece for them!
• Incorporate their tech: Even if you do not fully solve their main challenge, integrating one of their tools into your main hackathon project is a way to get their attention. It shows you are proactive and capable of learning new tools quickly.

3. The Sponsor Booth: Your One-on-One Moment

The physical booth is where you transition from a general attendee to a potential candidate.

• Keep it brief: Representatives have many people to talk to. Have a 30-second elevator pitch ready so they can easily remember you: your name, your year/major, one impressive project (or your current hackathon idea), and why you’re interested in their company.
• Example: “Hi, I’m Alex, a year 2 student studying Computer Science. I’m currently building XXX for this hack. I’ve been following your work in AI ethics and would love to know more about internship opportunities in your research division.”
• Ask targeted questions: Use the research you did in step 1.
• For Internship Insights: “What is the most common project an intern on your engineering team would work on?”
• For Company Culture: “What is a major development challenge your team is currently tackling, and how does your company philosophy guide that solution?”
• Exchange contacts: If the conversation goes well, politely ask for a business card or if you can connect on LinkedIn. Don’t just grab a card — ask! “Would it be alright if I connected with you on LinkedIn to follow up on this conversation?”

4. The Final Project Presentation

This is your last, and possibly best, chance to impress the technical representatives, so tailor your presentation if you ever get your chance to be on stage!

• Acknowledge their contribution: If you used a company’s tech, explicitly thank the sponsor and call out how their tool made your project better or possible.
• Focus on the “why”: Explain the problem, your solution, and the potential impact. If your solution aligns with a social or technical challenge the sponsor is known for (e.g. scalability, data security), emphasise that alignment.

Treat every interaction with a sponsor as a professional conversation. Be prepared, be polite, and most importantly, be genuine. The connections you make during that weekend could easily lead to your first great internship! Good luck, and happy hacking!

Hackathons are the perfect place to turn big ideas into working prototypes. From IoT devices, to robotics, to wearable tech, combining hardware with coding unlocks a whole new level of creativity.

If you’re thinking of tackling a hardware hack at your next event, here are some tips to help you prepare and make the most of your time:

1. Check the Rules Beforehand

Every hackathon is different when it comes to preparation. Remember to check the rules of each event carefully so that you are working within boundaries.

At DurHack, you are not allowed to start your project in advance, which means no coding or assembly before the hack begins.

What you can do:

• Brainstorm ideas and possible project directions.
• Research tools, frameworks, and hardware you might want to use.

Pro tip: Be prepared to stay flexible! Sometimes the best hackathon projects come from a surprise challenge announced on the day.

2. Come prepared

Time flies during a 24-hour sprint, so set yourself up for success:

• Pack your essentials: chargers, adaptors, spare batteries, and anything you can’t hack without (maybe your emotional support animal: for us, it’s our DurHack Dino!)
• Have a programmable robot or cool set of sensors? Bring any specific hardware you’re keen to use!
• Bring a couple of project ideas. Just enough to give you a head start.

3. Make the most of what’s provided!

Make the most of the hardware available at your hackathon!

This year DurHack is excited to be able to provide an RS Hardware Library. You’ll have access to an amazing range of devices and equipment that you can make use of, including Raspberry Pis and Arduinos. We’d like to thank RS for their sponsorship of this Library, and our event!

4. Connect with Others

Hardware hacks often need diverse skills: coding, electronics, design, and even storytelling. Don’t be shy to reach out!

• Ask mentors for guidance. They can often point you to the right hardwares or save you from troubleshooting headaches.
• Join communities like the RS Student Community to share experiences and collaborate with your peers.

5. Enjoy the Experience

Hardware hacks can be challenging, but they’re also some of the most rewarding ones. Take the opportunity to try out different types of hardwares, push yourself creatively, and don’t forget to have fun with your teammates!