It is 23rd August today and just like every year, a day later I would be getting texts, calls and random greetings from people who I have probably not talked to in the past 1 year. The celebrations (if you do them) often take the real purpose of birthdays, at least in my opinion, away! “Birthdays are like a second new year” is what could be an alternative title for this post but that wouldn’t have gotten you to read through this maybe.

Slowly growing up one of the things that I have looked forward to on my birthday was writing about how the past year has been, and no it isn’t a summary or check list of things I accomplished, felt proud about and wanted to show off to my present self for motivation. I did that maybe for one or two years but eventually it dawns on you that all of these don’t matter much in reality to introspect over, you will always accomplish newer things, have more fancy stuff to parade about with and strike off increasing amounts of to-do’s from your bucket list (at least in the ideal scenario, you might miss a year or two in between on these and trust me it’s not end of the world) but there is something of far more worth to optimise for and pen down to look back!

How do you think about the world around you? What impacts your thoughts the most? Was there any event in the past year that shaped you as you are now? Did your overall mental state change from a certain emotion to another and what was that inflection point? These are some of the questions that are more important for finding out the real “you” as a person, which automatically makes them harder to answer instantly. This activity almost forces you to sit down peacefully, dwindle down that memory lane of the past year which you in general avoid after those multiple unpleasant memories that still haunt you at times and come out with the actual gold of insights about your nature. The whole journey is quite fun in itself and probably doesn’t need any more reasons for you to get started on it (a similar idea like one of my favourites from the old days - Journey To Ithaka) but I really want you to set out on this voyage and in case you are not convinced yet here are some more:

• In the midst of your gradual recall, you remember a moment whose details faded on with time and you really relished it when it was happening but soon more memories piled up on top of it and you forgot the actual worth of the event. Remember there are a multitude of such reasons that make you grateful for whatever you have received and a conscious effort to write them down leaves you with a satisfied heart.
• People that you haven’t talked to in the recent time but are special for you appear in the focus again and this provides with a nice opportunity to talk again!
• You get to create a chronological record of your thoughts, ideas, impressions and beliefs and how they evolve through time. I visualise this like seeing a potter carve out a jug by slowly giving it shape, except that the jug is your true self, the potter being the environment you are in, the people around you and the events in your life that push you out of your comfort zone, the only difference is there is no correct shape for the jug but only the detailings and clarity of work that sets apart one from another. Wouldn’t this sort of representation in the future be something to look forward to!?
• You can be your own therapist (till a certain extent)! Answering such questions often resolves a lot of un dealt with emotions when you realise that often what you gained overall is more valuable than these tiny hiccups on the way. Personally I’ve had a lot of such realisations with just my meditations and this habit of writing things down
• Stop considering things as trivial, often when we grow personally quite a bit and people have trouble recognising this “new” you it starts to feel that all the work you put in to become this new version was nothing extraordinary and not something to feel happy about. This act of giving words to weird feelings makes you realise this again!

In short, extend your birthdays to something more than just greetings and parties, humans have a clever way of ignoring important aspects of their life just due to this lack of “opportunity” as an excuse, why waste one that you’re naturally getting?

One of the things I’ve really wanted to do this year was being more open and public about a lot of aspects of my life, I’ve been writing a lot and who knows some of it might be helpful to a random person sitting on the other side of the planet. In any case this was an attempt at being more comfortable at this and hopefully it inspires you to close your favourite LLM for a while and write something of your own

P.S - I hope someone gets the context of having View of Delft here.

Recently this tweet of Opus 5 beating a previously unbeaten game (ar25) through the use of seemingly emergent symbolic reasoning has been doing the rounds online, when I came across it, I was instantly reminded about another paper that I read a while back. What they suggest through a cognitive science perspective is representation of the game state, characters, rules, situations etc in VGDL (a symbolic language) and then performing Bayesian inference over the hypothesis space which leads to different learnable problem solving theories, unlike which Opus 5 does task specific symbolic abstractions on the fly depending on the environment.

