Introduction to Embeddings at Cohere

1
import cohere
2
import numpy as np
3
4
co = cohere.ClientV2(api_key="YOUR_API_KEY")
5
6
# get the embeddings
7
phrases = ["i love soup", "soup is my favorite", "london is far away"]
8
9
model = "embed-v4.0"
10
input_type = "search_query"
11
12
res = co.embed(
13
    texts=phrases,
14
    model=model,
15
    input_type=input_type,
16
    output_dimension=1024,
17
    embedding_types=["float"],
18
)
19
20
(soup1, soup2, london) = res.embeddings.float
21
22
23
# compare them
24
def calculate_similarity(a, b):
25
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
26
27
28
print(
29
    f"For the following sentences:\n1: {phrases[0]}\n2: {phrases[1]}\3 The similarity score is: {calculate_similarity(soup1, soup2):.2f}\n"
30
)
31
print(
32
    f"For the following sentences:\n1: {phrases[0]}\n2: {phrases[2]}\3 The similarity score is: {calculate_similarity(soup1, london):.2f}"
33
)

1
import cohere
2
3
co = cohere.ClientV2(api_key="YOUR_API_KEY")
4
5
texts = [
6
    "Hello from Cohere!",
7
    "مرحبًا من كوهير!",
8
    "Hallo von Cohere!",
9
    "Bonjour de Cohere!",
10
    "¡Hola desde Cohere!",
11
    "Olá do Cohere!",
12
    "Ciao da Cohere!",
13
    "您好，来自 Cohere！",
14
    "कोहेरे से नमस्ते!",
15
]
16
17
response = co.embed(
18
    model="embed-v4.0",
19
    texts=texts,
20
    input_type="classification",
21
    output_dimension=1024,
22
    embedding_types=["float"],
23
)
24
25
embeddings = response.embeddings.float  # All text embeddings
26
print(embeddings[0][:5])  # Print embeddings for the first text

1
import cohere
2
from PIL import Image
3
from io import BytesIO
4
import base64
5
6
co = cohere.ClientV2(api_key="YOUR_API_KEY")
7
8
# The model accepts input in base64 as a Data URL
9
10
11
def image_to_base64_data_url(image_path):
12
    # Open the image file
13
    with Image.open(image_path) as img:
14
        image_format = img.format.lower()
15
        buffered = BytesIO()
16
        img.save(buffered, format=img.format)
17
        # Encode the image data in base64
18
        img_base64 = base64.b64encode(buffered.getvalue()).decode(
19
            "utf-8"
20
        )
21
22
    # Create the Data URL with the inferred image type
23
    data_url = f"data:image/{image_format};base64,{img_base64}"
24
    return data_url
25
26
27
base64_url = image_to_base64_data_url("<PATH_TO_IMAGE>")
28
29
input = {
30
    "content": [
31
        {"type": "image_url", "image_url": {"url": base64_url}}
32
    ]
33
}
34
35
res = co.embed(
36
    model="embed-v4.0",
37
    embedding_types=["float"],
38
    input_type="search_document",
39
    inputs=[input],
40
    output_dimension=1024,
41
)
42
43
res.embeddings.float

1
import cohere
2
from PIL import Image
3
from io import BytesIO
4
import base64
5
6
co = cohere.ClientV2(api_key="YOUR_API_KEY")
7
8
# The model accepts input in base64 as a Data URL
9
10
11
def image_to_base64_data_url(image_path):
12
    # Open the image file
13
    with Image.open(image_path) as img:
14
        # Create a BytesIO object to hold the image data in memory
15
        buffered = BytesIO()
16
        # Save the image as PNG to the BytesIO object
17
        img.save(buffered, format="PNG")
18
        # Encode the image data in base64
19
        img_base64 = base64.b64encode(buffered.getvalue()).decode(
20
            "utf-8"
21
        )
22
23
    # Create the Data URL and assumes the original image file type was png
24
    data_url = f"data:image/png;base64,{img_base64}"
25
    return data_url
26
27
28
processed_image = image_to_base64_data_url("<PATH_TO_IMAGE>")
29
30
res = co.embed(
31
    images=[processed_image],
32
    model="embed-v4.0",
33
    embedding_types=["float"],
34
    input_type="image",
35
)
36
37
res.embeddings.float

1
texts = ["hello"]
2
3
response = co.embed(
4
    model="embed-v4.0",
5
    texts=texts,
6
    output_dimension=1024,
7
    input_type="classification",
8
    embedding_types=["float"],
9
).embeddings
10
11
# print out the embeddings
12
response.float  # returns a vector that is 1024 dimensions

1
import cohere
2
import base64
3
4
# Embed an Images and Texts separately
5
with open("./content/finn.jpeg", "rb") as image_file:
6
    encoded_string = base64.b64encode(image_file.read()).decode(
7
        "utf-8"
8
    )
9
10
# Step 3: Format as data URL
11
data_url = f"data:image/jpeg;base64,{encoded_string}"
12
13
example_doc = [
14
    {"type": "text", "text": "This is a Scottish Fold Cat"},
15
    {"type": "image_url", "image_url": {"url": data_url}},
16
]  # This is where we're fusing text and images.
17
18
res = co.embed(
19
    model="embed-v4.0",
20
    inputs=[{"content": example_doc}],
21
    input_type="search_document",
22
    embedding_types=["float"],
23
    output_dimension=1024,
24
).embeddings.float_
25
26
# This will return a list of length 1 with the texts and image in a combined embedding
27
28
res

1
res = co.embed(
2
    texts=["hello_world"],
3
    model="embed-v4.0",
4
    input_type="search_document",
5
    embedding_types=["int8"],
6
)

1
res = co.embed(
2
    texts=phrases,
3
    model="embed-v4.0",
4
    input_type=input_type,
5
    embedding_types=["int8", "float"],
6
)
7
8
res.embeddings.int8  # This contains your int8 embeddings
9
res.embeddings.float  # This contains your float embeddings

1
res = co.embed(
2
    model="embed-v4.0",
3
    texts=["hello"],
4
    input_type="search_document",
5
    embedding_types=["ubinary"],
6
    output_dimension=1024,
7
)
8
print(
9
    f"Embed v4 Binary at 1024 dimensions results in length {len(res.embeddings.ubinary[0])}"
10
)
11
12
query_emb_bin = np.asarray(res.embeddings.ubinary[0], dtype="uint8")
13
query_emb_unpacked = np.unpackbits(query_emb_bin, axis=-1).astype(
14
    "int"
15
)
16
query_emb_unpacked = 2 * query_emb_unpacked - 1
17
print(
18
    f"Embed v4 Binary at 1024 unpacked will have dimensions:{len(query_emb_unpacked)}"
19
)