A Beginner's Guide to Vector Embeddings
Published: 2024-06-21 14:41:16

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/vector-embeddings_172de68f3bd4b79705e48ce693a31d43.jpg" alt="A Beginner&amp;#39;s Guide to Vector Embeddings."/></figure>

In the world of machine learning and natural language processing, vector embeddings are a widely used technique to represent data in a format that captures semantic relationships and similarities and can be easily processed by deep learning algorithms. This data can be text, image, audio, or video.

In this beginner guide, we'll be exploring vector embeddings in more detail.

## What are Vector Embeddings?

What is vector embedding? Vector embeddings are the building blocks of many natural language processing (NLP), recommendation, and [vector search](https://docs.pieces.app/build/glossary/terms/vector-search) algorithms. The day-to-day tools you use, like AI assistants, voice assistants, language translators, or any recommendation tool, are working efficiently due to embeddings.

Vector embeddings are like a special method that turns words, sentences, images, and other data into numbers. These numbers show what data mean and how they relate to each other. Imagine these numbers as points on a map where similar things are close together. This helps computers understand and work with the information more easily.

Vector embeddings represent words or documents as vectors in a multi-dimensional space. Each dimension in the vector space captures different aspects of the semantic meaning of the word or document. For example, in word embeddings trained using techniques like Word2Vec or GloVe, each dimension may correspond to a specific semantic feature such as gender, tense, or sentiment.

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image4_35cc2564a6cf0a1b951fb4b5b8a2e48b.png" alt="A flowchart representation of how queries and training materials are transformed into vectors."/></figure>

Some of the different types of embeddings commonly used in various applications are:

- **Word Embeddings:** These embeddings represent individual words as vectors in a multi-dimensional space, capturing their semantic meanings and relationships with other words. Word2Vec, GloVe, and FastText are common techniques used to generate word embeddings.
- **Document Embeddings:** Document embeddings represent entire documents or paragraphs as vectors. Techniques like Doc2Vec and averaging word embeddings are often used to create document embeddings.
- **Sentence Embeddings:** Similar to document embeddings, sentence embeddings represent individual sentences as vectors. They are useful for tasks like sentence similarity and sentiment analysis.
- **Image Embeddings:** In computer vision, images can be represented as vectors using techniques like convolutional neural networks (CNNs). These embeddings capture the visual features of images and are used in tasks like image classification and object detection.


These are just a few examples of vector embeddings, and new techniques are constantly being developed to address specific use cases and improve performance in various applications. Some more types are knowledge graph embeddings, entity embeddings, audio embeddings, etc.

## The Mathematics Behind Vector Embeddings, Explained

The mathematics behind vector embeddings vary depending on the application, but several mathematical and machine learning concepts and techniques are commonly used when creating them.

For example:

- Vector Space Model (VSM)
- Word Embedding Algorithms (Word2Vec & GloVe)
- Neural Networks
- Dimensionality Reduction
- Distance Metrics
- Optimization Techniques (SGD)
- BERT


Last but not least, as the term suggests, "vector embeddings" are related to vectors. In math, a vector is a set of numbers representing both magnitude and direction. It's like an arrow pointing from the origin to a specific point in space.

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image6_d2bd050b74e2aae7d619760f718f11e8.jpg" alt="The vector at 1,1."/></figure>

As developers, we can think of vectors as arrays with numerical values. In a space filled with vectors, some are close, others distant, and some cluster together while others are scattered. These models, often created with neural networks and labeled data, can handle even high-dimensional vectors that are hard to visualize. In machine learning, these multi-dimensional vectors are like magic, helping us solve various problems, from finding similar items online to organizing data effectively.

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image5_d8d9bbd575dfd0e3ba039eed6c649a7e.jpg" alt="Several vectors on a 4-quadrant graph."/></figure>

Vectors are essential for machine learning, but transforming data into vectors isn't straightforward. We need embedding models (like Word2Vec, BERT & GloVe) to maintain the meaning of the original data. ML algorithms require numerical data to function. We use vector embeddings, which are lists of numbers, to represent various types of data, including audio files or text documents. This allows us to perform operations on them efficiently, simplifying tasks such as analyzing text or processing audio data.

Vector space models are mathematical frameworks used to represent objects or concepts as vectors in a high-dimensional space, sometimes in a vector database.

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image3_9bbeb1c9e6c00fca4d6959941955d1a3.jpg" alt="A visualization of objects going through an embedding model to become vectors."/></figure>

Vector embeddings play a crucial role in capturing semantic information from textual data. One of the key applications of vector embeddings is measuring semantic similarity between words, phrases, or documents. Semantic similarity refers to the degree of closeness or resemblance in meaning between two vectors.

To measure the similarity between two vectors, the cosine similarity formula is commonly used. It calculates the cosine of the angle between the vectors, which represents their direction in multi-dimensional space.

The formula for cosine similarity between two vectors `a` and `b` is given by:

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image1_e99322cb692a34b945bb9dc25727ab15.png" alt="cosine_similarity(a,b) = (a*b)/(||a||*||b||)."/></figure>

Where,

- `a` and `b` are the two vectors we want to compare.
- `•` represents the dot product operation, which calculates the sum of the products of corresponding elements between the two vectors.
- `||a||` and `||b||` represent the magnitude (length) of vectors `a` and `b`, respectively.


Cosine similarity outputs a value between `-1` and `1`. A value of `1` indicates perfect similarity (vectors pointing in the same direction), `0` indicates no correlation (vectors are orthogonal), and `-1` signifies perfect dissimilarity (vectors pointing in opposite directions).

By calculating cosine similarity between vector representations of words, sentences, or even documents, machine learning models can perform tasks like recommendation, identification, and grouping based on the closest semantic meaning.

## Applications of Vector Embeddings

Vector embeddings create efficient data representations because they provide a way to represent complex and high-dimensional data in a simpler format essential for processing and analyzing large datasets effectively. Embeddings significantly enhance machine learning model performance by allowing them to understand data nuances and relationships, particularly in text analysis.

They enable complex tasks like natural language processing and image recognition by converting raw data into a suitable format for algorithms. Moreover, embeddings help build advanced recommendation systems for personalized suggestions and facilitate data visualization and clustering. Additionally, they enable innovative approaches such as [cross-modal search](https://docs.pieces.app/features/search-modes) and retrieval by bridging different data types.

Vector embeddings have a wide range of applications across various fields. Let's explore a few of them in more detail:

1. **Natural Language Processing (NLP):** Vector embeddings are crucial for tasks like sentiment analysis, [question answering](https://code.pieces.app/blog/question-answering-on-source-code-repositories), [neural machine translation](https://docs.pieces.app/build/glossary/terms/neural-machine-translation), and other tasks that demand efficient processing of textual data, such as [NLP chatbots](https://code.pieces.app/blog/nlp-chatbots-an-overview-of-natural-language-processing-in-chatbot-technology).
1. **Personalized Recommendation Systems:** Vector embeddings power recommendation systems by capturing user preferences and item characteristics, leading to tailored content suggestions, as seen in platforms like Netflix.
1. **Visual Content Analysis:** Vector embeddings enhance image classification, object detection, and similarity searches, contributing to advancements in image recognition technologies like Google Lens.
1. **Anomaly Detection:** Utilizing embeddings, anomaly detection algorithms identify unusual patterns in various data types, aiding in cybersecurity applications by detecting deviations from normal behavior.
1. **Search Engines:** Vector embeddings power semantic search capabilities in search engines such as Pieces’ [Global Search](https://docs.pieces.app/features/global-search), allowing for relevant web page retrieval, spelling correction, and related query suggestions based on semantic relationships.


From a developer's perspective, the challenge often lies in efficiently handling unstructured data. Traditional applications rely on structured data represented as objects with properties, which may grow over time. As these objects become "fat" with numerous properties, selecting essential features becomes vital for optimal application performance. This process, known as feature engineering, involves creating specialized representations of objects tailored to specific tasks.

However, when dealing with unstructured data like text or images, manual feature engineering becomes impractical due to the abundance of relevant features. In such cases, vector embeddings offer an automated solution. Instead of manually selecting features, developers can utilize pre-trained machine learning models to generate compact representations of the data while preserving its meaningful characteristics. This approach streamlines the handling of unstructured data, allowing developers to extract valuable insights without extensive manual intervention.

## How to Create Embeddings

We will be using the Hugging Face[ sentence-transformers](https://www.sbert.net/) model[ all-MiniLM-L6-v2](https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2) to create sentence embeddings. `all-MiniLM-L6-v2` is a pre-trained model available in the Sentence Transformers library, which is built on top of the Hugging Face Transformers library. It provides a high-level API for generating sentence embeddings using pre-trained transformer models from the Hugging Face Model Hub. The `all-MiniLM-L6-v2` model is based on the MiniLM architecture, which is a smaller and faster version of the popular BERT architecture.

This model maps sentences & paragraphs to a 384-dimensional dense vector space and can be used for tasks like clustering or semantic search.

Let's create sentence embeddings!

**Step 1:** Install the Sentence Transformers library:

```
pip install sentence-transformers
```

**Step 2:** Import the SentenceTransformer class:

```
from sentence_transformers import SentenceTransformer
```

**Step 3:** Load a pre-trained model:

```
model = SentenceTransformer('all-MiniLM-L6-v2')
```

**Step 4:** Generate embeddings for some example sentences:

```
sentences = ['You are reading Pieces Blog.', 'You are using the right tool.']
embeddings = model.encode(sentences)
```

**Step 5:** Print the generated sentence embeddings:

```
print(embeddings)
```

<figure><img src="https://d37oebn0w9ir6a.cloudfront.net/account_32099/image2_559a812be3fb4bfbeb53a20142d833cd.png" alt="The vector embeddings of the input sentence above."/></figure>

As you can see in the above image output, you've successfully generated sentence embeddings using the Sentence Transformers library. The output is a NumPy array of shape `(2, 384)`, meaning each of the resulting sentence embeddings has 384 dimensions and each row corresponds to a sentence embedding.

## Conclusion

With the increasing use and development of AI, vector embeddings are going to be widely used in various applications in the ML field. Vector embeddings are a very powerful and important tool for developers to work with complex data. Any AI apps you use or see work effectively due to vector embeddings.

Vector embeddings are widely used in Pieces for Developers too; for example, you can check our [state-of-the-art OCR](https://code.pieces.app/blog/top-ocr-tools) feature that [extracts code from images](https://pieces.app/features/extract). Text embeddings are used to provide better code suggestions and explanations, among many other features.