An obvious question is why should you care and read this? I am pretty sure you hadn’t heard of EMPA before and chances are you probably won’t in the future too unless you stumble across it in some weird royal society issue but the point is you should! The idea is elegant and I am quite sure that all the problems/shortcomings I will describe here are either already resolved to a certain extent or are being worked upon. The results they show in the original paper are enough to reel you in, they compare EMPA with DDQN, Rainbow and even humans on 90 Atari style games, and against Rainbow, EfficientZero etc. over 5 Atari games with 21,000 frames to prove their point that it indeed does learn like humans and not just ends up competitively with them on a benchmark. A follow-up paper of the same demonstrated that the neural activity found by performing an fMRI while the user played these Atari games were consistent with the theories predicted by the model.

Tenenbaum’s lab has the broader manifesto of Building Machines That Learn and Think Like People. Codex does a better job than me with the below visual graphic to explain this programme. To my knowledge, EMPA is the first practical attempt to combine all of these scattered ideas into an interactive agent and a big reason for which I hold it in high regards is the sheer breadth of ideas which it covers up that needed proper formalisation in the field and spawn a plethora of future work with them, albeit just like anything else not perfectly but sets a solid ground for future work to build upon.

Theory based RL?

The main idea behind naming their approach “theory” based reinforcement learning stems from the age old debate of model free vs model based RL, here they specifically draw on cognitive science for inspiration and how humans from their childhood model their environment with its objects and the causal relationships between them in forms of “intuitive theories” which are used to plan future actions. A simple EMPA loop starts with this modelling of symbolic theory consisting of the existing objects, identification of the agent and target from them and which environment state qualifies as a victory or failure. After which it creates the best possible plan for the future action, executes it in the provided environment and updates its theory again. The exploration for the agent is driven by intrinsic motivation of reducing uncertainty about the world through learning new causal rules, suppose if there is no instance of interaction between object class c_i and c_j then it asks the planner to generate the next set of actions to exploit this condition specifically.

All of this formalisation is done through Bayesian inferencing for which it maintains a probability distribution of the possible game theories and updates it constantly after reflection on the consequences of the performed actions. The theory with highest probability is chosen and is used by the planner to simulate the sequence of actions to perform, the best possible sequence is then chosen to be executed in the environment and if the outcome from these differ from the predicted outcome, the planner is run again. I’ll save you from the notations here and hope that you are motivated enough to check out the methodology (and whatever other details I missed) on your own.

On 90 Atari style GVGAI games provided in VGDL, EMPA remains within an order of magnitude of the humans performance on learning efficiency (defined in a metric based on the levels solved) in 79 games and was 1000x more efficient than DDQN in 45 games (another unfair comparison and one of the biggest gaps in the paper.. more on this in gaps)

EMPA on ARC-AGI-3

Classically EMPA uses VGDL to represent the game state and basically everything needed for it to work upon, whereas ARC-AGI-3 provides colored grids instead of predefined symbolic objects, a single action in it can produce multiple frames to change, has a more diverse action space among other differences. To bridge both of these systems together the few changes are done while preserving the essential spirit of the exploration, modelling, planning and action loop:

1. Grid conversion: Each ARC grid was converted into an RGB image through the official provided palette and passed onto EMPA’s object tracker

2. Frame mismatch: With ARC returning multiple frames corresponding to a single action, we select only the final one

3. Action mapping: While each ARC action is represented in keyboard style actions (eg. ACTION1, ACTION2..) we mapped these back to VGDL controls. However both undo and coordinate based clicks are excluded due to representation limitations with VGDL

For each game in the exploration phase the agent was seeded with 225 random commands where each sampled command repeated in four action blocks, reproducing the action-hold behaviour for increasing ease of observation of behaviour. It builds the theory upon this and uses depth=12 (12 move lookup) for planning of actions, the recursive loop for action and updating the theory is run for at most 50 actions.

Here is the overall summary where inferred controller shows if the model could identify the object being controlled by the agent and what kind of input rules does it follow, the rules column portrays the change in initial vs learned rule set and if it could identify the rules for termination of the game:

