Week 17

Status

 It has been a long time since my last post. The reason is that I have experimented a lot with nerual networks using the programming language Julia, and would wait to post until I got some results. But I have not got any conclusive results yet. So it was time to let all the accumelated ideas to get posted anyway.

 Agentic AI

In my first blog post I posted an idea how to call a LLM multiple times to get better results. Turns out that idea was very old, and stuff like AutoGPT has been out for a long time. I don't know who exactly coined the term, and if it is the right term for the idea. But it seems tons of people are thinking the same, and moving down that road. Andrew NG has a lot of ideas of agentic AI, that seeems to have gained popularity.

But in short I see it when you use the context window of an LLM as the short term memory, have some storage as long term memory, and use the programming ability of the LLM to create world simulations.

 This is then extended with whatever actions the agent should be able to do. I will come back to later, why it doesn't seems like anyone actually have figured it out correctly, yet.

Trust and performance

If I at some point will make an AI software company, it should focus on only two things. Trust and performance.

The reason is that I would make a personal assistant AI. The reason are simple - if it fails, it is because somebody has done it better, which would lead to having a personal AI assistent, and if it doesn't fail, it would also lead to that result.

If you have a company, you need to have some core expertise. And focusing on trust and performance in AI, has some nice properties.

The more trust people have in the AI, the more responsibility they will give it, which means it can take even better decisions on behalf of the user. 

The end goal is that the personal assistent should be able to participate in this AI governed democracy that I have blogged about in a previous post.

To do this it needs access to everything from bank account to medical information. 

But trust is both inbound and outbound. How much does the user trust the AI? And how much does the AI trust other things. It needs to know how to evaluate trust news reporting, other AI systems and research. And the better it is at that, the better it can perform.

The other thing is performance. The better performance the AI system have, the more people can get access to it. And ability of what it can do increases, every time the performance get better. 

One of the most important things for performance is actually trust. If you instead of doing a world simulation for each person, you could do it in a shared way, and could trust that result, it would be an enourmous perfomance boost. In general you could say that the goal is that a calculation should done as few times as possible, across all computers, while still retaining trust.

The two main examples are people who are running AI on their home computer. This actually has a lot of traction, since a lot of open parameter LLMs exists. The problem is that it is hard to trust the calculations done, since the owner has full control.

The other example is an AI cloud provider, which has enough measures in place, so it can be asserted that the AI calculations are not tampered with. In that case computational results can be reused to a very high degree, which means that personal AI assistents can use these result to be cheap and powerful at the same time.

Complete AGI

To create a personal AI with a high degree of trust and perfomance, we must build an AGI.

I have previosly written what I think AGI means, and even if other people disagree, this would still be the measure I would be looking for.

The first on is that is self improves. As soon as we have an AI that changes the code it itself is made of, to improve it self, I see it as AGI.

The next question is which areas it improves itself. If it only makes itself faster, but doesn't gain any new ability, it won't ever get new abilities. So I have the concept of completeness. If you as a human can think of a problem or area the AGI should excel at, it is more complete if it can also do that area. So the more areas it can improve it self at, the more complete it is.

We then have the concept of a complete AGI - and AGI that can improve it self in any area that a human can think of.

I don't know if that is possible, but the ideas presented below should either lead to that or something very close.

So lets start with the agentic AI, and the stuff that I have not found others already written about (but probably have).

Agentic AI works by having text in the context window, that is then answered. And a new context window is then made from that. This leads to strings of thoughts - which is an cabability missing when asking the LLM directly. 

Three importants things needs to be done, that I haven't seen done by others yet:

• A lot of LLMs can be at chosen from, each with different capabilities.
• The context for the next 'thought' should match the capabilites of the chosen LLM
• Previous context can in some situations be reused, and how much depends on how the context window is structered, and what the architecture is of the underlying LLM.
• What is put in the context window should give the best overall performance. Limited size of a context window, is actually a good thing.
  

If we look at the LLMs used, it also looks like that are some areas people are not looking at.

• It should know when it can not answer a question
• It should be optimized for logical reasoning based on information in the context window
  
• The idea that an LLM with an unlimited or extremely big context window is needed, is probably wrong

 

 Logical LLM

So how do we make an LLM that does logical reasoning, and knows when it doesn't know an answer?

My idea is to structure it in the following way:

Fundamentally change how the neural network works.

Instead of having predefined layers of neural networks that are interconnected, we can have small neural blocks, that acts as function calls from a programming langauge.

This is a little bit how recurring neural network works, where the same part of the neural network is called again and again.

The next thing is that the neural network should grow and take shape according to the data. The way to do this is to split the data op in three parts - one for setting the parameters for the neural network, and one for changing the shape for the neural network. And the last part is just the test data, to see if it actually works.

This would give a neural network that can think much more logically.

The next thing is to change how LLMs work. Right now they work by predicting the next token, and have some cache for performance to avoid the runtime being n*m, where n is the number of input tokens, and m being the number of output tokens.

Instead we should change the training to be question/answer based and only predict the tokens in the answers.

The LLM should then be trained to parse the question, to give the full result. This is done by parsing the question once, then build an intermediate datastructure. Then repeat that a lot of times.

After that is done, the process is kind of reversed, and there is written to an output datastructure. This is then repeated multiple times, and the final output is then the answer to the question.

Backpropogation is then done, for the neural network that is responsible for the parse-in/write-out.

The runtime for inference for this architecture is something in the line of n*log(n) + m * log(m) .