AI Society 4 – Socialising Part 2

HOW: PHILOSOPHICALLY

The Question

I think the best way to start this post is a question. How do the nodes understand, react to and grow based on an interaction and its output? We can break this question down into three parts:

• Understand: How do they understand the interaction? = Apply data to interaction.
• React: How do they react to the interaction? = Apply understanding to respond in the interaction.
• Grow: How do they grow based on the interaction and its output? = Store the data, build connections.

N.B The connections mentioned under growth will be built on a neural network style data store.

How can we solve this?

As the name implies, artificial intelligence aims to emulate intelligence. – Note that this doesn’t specifically mean human intelligence, see swarm intelligence for a good example of this -. However, in the case of this project, we are trying to emulate human intelligence at some level. Therefore, it makes sense that we should look to how we, as humans, process this question. In this analysis, I will be applying Nikola Tesla’s thoughts that everything which we think and do is directly influenced by our surroundings, whether we notice the influence or not. This line of thinking applies very well in this circumstance.

Situations

Let’s consider what kind of situations a node might find itself in when socialising with another.

• General socialising
• Trade
• Working towards desire
• Feels like socialising

Now, what would trigger these situations? Technically, a mixture of entropy and situational triggers. For example, higher confidence would add a greater multiplier, which would be combined with the entropy to generate the number that indicates to a node that it should start an interaction. But what is this number and how does a node choose who to talk to? The number is easy enough. Let’s say that it is between 0 and 100, if greater than or equal to 50 it becomes 1 (or true) if it is less than 50 it becomes 0 (or false). Choosing a conversational partner is slightly trickier. Let’s first remember that when the nodes are initially setup they don’t know who is out there; not to mention they won’t have any data on previous interactions to play on for these initial interactions. Once they have some contacts, they should have enough initial data on their contacts to react during an interaction.

Understanding

With this in mind, I would say that it is clear that the way we respond to interactions is based on experience: long-term: upbringing, school, career; short term: the last few days, weeks, months; and immediate term: the current interaction, including who you are interacting with, what you are talking about and what is going on in the environment around you.

This makes it clearer what the nodes should be considering, but not how they should store this data over time or how they should apply it to the current interaction. As this is a philosophically focused post we will not be looking in depth at the technical side of storing this data, mainly how we will be applying the already gathered data to an interaction.However, as a side effect, at the end of this post, we should have a very good idea of exactly what data needs to be stored.

Reacting

The decision-making process that the nodes will work through will require them to go through the data and add weight against the contact; this weight is temporary and specific to this conversation, this will most likely require some pattern recognition work in order to figure out a related response. A low weight indicates that the node does not think the information is very relevant to this interaction. Where a high score would indicate that they think the information is relevant. This brings us to another issue, how does the node determine the connection between this data and the topic in hand? This is where the pattern recognition would come into play, but this may not need to be too advanced initially. If designed well the data may be identical to something already stored, even if created independently. If these two nodes had previously discussed this topic, it makes it easier as they would already have made connections that would be relevant. The real trick is giving the nodes a concept of similarity and building data relationships. Easily solved by pattern recognition. Lastly, we also need to give them the ability to build on this for themselves. For now, we should focus on figuring out the best way to have a node connect points of information.

Growing

How do we create this connection? Thinking once again about how we, as humans, would do this, we see that connections in our brains neural network are created and removed (really strengthened and weakened) based on usage. Making our neural networks very dynamic. We should also note that as humans, we don’t all make the same connections between things, additionally when someone points out a connection our brains will create or strengthen a connection based on that. This is very straightforward to apply here, in theory at least. As we don’t really know what exactly causes these connections to be made in a human mind I will be employing artistic license when it comes to resolving this issue for the project. Let’s say that any little thing, anything that could be slightly thought of as a connecting point is noted down as a connection. So every different topic in a conversation is noted down as a connection, this includes being linked to the other node in the interaction. Now, this data may be legitimately completely unrelated, and that is where the next part comes in. Over time the data that is actually related has its connection strengthened, whereas the other connections may not have been strengthened at all and will be removed after a time. Or perhaps given a negative connection, indicating to the node that this is not related, at least not in their mind.

In review

Let’s start the recap by looking again at the initial question.

“How do the nodes understand, react to and grow based on an interaction and its output?”

Which we broke down further to:

1. How do they understand the interaction?
2. How do they react during the interaction?
3. How do they grow based on the interaction and its output?

And the brief answers:

1. They create connections using all parts of the conversation, using this information to create new connections and strengthen existing ones.
2. They react and respond during the interaction by referring to existing connections and working out what has the strongest connection to the current topic.
3. The growth comes from the understanding and building and strengthening connections.

Initially, all new data, received in an interaction, is connected, over time these connections are strengthened and weakened. As they get weaker they can become negative, indicating to the node that there is absolutely no connection between these items, at least in their mind.

One final question: How do we prevent or reduce duplicate data? Initially, I thought the solution would be to have a layer that analyses data and compares it to see how it matches up, utilising the pattern recognition I mentioned earlier. However, given the situation, it makes much more sense to give a strict language definition that makes it obvious if this data is the same as other data already stored. So, even if two nodes create data completely independently and this gets spread around, it will be stored in the same. It is important to make sure that this definition does also allow them to develop their own language, but this is something to consider later.