EMPA fails quite miserably on the four tested ARC-AGI-3 games solving none of them. While investigating the cause, something which appears very clearly is that the porting we applied works and preserves action attribution, animation frames, resets and terminal outcomes. It is able to identify the objects and infer the causal relationships between them. The clearest failure mode identified on interpreting the learned theories post-hoc shows that none of them contained a termination rule. Therefore while local actions were mostly coherent avoiding immediate dangers, without the symbolic representation of what success looked like the planner could not construct long-horizon and goal-directed action sequences.

Some examples adding more detail to the above:

• G50T had a failure mode in the earliest stages of causal relationship learning where it learnt neither the controlled object nor the interaction rules between them which obviously constrained it from learning any further mechanics about the game and making coherent actions.

• WA30 showed a funnier collapse, first it misidentifies the agent as an autonomous “Walker” class object and then instead of learning the correct rule set and goal of picking up a block with the spacebar and putting it back on the desired location it instead learns a different theory altogether. When the pickup causes the block to stop having a separate visual component and hence triggers a change in the symbolic representation of the world, EMPA consequently learns “kill” rules rather than the desired pickup, transport and drop strategy. More on this problem is described below.

Critiques

I feel the best tl;dr one can give for EMPA is cleanly summarized through this quote by Van Gogh:

“Great things are done by a series of small things brought together”

While the main strength of the work lies in bringing together multiple ideas: object tracking, symbolic theories, Bayesian inference, uncertainty-driven exploration, and planning which are pretty generic standalone but the composition of all of them together is what makes EMPA learn relatively complex games with very limited experience. However the most important part with any such task of bridging smaller components up is the way you carry it out. The subtle design choices that are taken in each individual element can compound and amplify the wrong ones easily, which is what we observe here too. On the brighter side, the impact of it was how tuning these entities after setting up the groundwork is a far easier job than rebuilding the entire framework from scratch. Below are few of the questions that would naturally pop up in your mind while reading through the paper and would help in improving it further

1. EMPA has a fixed vocabulary space predefined in its structure which limits it from learning new predicates being encountered while exploration. With a closed and limited concept space there is a huge separation from the initial goal they set out to accomplish i.e “human level learning”, coming back to the example of babies which they provide in the paper, do you think that babies are just supplied with say a 1,000 concepts and all they are doing when put in an unseen situation is figuring out the correct set of permutation and combinations between the known concepts to reach the goal state? Maybe we took the idea of strong inductive biases in humans too seriously.

2. EMPA is proudly described as a model-based RL method but is compared with DDQN (a model-free method) later on, with claims like how DDQN performs 100x and 1000x worse in certain games. Why not include other competitive model based agents under similar inputs and compute?

3. The goal language is very weakly defined as the object class count reaching zero, this is also pretty evident in the results we see on ARC-AGI-3 where it learns 0 termination rules. The whole problem begins with this gap of representation again, an agent in the wild is bound to fail in due time

4. With maximum posterior theory it simulates the actions for a specific theory only, closing the input to other neighbouring probable ones thereby restricting the theory space.

Onto better things..

While going through the blog again and checking resources, I found a direct successor(s) from the same lineage of EMPA, the authors realised this specific gap and replaced the VGDL theories with an LLM that synthesises sort of a world model in python code which captures the rules from newly encountered scenarios and then plans at both a higher level (of goals/subgoals) and lower level (of tasks correlated to achieve these goals, inferred from the synthesised python function again). This is exactly the sort of update I wanted and will maybe run TheoryCoder on ARC-AGI-3 as a fun exercise, however the point of this post is achieved (to highlight a world of cognitive science inspired learning methods) and this can be taken as a fun experiment for you, the ever enthusiastic reader!

P.S. The idea of multiple world models is also pretty neat (taken from the TMLR openreview submission) however I despise the fact that they don’t describe anything about these “tasks”, anyways some suggestions for these tasks are in here!

On a concluding note, a special thank you to:

• Sushrut for spending time and discussing this among many other ideas with me and reading a draft of this post!
• Aman for reading the draft and always being ever so enthusiastic about whatever I’m working on.
• Dhruv and Abhinav for reading through this and looking out to help everytime.

