Text embeddings explained with no jargon

Imagine you’re trying to teach a computer to understand a story. The computer doesn’t understand words or sentences like we do. It only understands numbers. So, we need a way to turn the words and sentences in the story into numbers that the computer can understand. That’s where text embeddings come in.

Let’s say the story is about a cat and a dog. We could give the word “cat” the number 1 and the word “dog” the number 2. But what about the word “pet”? It’s related to both “cat” and “dog”, so it should have a number that’s somewhere between 1 and 2, right?

That’s the basic idea behind text embeddings. We give each word a number (or a group of numbers) that represents its meaning. Words with similar meanings get numbers that are close together. This way, the computer can start to understand the relationships between different words.

And it’s not just for single words. We can also do this for whole sentences or even longer pieces of text. This helps the computer understand the story as a whole, not just the individual words.

So, text embeddings are like a translator between us and the computer. They help the computer understand our words and stories in a way it can process and learn from.

Difference between chunk size and chunk overlap

Chunk Size

Let’s say we have a text:

"Hello, this is a sample text to demonstrate the concept of chunk size in text splitting."

And we set chunk_size = 20. This means that each chunk of text that we split will have up to 20 characters. Here’s how the text would be split:

1. "Hello, this is a sam"
2. "ple text to demonstra"
3. "te the concept of chu"
4. "nk size in text splitt"
5. "ing."

As you can see, each chunk is up to 20 characters long. If a word gets cut off at the end of a chunk, it will be completed in the next chunk. 

Chunk Overlap

Now let’s understand chunk_overlap with the same example.

This time, let’s set chunk_size = 20 and chunk_overlap = 5. This means that each chunk of text will have up to 20 characters, and the last 5 characters of one chunk will be the first 5 characters of the next chunk. Here’s how the text would be split:

"Hello, this is a sam"

" is a sample text to"

" text to demonstrate"

"rate the concept of c"

"ept of chunk size in"

" size in text splitt"

" text splitting."

As you can see, each chunk starts with the last 5 characters of the previous chunk. This overlap can be useful if you’re processing the chunks independently and don’t want to miss any information that spans two chunks.

let’s consider an example where chunk_overlap can be particularly useful.

Suppose we have a text that contains sentences, and we want to split this text into chunks for some kind of processing (like machine learning model training). However, we don’t want to split sentences in the middle, as it could lead to loss of context and meaning. This is where chunk_overlap can be helpful.

Let’s take the following text:

"The quick brown fox jumps over the lazy dog. The dog was not amused. The fox laughed."

We’ll set chunk_size = 20 and chunk_overlap = 10. Here’s how the text would be split:

"The quick brown fox ju"

"ox jumps over the la"

" the lazy dog. The do"

" dog. The dog was not"

" not amused. The fox "

" fox laughed."

As you can see, each chunk starts with the last 10 characters of the previous chunk. This overlap ensures that we don’t lose any sentences in the middle of the chunks. For instance, the sentence "The dog was not amused." is present in its entirety in chunks 3 and 4. This way, when we process each chunk independently, we still retain the full context of each sentence.

When we’re processing text data, especially for tasks like machine learning or natural language processing, it’s important to maintain the context of the information. By “context”, I mean the surrounding text that gives meaning to a word or a sentence.

For example, consider the sentence “The dog was not amused.” If we split this sentence in the middle, like “The dog was” and “not amused”, the two parts separately don’t convey the same meaning as the whole sentence.

Now, let’s consider chunk_overlap. When we split the text into chunks, chunk_overlap ensures that the end of one chunk and the beginning of the next chunk have some common text. This overlapping text could be a complete sentence or a part of a sentence that got split while chunking.

So, if a sentence gets split between two chunks, the chunk_overlap ensures that the complete sentence will still be present in the overlap between the two chunks. This way, when we process each chunk, we still have the complete sentence in some chunk, and we don’t lose the context or meaning of that sentence