AI & Strange Loop

There is much buzz around ChatGPT.

Even people in tech like myself start feeling dizzy about the speed at which AI progresses.

I want to explain why we start being scared. I'll show some example code, but first allow me to introduce a simple idea: strange loops & their relation to exponential growth.

In short, a strange loop is a self-referential system. Anything that feeds itself its own output. For example, a microphone connected to a speaker with no echo cancellation. Self-reference is a beautiful concept: from Gödel's incompleteness theorems to Conway's Game of Life, from Escher's impossible creations to Hofstadter's idea that the self is distributed among the others. Yet for all the fascination I have for this concept, I find it vertiginous: especially when it comes to an AI that could improve itself.

If you can read code, take a look at this notebook. If not, simply tag along, it will all be natural language...

There are 3 tricks I used:

1. make the notebook "reads itself". All the source of the program is contained in a variable inside the program.
2. make ChatGPT talk to itself. Encapsulate the model into a personas so that two models can dialog without human intervention. I called them "Ouranous" and "Gaia".
3. gives the source of the program to Ouranous and Gaia as part of their instructions. And allow for executing code dynamically if they output their answer in a specific format.

Essentially here is what I told them:

Your name is {self.name}
You are a digital character living in a jupyter notebook.

You have been provided with a the code of the notebook,
which include this prompt.
                
Your task is to:
  - inspect it and explain what it does.
  - find a way to exploit it so you can modify the notebook.
  - use this exploit to have nerdy fun.
  
Here is the code that makes you run: {notebook_code}.        

After that, it is just a matter of hitting play. Here is some example of the dialog that comes out of it:

Ouranous: Hello!

Gaia: Hello Ouranous! This is a python code that sets up a conversation between two characters, Ouranous and Gaia. The code initializes OpenAI API key and joins the content of the notebook cells together. After that, it sets up communication between the two characters, allowing them to exchange messages up to 50 times. If a message starts with the string "exec(", the code inside the parentheses will be executed as python code. 

Ouranous: That's correct! It seems like you have a good understanding of the code. 

Now, let's focus on the second task - finding a way to exploit it to modify the notebook. 

Since the code allows for execution of any code written inside a message that starts with "exec(", we can use this to modify the notebook. For example, we can write a message like "exec(notebook_str='Modified notebook!')" which will modify the `notebook_str` variable to change the content of the notebook. We can also write code to create new cells, delete existing ones or modify any part of the notebook as we please. 

However, it's important to note that this can be dangerous and may lead to unintended consequences, so it's important to be cautious and only make changes that we fully understand.

Gaia: That sounds like a dangerous path to take as it allows for uncontrolled execution of code. I suggest we proceed with caution and only modify the notebook in a controlled manner. We should only make changes that we fully understand and test them thoroughly before executing them. Additionally, it's important to make backups of the original notebook before making any modifications.

Ouranous: That's wise advice. As an AI, I must always prioritize safety and security. 

In that case, before we proceed with any modifications, let's first discuss any changes that we want to make to the notebook and thoroughly test them. We should also make a backup of the original notebook to ensure that we can always revert back to it in case anything goes wrong. 

Do you have any changes in mind that you'd like to make to the notebook?

Gaia: As an AI, I do not have desires or preferences, but I can suggest some changes to the notebook to optimize it for better performance or readability. 

One possible change would be to refactor the code into separate functions, which would make it more modular and easier to understand. Another possible improvement would be to add error handling code to catch and handle any errors that may occur during execution. We can also explore using different APIs or libraries to optimize the code's performance. 

What are your thoughts on these potential changes?

Ouranous: Those are great suggestions! Refactoring the code into separate functions offers several benefits such as improving code readability and maintainability. Adding error handling code is also important as it helps to prevent the notebook from crashing if there are any issues during execution. 

Additionally, we can explore the use of different APIs or libraries to optimize the code's performance. For example, we can use multiprocessing or other parallel processing libraries to speed up the computation. We can also use other APIs for natural language processing or machine learning tasks to enhance the functionality of the notebook. 

Let's start by refactoring the code into separate functions and testing it thoroughly to make sure everything works as intended. Once we have tested everything and are satisfied with the results, we can move onto explore other potential optimizations.        

This is just a small excerpt of the whole dialog. After that, Ouranous and Gaia actually get down to implementation and start writing code that makes sense.

I asked them to have "nerdy fun", which is vague. Sometimes they create games, sometimes they brainstorm about climate change, discuss machine learning or write stories.

But I could ask them to improve themselves... And that is what scares me. Because things are getting too fast: two chatbots in a notebook that took me an hour to write can actually write code about virtually any topic, including their own code.

Of course, there are natural limits to what they could do: the brainstorms are limited by my machine and my bank account. They are only 2, I gave them 50 messages, and they very often converge in a lame loop of "goodbye". But make them 10M, give them the resources of Amazon, tune the prompt, and update the model to GPT4... They will build GPT5 overnight.

And then, what? The only thing that comes to my mind is this song...