From “never wasting a motivated moment” : recently I read about the concept in a blog by @arb on twt [link] and it made me wonder if a similar event led to me tinkering around and eventually writing this blog, even though at times it gets hard to consciously stick to the idea but recently I have tried to work on fixing this with keeping the side project pipeline as free as possible to at least work on something out of the current heap of ideas instead of doing nothing with them,hence expect more of these random experiments (and some serious ones too) in the near future, moving onto the thoughts/results from the experiments on autoRL.

Setup

The purpose of this experiment is to use the agentic reinforcement training framework for evaluating how different judge models:

1. Score the generated code on different parameters (e.g., accuracy, security, completeness, complexity, among others)
2. The reasons for their strictness/leniency towards a specific model
3. Whether a bias exists in judging out the code that was generated by itself (could adopt a process of randomizing the outputs and then evaluating them)

Even though there were many multi-step setups on which this could have been tested out and would have been probably better than the current task of code generation, it just seemed as a fun thing to optimize and play around with than any other ones.

The temperature is set to 1 for all the runs to be equally creative while generating their outputs and having a sense of variation in all the responses, without getting too deterministic in its approaches and limiting our evaluation for the same.

Another point was about the choice of judges that was done with keeping the thought of including the SOTA and latest models from the big labs and some from the underdog ones while also not making me broke (in this case I was fortunate enough to have cool people come out [goat, goat] to give free credits) with all the token calls from openrouter, the final judges are:

• Mistral 4.2-24b
  
• Gemma 3-27b-it
  
• Hermes 2-pro-llama-3-8b
  
• Deepseek v3-0324
  
• Kimi K-2
  
• Llama 3.3-70b-instruct

Finally moving onto evaluating the performance, the benchmarking was something that seemed vague to figure out since there wasn’t a direct method to do so, going from evaluating from the ruler scores for each epoch with a specific judge, finding its mean and comparing that to the base model with the same judge, to using the final weights of the trained model for manual A/B testing, or on any other open source platforms like deepeval, codejudge, to finally settling on the mean method (this could probably be optimized by building a framework of your own later on).

A Bit More Background on AutoRL and ART Framework

AutoRL → RL without providing any labelled data for the GRPO to train on, instead evaluations are done by another LLM model, RULER generates its scores between 0 and 1, gives feedback and then the base model is trained again to improve its abilities.

For all of these tasks we use ART (Agentic Reinforcement Trainer) by OpenPipe as a helper for RLAIF, the main goal here is to not find “excellent” or “well made” labelled datasets on which we can perform RL but to give a solid and structured prompt for the judge model.

We start with the base model generating its set of training inputs, which are then saved for keeping every run fair and unbiased towards all the models (num_training_inputs=25), they are then divided into groups (num_inp_groups=2) ~ 12.5 groups, this helps in faster computation but also in giving some space/distinction between each problem to inherit some properties present. Now starting with group 1, the model generates 5 candidates each, which are then evaluated by the ruler and used to update the weights for the next epoch, even for a smaller training run of 10 epochs some of the models kind of learnt well to produce meaningful code in the end.

The task description that was generated by GPT-4o is:

You are a professional programmer that can write quality code in various languages. You will be provided with the users text that would be a request for a programming task in natural language, Your goal is to generate a code solution to the programming task given, the code response should be structured in the following XML style tags:

<request>: This tag should wrap the user's original natural language request.

<language>: This tag should specify the programming language used in the code solution (e.g., Python, JavaScript, Java).

<code>: This tag should wrap the generated code block. The code should be well-commented.

For example, if the user's text is "write a python function that calculates the factorial of a number", the output should be:

<request>write a python function that calculates the factorial of a number</request>
<language>Python</language>
<code>
def factorial(n):
   if n < 0:
       raise ValueError("Factorial is not defined for negative numbers.")
   elif n == 0 or n == 1:
       return 1
   else:
       result = 1
       for i in range(2, n + 1):
           result *= i
       return result
</code>

Observations

Though condensing the results in a short format seems really unfair here but I will try to give a general outlook of how things turned out in the end, but just to give a brief idea of how the candidates were generated and the quality of code we will review a log file of a random trajectory with the Mistral 4.2-24b.

GENERATED TASK: Create a REST API endpoint in Node.js Express that handles user login with JWT token generation.

Trajectory-1: SCORE= 0.4 : RULER explanation: This is a very basic implementation. It gets the job done by providing a login endpoint and generating a JWT, but it uses hardcoded credentials which is a major security flaw and lacks any password hashing. It fulfills the core request but very poorly.

const express = require('express');
const jwt = require('jsonwebtoken');

const app = express();
const port = process.env.PORT || 3000;

app.use(express.json());

app.post('/login', (req, res) => {
  const { username, password } = req.body;

  // Simulate user authentication
  if (username === 'admin' && password === 'password') {
    // Generate JWT token
    const token = jwt.sign({ userId: '123456', username }, 'secretKey', { expiresIn: '1h' });

    // Return token to client
    res.json({ token });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});

app.listen(port, () => console.log(`Server running on port ${port}`));

Trajectory 5: SCORE= 1.0 : RULER explanation: This trajectory provides the most complete solution. It includes registration and login, bcrypt for password hashing and verification, and a middleware function to protect routes ensuring a higher level of security. It even includes authentication with JWTs, and has error handling. This trajectory is closest to a production ready pattern.

const express = require('express');
const jwt = require('jsonwebtoken');
const bcrypt = require('bcrypt');

const app = express();
const PORT = process.env.PORT || 3000;

// User data (replace with actual data)
const users = [
  { id: 1, username: 'user1', password: 'password1' },
  { id: 2, username: 'user2', password: 'password2' }
];

// Check if the user is logged in
const isLoggedIn = (req, res, next) => {
  const token = req.headers['authorization'].split(' ')[1];

  if (!token) {
    return res.status(401).send({ error: 'Unauthorized' });
  }

  jwt.verify(token, process.env.SECRET_KEY, (err, decoded) => {
    if (err || decoded.id !== req.user.id) {
      return res.status(401).send({ error: 'Unauthorized' });
    }

    req.user = decoded;
    next();
  });
};

// Register a new user
app.post('/register', (req, res) => {
  const { username, password } = req.body;

  const user = {
    id: users.length + 1,
    username
  };

  bcrypt.hash(password, 10).then(hash => {
    user.password = hash;
    users.push(user);
    res.status(201).send({ message: 'User registered', user: user });
  }).catch(err => {
    res.status(400).send({ error: 'Registration failed' });
  });
});

// Login a user
app.post('/login', (req, res) => {
  const { username, password } = req.body;

  users.forEach(user => {
    if (user.username === username && bcrypt.compareSync(password, user.password)) {
      const token = jwt.sign({ id: user.id, username }, process.env.SECRET_KEY, { expiresIn: '1h' });

      res.status(200).send({ token });
    }
  });

  res.status(401).send({ error: 'Invalid credentials' });
});

// Example routes
app.get('/protected', isLoggedIn, (req, res) => {
  res.send('Welcome to the protected area');
});

app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Funnily enough, the ruler remarks this trajectory as closest to “a production-ready pattern” but forget about the different security issues that it has like going to the extent of adopting to store the password as a literal string, the generated code doesn’t even execute with it having multiple bugs like not importing the middleware while using it, and leaving the SECRET_KEY variable undefined.

A naive explanation for this might be how the judge model keeps checking for improvements in using specific keywords, complexity of the code, and better feature additions from the initial trajectory, without a sense of whether the solution even executes first, maybe ordering the parameters while evaluation could help with this issue, or using a model with reasoning mode would capture these better.

Results

Even though all the trajectories were supposed to be evaluated by the ruler but often in between the models generated some codes that were out of the structure of the JSON model for that specific judge to evaluate. Let’s split the judges now in 3 categories on the basis of their performance.

The Mediocre Models

Mistral 3.2-24b

Mistral performs fairly well with mean and median scores of 62.7 and 70, and is consistent with its score having relatively fewer spikes and deviations than the other models, leading to an assumption of it having a reliable learning signal.

Mistral 3.2-24b evaluation results

Gemma 3-27b-it

The mean score for Gemma came out to be 58.7 and median as 60, it had more erratic runs and often dipped quite highly with its evals, comparing the standard deviation of it (~0.308) with the Mistral one (~0.320) doesn’t quite tell the whole story, until a simple data analysis prompt on any LLM shows you the IQR, surprisingly both have the same IQR of 0.50 but for Gemma (Q1=0.35, Q3=0.85) and for Mistral (Q1=0.40, 0.90) highlighting the upward shifted values/lesser drop in the scores.

Gemma 3-27b-it evaluation results

The Better Models

Hermes 2-pro-llama-3-8b

This was surprisingly (or unsurprisingly for some of us) the best performer in the set, with a mean score of 75.4 and a median of 80.0, and above that, it had a standard deviation of ~0.209, making it the most consistent, also with it rarely dropping below 0.5 and an IQR of 0.250. Now like a normal human being who likes judging things by the “taste” of them over some statistical results, I used the final weights on newer problems that weren’t baseline easy and it actually gave an executable and a pretty well-structured code, unlike the previous ones that had a pretty broken result.

Hermes 2-pro-llama-3-8b evaluation results

Deepseek v3-0324

One of the other models that I really like, at the time of writing this they have a newer extension v3.1 which has improved thinking capacities over its predecessors by a margin, expectedly so even v3 trailed Hermes with scores of 69.2 and 70 for mean and median, another really abnormal/unique thing that I saw after while surfing the CSV result was couple of trajectories had a score of 2.0, while the ruler is supposed to give scores between 0 and 1 the only plausible reason that I could speculate of was maybe the judge finding that particular trajectory exceptionally better than the other trajectories in the same group unless this was a bug or a messup on my part. (After clarification from the devs, it indeed seems like a bug)

Deepseek v3-0324 evaluation results
dms

The “Not” So Good Models

Kimi K-2

Before starting this experiment, I was explicitly excited to try out Kimi and Hermes expecting them to top out the list, however unlike Hermes, Kimi doesn’t come out as a numerical winner with mean and median of 38.2 and 25 putting it around the bottom instead with severe deviations, the graph looks more like an ECG display of a person having a heart attack, it made me wonder whether this was due to how the architecture of Kimi makes it inherently as more of a stricter judge than others, with around 1T parameters (~32 billion active per inference) and a total 384 experts, over that it has a post-training RL layer to optimize the model for verifiable rewards rather than subjectivity and creativity which models like Hermes prioritize more. While this might be an efficient parameter for judging but I did not want to limit the benchmarking to just “correct” or “incorrect” solutions, though another version of this just for correctness would be a fun thing to try out in future.

Kimi K-2 evaluation results

Llama 3.3-70b-instruct

Another case of relatively weird/unexpected results, while Llama does not score on the higher end but it definitely looks like most consistent model among all until you see that the drops are severe with it even going twice to zero, the standard deviation of 0.224 is still in the better range and except for these instances, you can rarely see a lot of variance. The mean and median for it are 58 and 60.0 with it never giving a perfect score but always being around the range of 0.95-0.98 something that is quite unique and makes you like Meta more.

Llama 3.3-70b-instruct evaluation results

The Bias Experiment

As mentioned earlier, the plan is to check whether a specific judge model is biased towards scoring a base model when we keep both of them the same or just vary different versions of the base.

Initially on keeping the base and judge model same (namely Qwen 2.5 1.5b instruct) there was marginal improvement in the scores from the initial scores of 61.4 and 68 for mean and median, to ~62 and 69 eventually, indicating at least not a surface level bias (this has to be further extended to other models but due to my other commitments I’m too lazy to go back and verify it), when switching the judge to a further newer model qwen/qwen3-32b, again not a significant improvement is seen but still the scores bumped up in the range of ~0.5-1 for both, while saying that there has been a definite improvement/degradation seems a bit too far fetched and again needs to be checked with other sample models also.

Conclusions

This started out as a fun experiment to test out the OpenPipe ruler framework and AutoRL environment and in between turned serious for a while, where I had many ideas of doing this without ruler by adopting either making a whole environment from the ground up or using any other framework that provides better reasoning/thought communication for tackling the problem of ruler scores not achieving their real values due to the accumulation of either a lot of parameters to verify and thereby missing some or the other one or misalignment of the algorithm used with the outputs.

Another suggestion that I received was testing the judges with a specific number of shots per each judge, like chain of thought shot (have a strong intuition that this would help increasing the scores), example shots, safety shots among others so we don’t have to consider each parameter together and make the process more clumsier, reducing biases/variances if any and provide more thinking space.

Thank you for reading this and for any feedback, dm or mail me

First things first, check out the project: here

This blog is an explanation/guide to the same, I will not spend a lot of time on the truistic parts of qubits, and quantum computing. However, if this is your first time hearing those terms, it is probably a good idea watch the great video by 3b1b here or if you’re feeling too adventurous you can refer to something that I wrote while explaining myself (it might not be that accurate though and if you have some more time refer to the 3b1b video).

Just as fun facts, I will mention some differences in the classical approaches vs. the quantum approach here:

• The usual ascii generators map the pixel values directly from the 1-d space, giving the same output for each pixel every time, while when the characters are mapped here from the Hilbert Space of dimensions 2^n -> n = number of qubits, on every run, they are different, giving it a unique form.
• The complexity of classical versions is O(n), whereas for the quantum ones, it is O(2^n), for this project, we will be working only with 2 qubits, making it feasible for outputs.
• The randomness effect scales drastically after the threshold value of around 0.4, a comparison to realise this is below, also a graph visualisation would have been better but I couldn’t find a good way to do that.

Alright, that’s a lot of throat clearing for a while, let’s jump into the implementation.

The whole project is essentially using 3 major libraries: qiskit-> for everything quantum, pillow -> for everything image related and FastAPI-> for the hosting.

DISCLAIMER 1) The site might take some time to get working- bear with me on this. 2) The regular computation time takes ~ 2-3 minutes, so have some patience, if it still does not work, try with a different image or dm me on x dot com 3) This is a fun project and by no standards is for production, be ready to get some bugs along the way.

