Articles on jwhogg

Edge AI: ML inference in the browser

Tue, 18 Jun 2024 00:00:00 +0000

Recently, I stumbled across a guy who ported OpenAI’s Whisper model into c++, in various sizes, allowing the model to be run on-device, at impressive speed.

I went down a rabbit-hole, and found a whole family of popular models that had been ported to work on-device, from the browser:

yolo in the browser

Word2Vec Overview

Wed, 12 Jun 2024 00:00:00 +0000

In this article we will introduce the context surrounding word2vec, including the motivation for distributed word embeddings, how the Continious Bag-of-Words and Skip-gram algorithms work, and the advancements since the original paper was released. We will also go into the training of the neural network, so it is assumed you have some knowledge on this.

These 2 papers introduced word2vec to the world back in 2013:

paper1	paper2
[Word2Vec Paper 1](https://arxiv.org/pdf/1301.3781)- introducing CBOW and Skip-Gram	[Word2Vec Paper 2](https://arxiv.org/pdf/1310.4546)- Performance Improvements

Motivation

For many NLP tasks, we need to learn on data which can’t be easily represented numerically. For example, let’s look at the popular IMDB dataset, which gives reviews in one column, and a binary sentiment label in the next:

Implementing Word2Vec in python

Fri, 31 May 2024 17:25:04 +0100

We will be implementing the Neural Network for the Continuous Bag of Words (CBOW) from the word2vec paper. This article assumes you have a good understanding of the high-level of word2vec. This will be covered in coming articles also.

Our goal is to train with sample pairs $(y,X)$, where $y$ is the target word, and $X$ is one of the context words from within the window.

Neural Network for Word2Vec

Fine-tuning a pre-trained model from HuggingFace

Fri, 24 May 2024 13:29:04 +0100

We will be using a 🤗 HuggingFace model (GPT-2 Medium)

📙Jupyter Notebook Link

Create train/test split for custom dataset

(can use sklearn for this)

Get the model tokeniser

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("your-model-here") #eg "bert-base-cased"

Create encodings for train/test using tokeniser

def tokenize_function(examples):
 return tokenizer(examples["text"], padding="max_length", truncation=True)

tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)
# where raw_datasets is a dict with train/dev/test

we need padding as the inputs must fit the models input even if they are too short

Create small datasets for development

small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(1000)) 
small_eval_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(1000)) 
full_train_dataset = tokenized_datasets["train"]
full_eval_dataset = tokenized_datasets["test"]

use the full ones once you have all params figured out and want to do the final training

Import model

from transformers import GPT2Tokenizer, GPT2Model

tokenizer = GPT2Tokenizer.from_pretrained('gpt2-medium')
model = GPT2Model.from_pretrained('gpt2-medium')

Training

Transformers has a Trainer class that can speed up training of models, and does a lot of the work for us
Trainer is defined as a dict of arguments and a compute_metrics function, but first we need to define these:

Training args:

from transformers import TrainingArguments

training_args = TrainingArguments("test_trainer")
#use just default args to start with
#add arg: evaluation_strategy="epoch" to report metrics every epoch

Configure training metrics

Trainer can take a compute_metrics() function, which takes predictions and labels (in a tuple), and returns a dict with metric names and values
we can use the Datasets library to get access to common metrics
- ‘accuracy’ is one of these

import numpy as np
from datasets import load_metric

metric = load_metric("accuracy")

def compute_metrics(eval_pred):
 logits, labels = eval_pred #splitting tuple into the output logits and their labels
 predictions = np.argmax(logits, axis=-1) #convert logits into predictions
 return metric.compute(predictions=predictions, references=labels) #calc predict accuracy

Define Trainer

from Transformers import Trainer

trainer = Trainer(
 model=model,
 args=training_args,
 train_dataset=small_train_dataset,
 eval_dataset=small_eval_dataset,
 compute_metrics=compute_metrics,
)

Train and Evaluate:

trainer.train()
trainer.evaluate()

We are now done! the training args or dataset can be tweaked to try to improve performance

Notes on: Applying for jobs within tech/ML

Thu, 23 May 2024 13:07:04 +0100

A collection of notes about articles I found useful when applying for jobs. Hopefully these can be of some use to others also.

Summary of this article / video

Intro

can split getting an ML job into 2 steps:
1. Getting ML skills
  - building projects
  - contributing to OS
  - reading technical info
2. Marketing ML skills
  - communication
  - interviewing
  - portal creation
  - passing application screening

Strategies:

Make ML jobs come to you by Learning in Public (great article!) Summary: