When you talk to a large language model (LLM), it feels like the model understands the meaning. But under the hood, the system depends on the number, vectors and maths to find the system The relationship between words And phrases
One of the most important tools that makes it possible is the matching match. If you want to know how the LLM can decide that two sentences mean almost the same thing, the Kosin match is key.
This article explains the similarities in simple language, shows mathematics behind it, and connects it to the work of a modern language model. Finally, you will see why this is an easy idea to measure angles between vector power, chat boats, and many other AI systems.
The table of content
What is the Kosin match?
Imagine that you have two sentences. A computer is not a word, but a vector, a long list of numbers that make sense.
The Kosni resembles how close the two venors are, not from their length, but from the angle between them.
Think about the two arrows that start from the same point. If they point to the same direction, the angle between them is zero, and the Kosin match is one. If they point to the opposite direction, the angle is 180 degrees, and the similarities are negative. If they are at the right angle, Kosn’s similarity is zero.
Therefore, the Kosin match tells us whether two venors are pointing to the same common direction. In language works, it means that it tells us whether two pieces of text have the same meaning.
Maths behind the Kosin matching
We need to see a little math to understand the similarities. In geometry, the angle of the angle is proportional between the two vectors’ dot product and their expansion products. Written as a formula, the Kosin matching looks like this:
cosine_similarity(A, B) = (A · B) / (||A|| * ||B||)
Here:
A · BVector A and B are a dot product.||A||Vector A is the breadth (length)||B||Vector B is the breadth.
Dot Product multiplies and increases the same numbers in both vector. The vastness of the vector is equivalent to finding an arrow length, Pittagorin Theorem.
This formula always values ​​between -1 and 1. The price near 1 means that the vectors are pointing to the same direction. Near the price of 0 means they are irrelevant. The price near -1 means they are opposed.
A simple example
Let’s see a brief example using Azgar. Suppose you want to check how two short texts are similar. We can use Skate To convert them to vector and then calculate the Kosin similarities.
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
texts = (
"I love machine learning",
"I love deep learning"
)
vectorizer = TfidfVectorizer().fit_transform(texts)
vectors = vectorizer.toarray()
similarity = cosine_similarity((vectors(0)), (vectors(1)))
print("Cosine similarity:", similarity(0)(0))
The code begins with the import of two major tools. TfidfVectorizer Is responsible for turning the text into numbers, while cosine_similarity Measure how many sets of numbers are. Together, they compare us to the text in a way that the computer can understand.
Next, we explain the phrases we want to compare. In this example, we “love me machine learning” and “I love learning deeply.” Both of these phrases share some words such as “I,” “Love,” and “learning” while in one word vary in: “The machine vs.” deep “. This gives them good examples of testing, because they are clearly associated with but not exactly the same.
The vector then produces words stored with all unique words in both sentences. Ls these inputs, the words become ("deep", "learning", "love", "machine"). This means that the program now contains a list of all words when it will be detected when building a numerical representation of the sentence.
After that, each sentence is converted into a vector, which is just a list of numbers. These numbers are not just counting the word. Instead, they are in weight using TF-DIF, which stands Term frequency – the frequency of the reversal document.
TF-IDF attaches more importance to words that are important in a sentence and give less importance to very common words. In a simple form, the first phrase becomes something like that (0. 0.50154891 0.50154891 0.70490949)While the second becomes (0.70490949 0.50154891 0.50154891 0. ). The number may look small, but what is important is the values ​​of them.
.toarray() The method then turns these vector into the ranks of the standard. This makes them easier to handle, as the TF-Adf output as default is stored in a particular viral format.
Once the sentences are presented as a vector, the Kosin match is applied. This step checks the angle between the two vectors.
If the vectors point to the same direction, their matching score will be one. If they are irrelevant, the score will be close to zero. If they point to the opposite direction, the score will be negative.
In this case, because both phrases share most of their words, so the vectors point to a similar direction, so the coin match comes around 0.5 to 0.7.
In simple terms, this code shows how the computer can convert two sentences into numbers vectors and then check how close the vector is. Using the Kosian similarities, the program can not only decide whether the sentences share the words, but also how firmly they become overplaps.
Matching the Cosin in Embeding
In practice, LLMs like GPT or Burt do not use simple words counting. Instead, they use embedded.
An embellishment is a dense vector that captures the meaning. Each word, phrase, or phrase numbers turns into a set of numbers that keep it in a high -dimensional place.
In this place, similar words are close to each other. For example, embedded for “king” and “Queen” is much closer than the embedded “king” and “table”.
Cosin matching is the tool that allows us to measure how close the two embedids are. When you look for a “dog”, the system can look for embellishness that points in a similar direction. Thus, he gets the results about “dog,” “canon”, or “pet” even if those words are not in your inquiry.
How LLM use Kosine Matching
Large models of language use coin similarities in many ways. When you ask a question, the model encodes your input into the vector. This vector is then compared with stored knowledge or with the candidate’s responses that use the coin matching.
The meaning of the spiritual search helps in the classification of the match matching documents. A system can embed all the documents in the vector, then embed your query and count the matching score. High score documents are the most relevant.
In clustering, the Cosin Matching helps with the group sentences that mean. In the recommendation system, it helps users to match their items by comparing their preferred vectors.
Even when you produce answers, LLMs rely on vector similarities to decide which words or phrases in the context are best followed. The Kosin match provides an easy but powerful way to measure the proximity of meaning.
The limits of the Kosin matching
Although the Kosin similarity is powerful, it has limits. It relies heavily on the quality of embedded. If embeddings fail to capture the meaning well, the match scores cannot reflect the proximity of the real world.
Also, the similarities only measure the direction. Sometimes, there are also useful information. For example, a phrase can be embedded length that reflects confidence. By ignoring it, the similarities can lose some part of the image.
Nevertheless, despite these limits, the similarities of the Cosin are one of the most used methods in the processing of natural language.
Why is it important for LLMS
Cosin matching is not just a mathematical trick. It is a moment between human language and machine understanding. It allows a model to behave with the meaning of geometry, changing questions and answers to points in space.
Without a similarities, embellishments will be less useful, and tasks like cement search, clustering, and classification will be more difficult. By reducing the problem to measure angles, we make meaning and use.
Whenever you find on Google, chat with an AI, or use a recommended engine, the Kosin match is behind the curtains.
Conclusion
The Kosin similarities suggest how LLM decides the meaning of the meaning between words, sentences, or even the whole document. It works by comparing the angle between vector, not their length, which makes it ideal for text. With embedded, the Kosin match becomes the basis of spiritual search, clustering, recommendations and many other tasks in the processing of natural language.
The next time an AI gives you an answer that feels “close enough”, remember that a simple mathematical idea, measuring the angle between the two arrows, is doing a lot of heavy lifting.
Hope you enjoy this article. Sign up for my free AI newsletter turningtalks.ai For more lessons on AI. You can also find Visit my website.