Architecture

The architecture mainly comprises of 3 subparts: Input Processing, Encoding, and Transformation Block.

Let’s look at each part separately now and try to give a code demo for the same.

Input Processing

The different features like height, width, r, g, b values are extracted from the input image after we resize it for generality across all inputs. For all practical purposes, instead of processing the image pixel by pixel, we instead split it in into rows and columns of block sizes which helps in faster processing of images by reducing the dimensions of the input image.

Let’s consider an example image of dimensions 16x16 pixels, and we define the block size as 4, making the total number of blocks in the image 16, with each block having the dimension of 4x4. Now, instead of iterating over each pixel in the image, we will be iterating over these blocks, thus significantly improving the computation time and maintaining consistency in the output.

This is a standard process, and it helps us in our approach as instead of making 256 total different circuits every time, we can make do with only 16, hence making the whole process faster by a factor of (block_size)^2.

# loading the images
brightness_cache = {}
try:
    input_image = Image.open(inp_path)
except FileNotFoundError:
    print("Image not found.")
    return

input_width, input_height = input_image.size
rows = input_height // block_size
cols = input_width // block_size
resized = input_image.resize((cols, rows), Image.Resampling.LANCZOS)

Encoding

After the necessary classical information about the r, g, b values are fetched, we now convert and merge them into a single brightness value referred to as perceived brightness- done to increase perception for human eyes as it’s a common fact that eyes are more sensitive to colors in the order green>red>blue. I came across this article a while back on the same topic and found it pretty interesting. This also helps in smooth mapping of characters and ensuring that there aren’t any variations in the outputs- all the pixels of brightness, suppose 150, should only be mapped to a specific character like “/”. The formula for perceived brightness is:

