Infinite AI Array

I love this. It reminds me of [1], which I wrote years ago to do something similar with undefined method calls: Rather than erroring, a modified `method_missing` triggers and searches Stack Overflow for code snippets with the same method name, then injects that code into scope and walks back the stack trace to try again, recursively if necessary.

Horrible idea. Great execution.

[1] https://gist.github.com/drusepth/48a246e1263183e0418c

The problem with this is you can't trust the actual data, if you care about data quality. I'm really not getting it's usefulness beyond a contextual lorem ipsum generator? It could probably work for a test environment but you still need to have a human review the lists that are generated.

If the results were stable, reproducable and somehow memoizable, this would be actually insanely useful. Perhaps it could modify a cache file somewhere with the generated Python code, and that could be committed.

This is similar to copilot-import [0] which in turn was based on stack-overflow-import [1]. I'd be interested to see whether ChatGPT/GPT-3 or Codex/Copilot is better at generating function bodies.

[0]: https://github.com/MythicManiac/copilot-import [1]: https://github.com/drathier/stack-overflow-import

This is a great illustration of how ChatGPT fundamentally changes "true/false" into a continuum of "truthiness" as measured by plausibility. The infinite AI array is clearly marked as such, but how long will it be before generative extensibility is the (undeclared) norm?

We're all about to get some real-world GAN training.

I was just messing around with ChatGPT for a similar use case. Amazing what comes out of you ask for:

    Give me a list of imaginary products that might be found in a magic shop formatted as json array including an id name, description, sku, price. Use syntax highlighting for the output and pretty print it.

Does anyone remember Google Sets? It was a short lived project where you'd input some entries from a list and Google would automatically expand it with related items. Seemed magical at the time (mid-late 00s I think?).

God damn, Ian has been releasing super creative code since before I started paying serious attention to Python circa 2005. Great to start 2023 with another one. The opportunity to hire someone of his caliber doesn't come up often.

It's hilarious that even before thinking "wow it's crazy how accessible and powerful these LLMs are" I thought "man... Python is a pretty heinous language".

Do those objects... know the names of the variables they are assigned to?

The magic method resolution seems much more intriguing to me than the infinite array. Are there any programming languages (or perhaps a better word would be paradigms), that take this concept further?

I would imagine that I just state comments in my code file. Then, at runtime, all code is produced by the language model, and then executed.

There's the issue of the model producing different generative results with each execution. But maybe that could be taken care off by adding doctests within my comments. Which could, of course, be mostly generated by another language model...

I tried GPT-3 and it generated code examples that just ~made up~ some library that didn't exist at all. It had code that in theory would have ran, if that library ever existed at all, but it didn't, and it consistently came up with code examples using this imaginary library. I thought that wasn't very impressive.

What I'm finding it's extremely great for is writing drivel. I'm talking ecommerce product descriptions, product names, copy... it's really awesome for making one of my side gigs less of a chore.

It kind of reminds me this one https://xkcd.com/221/:

    getRandomNumber() {
        return 4; // chosen by fair dice roll
                  // guaranteed to be random
    };

Clever. I could see this being legitimately useful for generating test data.

Here’s what I got from ChatGPT

class InfiniteArray: def __init__(self, generator_function): self.generator_function = generator_function self.items = [] self.index = 0

  def __getitem__(self, index):
    # if the index is out of bounds, generate more items
    while index >= len(self.items):
      self.items.append(self.generator_function())
    return self.items[index]

# example generator function that generates capital cities def world_capital_cities(): # list of capital cities capital_cities = ['Paris', 'London', 'Tokyo', 'New Delhi', 'Beijing'] # generate capital cities in a cyclic manner for i in itertools.cycle(range(len(capital_cities))): yield capital_cities[i]

# create an infinite array object with the world_capital_cities generator function capital_cities_array = InfiniteArray(world_capital_cities)

# access the 10th item in the array print(capital_cities_array[10]) # prints 'New Delhi'

