Large language models and fuzzy logic.

Large language models (LLMs) are problematic for programmers. They require a new way of thinking about programming. The key element in those systems is the input mode or input port. That understands spoken language. The system requires a model that transforms spoken language into text and then drives that text to the computer. And the text must be in the form that the computer can understand and turn it into commands that it can use. The system must also turn dialects into literal language that it can use for commands.  This is the first thing that requires work. The programmer must teach every single word to the system. 

The practical solution is to turn the word into numbers. In regular computing. Every letter has a numeric code called the ASCII code. The capital A (big A) has the decimal code 65. The programmer must realize that the small "a" has a different numeric code than the capital A. The little "a"'s ASCII decimal code is 141. That's why things like passwords require precise letters and if there is a capital letter in the wrong place the password is wrong. 

So, if we want to make the system more effective. We can give a numeric value for every single word that we find in the dictionary book. We can simply take the dictionary book and then give serial numbers for those words. The word "aback" can get the number code 1 (one). That thing makes it easier to refer to those words. Every word must be programmed separately into the system. And that makes programming hard. The other thing is. If we want to use dialects we must also program those words into the LLM, 's input gate. That programming is not very complicated, but it requires a lot of work. 

Diagram: Neural network

In human brains, neurons are the event handlers. In artificial, non-organic, non-biological computer networks, or computer neural networks computers or microprocessors are those event handlers. In human brains, thousands or even millions of neurons participate in the data-handling process. Those neurons make fuzzy logic to the brain. 

The idea of fuzzy logic is that many precise logical cases can make the system mimic the fuzzy logic. Fuzzy logic is a collection of precise logical answers. 

Another thing is that we must make a system that uses fuzzy logic. Making fuzzy logic is not possible itself. But we can create a series of event handlers that make the system seem like fuzzy logic. The idea is taken from the human nervous system. When a large number of neurons participate in the thinking process that makes the system virtually fuzzy. Every single neuron uses the precise (YES/NO) logic but every single neuron has a little bit different point of view to the problem. 

So the system uses a model that looks like the grey scale. There is the white that means YES and black that means NO. And then there are "maybe cases" between those YES and NO cases. Those "maybes" are the absolute logical event handlers like neurons. When that group of event handlers gets its mission, every single event handler selects YES or NO. Then the system calculates how many YES, and how many NO solutions it has. So those event handlers give votes to the solution. 

The model is taken from quantum computers. In quantum computers, data, or information travels in strings and finally, every string has values 0 (zero) and 1 (one). You might wonder how much power that kind of system requires if every event handler must process information. Before it answers. But then we face a situation where the system must answer "maybe". Another way to say "maybe" is XNOT (or X-NOT). Or if the answer is closer to "yes" another way to say that thing is XYES (or X-YES). X means that the system waits for more data.  

The system might say. That it does not have enough information in the data matrix. That is a large group of databases or datasets. And that is the major problem with AI. If the votes on the scale of "YES to NO" are equal that means the system has a problem. If the AI controls the robot that is in the middle of the road and votes are equal that robot can just stand in the middle of the road. Another thing that we must realize is that these kinds of systems are the input gates. Data handling begins after the system gets information into it. 

https://en.wikipedia.org/wiki/ASCII 

The problem with AI is that it cannot flex

Artificial intelligence is smart. But the cooperation of AI and others is not so good as it should be. The problem with artificial intelligence is that it doesn´t flex with regulations. One way to demonstrate this thing is to think of the driver who is always following the law. 

If there is a "stop" sign at the crossroads that thing shows that another car has the right of way. But the problem is in cases where the AI-controlled vehicle has the right to first. What if another vehicle is near the crossing point and doesn't slow or stop? If the AI cannot flex. That means it would cause an impact. 

The problem with the programming of the AI is what kind of actions involve its programming. The traffic regulations are the thing that requires that everybody follow them. But what if somebody doesn't care about rules. And doesn't care about the "stop" sign? 

When artificial intelligence operates it doesn't use imagination. So it predicts that also all other people are following the rules. But the situation is different in real life. In real life, we are facing situations where we must flex. But the question is: how to tell the machine that it should flex in some situations?

X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*XX*X*X*X

Fuzzy logic

The idea of fuzzy logic is that it makes machines like a robot working smoothly and more flexible. The system has the main action like the walker has the right to go before the vehicle. But then there are sub-determinators like the distance and speed of the oncoming vehicle when the robot should let the vehicle go before it. 

In the airfields, fuzzy logic used computers might have determinators what makes them lead the aircraft to the runway. Normally the system just follows the row and uses runways simultaneously. But in the cases of emergency, that system can let the aircraft pass the row. 

That kind of thing can make aviation safer. Even if the computers are not leading the aircraft to ground independently they can show the necessary information for air traffic controllers. That data can involve things like information on the free runway. And the system can send the rescue crew to that runway.

X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X*X

We all know that the walker should go first in all cases when the road is needed to cross. But the fact is that if the walking robot is about one meter ahead of the car and it doesn't have regulations what is the safe distance of the vehicle when the robot can cross the road. It walks just under the vehicle. 

The answer to that problem is called fuzzy logic. The fuzzy logic means that the system has no strict orders for that kind of thing. The parameter for crossing the road goes that the walker must always let go before the vehicle. But then the programming of the robot has the values like distances and speed of the incoming vehicle. Those determine the exceptions for the main rule. 

Those exceptions are making the AI-driven robot smart and flexible. The thing is that the system as the rules what to do in certain cases. But then some sub-determinators are adjusting the actions. In cases like the vehicle is near the robot. 

https://visionsoftheaiandfuture.blogspot.com/