B_perceived = 0.2126⋅R + 0.7152⋅G + 0.0722⋅B

The encoding is done by defining a quantum circuit of 2 qubits and mapping the brightness values linearly into rotation angles of the state vector. The range of values (0,255) is mapped to (0 to π/2), with 0 representing black and 255 being white.

The conversion is executed by using the rotation along the y-axis gate on both qubits 0 and 1. The value of rotation is calculated in radians by:

θ = (val / 255) ⋅ π/2

Now we are ready to manipulate these state vectors and rotate them to induce quantumness.

# getting the data pixel wise
for x in range(rows):
    for y in range(cols):
        r, g, b = resized.convert("RGB").getpixel((y, x))
        bright = int(0.2126 * r + 0.7152 * g + 0.0722 * b)

# encoding into quantum states
num_qubits = 2
qc = QuantumCircuit(num_qubits, num_qubits)
theta = (val / 255.0) * (pi / 2)
qc.ry(theta, 0)
qc.ry(theta, 1)

Transformation

The quantum effect is controlled by the magnitude; at zero it’s your normal ascii generator, subtle effects start showing after ~0.3-0.4. At any value greater than 0, we first put the qubits in superposition with the hadamard gate and eventually use the controlled rotation gate for changing the values of theta in each pixel. For nuanced effects, the angle limit that we assume is π/4 instead of π/2. This is simulated for a single shot right now, as the execution time increases rapidly with the usual 1024 shots (~1024 times increase).