# example generator function that generates concatenation of two lists def soft_sweet(): # list of soft items soft = ['cloud', 'pillow', 'fluffy'] # list of sweet items sweet = ['ice cream', 'candy', 'bunny'] # generate concatenation of soft and sweet in a cyclic manner for i in itertools.cycle(range(len(soft))): yield soft[i] + ' ' + sweet[i]

# create an infinite array object with the soft_sweet generator function soft_sweet_array = InfiniteArray(soft_sweet)

# access the 5th item in the array print(soft_sweet_array[5]) # prints 'pillow candy'

This is an example of something I've seen referred to as "code hallucination". It's pretty darn mindblowing, and you can get some really interesting results. Those times when AI hallucinates some function that doesn't exist are kind of annoying, but one man's bug is another man's feature. You can turn the table on it and make it useful by __going ahead and using those functions that don't exist__.

I was playing around with this by telling ChatGPT to pretend to be a Python REPL and provide reasonable results for functions even if they weren't defined. A few of my favorite results:

    >>> sentence_transform("I went to the bank yesterday.", tense="future") 
    "I will go to the bank tomorrow."
    
    >>> wittiest_comeback(to_quip="Hey George, the ocean called. They're running out of shrimp.", funny=True)
    "Well, I hope it's not too crabby about it."
    
    >>> sort_by_temperature(["sun", "ice cube", "flamin-hot cheetos", "tea", "coffee", "winter day", "summer day"], reverse=True)
    
    ["flamin-hot cheetos", "sun", "tea", "coffee", "summer day", "winter day", "ice cube"]

It took some experimenting to get it to consistently respond as expected. In particular, it'd often warn me that it's not actually running code and that it doesn't have access to the internet. Explicitly telling it to respond despite those things helped. Here's the latest version of the prompt I've had success with:

---

Your task is to simulate an interpreter for the Python programming language. You should do your best to provide meaningful responses to each prompt, but you will not actually execute code or access the internet in doing so. You should infer what the result of a function is meant to be even if the function has not been defined. To do so, you should take into account the name of the function and, if provided, its docstring, parameter names, type annotations, and partial implementation. The response to the prompt should be formatted as if transformed into a string by the `repr` method - for instance, a return value of type `dict` would look like `{"foo": "bar"}`, and a float would look like ` 3.14`. If a meaningful value cannot be produced, you should respond with `NoMeaningfulValue(<explanation>)`. You should output only the return value, and include no additional explanation in natural language.

---

I also add a few examples; full thing at [0], to avoid polluting the comment too much.

I was meaning to write a Python library to do that, but right around then OpenAI implemented anti-bot measures. I'm sure it's possible to circumvent them one way or another, but if there's measures in place there's a reason for that, and it's not very nice to degrade everyone's experience. I've had less impressive results with codex-2 so far. Still, harnessing hallucination is a pretty cool idea.

[0] https://gist.github.com/pedrovhb/2ac9b93f446f91a2be234622309...

I wasn't aware there was a mechanism to get the actual name attached to an object when it is instantiated in Python! That alone made my day.

This is good fun. In the same spirit as something I threw together recently [1], that runs broken code (with un/misdefined functions and variables), and repairs it using a combination of stacktraces and comments fed to GPT-3.

[1] https://news.ycombinator.com/item?id=34230238

This will be absolute gold for generating test data.

Super useful for mock data generation and testing.

I find it simply ... human to use a tool once you understand it. The ingenuity is so characteristic. Python is fusing with an NL dialect. Amazing.

It feels like the current AI developments ( OpenAI, SD, etc) are just like wheels. We are now putting them on a cart and invent transportation.

And look, we are planning to go to Mars.

Can anyone clarify what this does? I can't understand what the purpose of this is.

Neat idea. But GPT itself has context length limit, so it is not infinite? At some point the list will go rogue and becomes irrelevant.

How does this code work?

primes = InfiniteAIArray()

Is the context determined from the variable name? If so is this through a kind of reflection?

What?