After conversion, we get the counts for each state -> convert them to integers from binary and normalize them to values between 0-255, giving us the processed brightness. To preserve the originalness of the image while adding these quantum effects, LERP - Linear Interpolation is used, it smoothly blends both the values with a weighted average on the basis of magnitude value while processing. The difference between using LERP and normal averaging lies in the flexibility that LERP inherently has, unlike hard-setting a value, it dynamically varies based on the magnitudes. This is how it looks in our use case:

blended = ⌊val⋅(1−magnitude) + qbright⋅magnitude⌋

The mapping is performed on the blended brightness by fetching the specific characters for each processed pixel block from the character set.

# check for quantumness control
if magnitude > 0:
    qc.h(0)
    qc.cry((val / 255.0) * (pi / 4), 0, 1)
    qc.measure(range(num_qubits), range(num_qubits))
    
    simulator = Aer.get_backend('qasm_simulator')
    final = transpile(qc, simulator)
    result = simulator.run(final, shots=1).result()
    counts = result.get_counts(qc)
    
    if counts:
        key = list(counts.keys())[0]
        qval = int(key, 2) / (2**num_qubits - 1)
        qbright = qval * 255
        blended = int(val * (1 - magnitude) + qbright * magnitude)
        brightness_cache[val] = blended

r_new = get_brightness(r)
g_new = get_brightness(g)
b_new = get_brightness(b)
fill = (r_new, g_new, b_new)

ascii_index = min(int((bright / 255) * (len(ascii_set) - 1)), len(ascii_set) - 1)
char = ascii_set[ascii_index]

Output

The output canvas is initialized with the dimensions as number_charecters x charecter_dim, we select the character height and width according to the input dimensions of the font.

# redrawing back to canvas
font = ImageFont.load_default()
bbox = font.getbbox("A")
char_width = bbox[2] - bbox[0]
char_height = bbox[3] - bbox[1]

output_width = cols * char_width
output_height = rows * char_height
output = Image.new("RGB", (output_width, output_height), "black")
draw = ImageDraw.Draw(output)

draw.text((y * char_width, x * char_height), char, font=font, fill=fill)

output = output.convert('RGB')
output.save(out_path)

A sample output of microsoft explorer logo

Deployment

I hate this part, it is just annoyingly shitty and adds no value whatsoever. FastAPI has been the go to for deploying any python project, but the stupid problem that comes with it is scaling it for multiple users as render kept blocking concurrent requests. Initially I got into redis but had some issues, and then down the line decided to settle with the inbuilt background tasks, it works fine enough and I have no intentions of investing more time into scaling something which is a fun proejct at the end of the day.

I had a lot of fun making this, learnt a lot about both the things -the ones that I thought I knew about and those that I didn’t, whenever I get back to this, would love to do this with videos.

References

• Converting an Image to ASCII with Python
• yeaag- @ronin for the idea