Embeddings vectoriales

New embedding models

text-embedding-3-small and text-embedding-3-large, our newest and most performant embedding models, are now available. They feature lower costs, higher multilingual performance, and new parameters to control the overall size.

¿Qué son los embeddings?

Los embeddings de texto de OpenAI miden el grado de relación entre cadenas de texto. Los embeddings se usan comúnmente para:

Buscar (los resultados se ordenan según su relevancia para una cadena de consulta)
Agrupamiento (las cadenas de texto se agrupan por similitud)
Recomendaciones (se recomiendan elementos con cadenas de texto relacionadas)
Detección de anomalías (se identifican valores atípicos con poca relación con los demás)
Medición de la diversidad (se analizan las distribuciones de similitud)
Clasificación (las cadenas de texto se clasifican según la etiqueta más similar a ellas)

Un embedding es un vector (lista) de números de punto flotante. La distancia entre dos vectores mide su grado de relación. Las distancias pequeñas sugieren una mayor relación y las distancias grandes sugieren una menor relación.

Visita nuestra página de precios para conocer los precios de los embeddings. Las solicitudes se facturan según la cantidad de tokens en la entrada.

Cómo obtener embeddings

Para obtener un embedding, envía tu cadena de texto al punto de acceso de la API de embeddings junto con el nombre del modelo de embeddings (por ejemplo, text-embedding-3-small):

Ejemplo: obtener embeddings

JavaScript

1
2
3
4
5
6
7
8
9
10import OpenAI from "openai";
const openai = new OpenAI();

const embedding = await openai.embeddings.create({
  model: "text-embedding-3-small",
  input: "Your text string goes here",
  encoding_format: "float",
});

console.log(embedding);

1
2
3
4
5
6
7
8
9from openai import OpenAI

client = OpenAI()

response = client.embeddings.create(
    input="Your text string goes here", model="text-embedding-3-small"
)

print(response.data[0].embedding)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24package main

import (
	"context"
	"fmt"

	"github.com/openai/openai-go/v3"
)

func main() {
	client := openai.NewClient()

	embedding, err := client.Embeddings.New(context.Background(), openai.EmbeddingNewParams{
		Model: openai.EmbeddingModelTextEmbedding3Small,
		Input: openai.EmbeddingNewParamsInputUnion{
			OfString: openai.String("Your text string goes here."),
		},
	})
	if err != nil {
		panic(err)
	}

	fmt.Println(len(embedding.Data[0].Embedding))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;

var embedding =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .input("The food was delicious and the waiter...")
                .build());

System.out.println(embedding.data().get(0).embedding());

1
2
3
4
5
6
7
8
9
10
11using OpenAI.Embeddings;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "text-embedding-3-small";
EmbeddingClient client = new(model, key);

OpenAIEmbedding embedding = await client.GenerateEmbeddingAsync(
    "The food was delicious and the waiter was friendly."
);

Console.WriteLine($"Dimensions: {embedding.ToFloats().Length}");

1
2
3
4
5
6
7
8
9
10require "openai"

client = OpenAI::Client.new

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: "The food was delicious and the waiter..."
)

puts(response.data.fetch(0).embedding)

1
2
3
4
5
6
7curl https://api.openai.com/v1/embeddings \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -d '{
    "input": "Your text string goes here",
    "model": "text-embedding-3-small"
  }'

La respuesta contiene el vector de embedding (lista de números de punto flotante) junto con algunos metadatos adicionales. Puedes extraer el vector de embedding, guardarlo en una base de datos vectorial y utilizarlo en muchos casos de uso diferentes.

123456789101112131415161718{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": [
        -0.006929283495992422, -0.005336422007530928, -4.547132266452536e-5,
        -0.024047505110502243
      ]
    }
  ],
  "model": "text-embedding-3-small",
  "usage": {
    "prompt_tokens": 5,
    "total_tokens": 5
  }
}

De forma predeterminada, la longitud del vector de embedding es de 1536 para text-embedding-3-small o de 3072 para text-embedding-3-large. Para reducir las dimensiones del embedding sin perder sus propiedades de representación de conceptos, proporciona el parámetro dimensions. Encontrarás más información sobre las dimensiones de los embeddings en la sección de casos de uso de embeddings.

Modelos de embeddings

OpenAI ofrece dos potentes modelos de embeddings de tercera generación (identificados con -3 en el ID del modelo). Lee la publicación del anuncio en el blog sobre los embeddings v3 para obtener más información.

El uso se cobra por token de entrada. A continuación se muestra un ejemplo de cuántas páginas de texto se pueden procesar por dólar estadounidense (suponiendo unos 800 tokens por página):

Modelo	~ Páginas por dólar	Rendimiento en la evaluación MTEB	Entrada máxima
text-embedding-3-small	62 500	62,3 %	8192
text-embedding-3-large	9615	64,6 %	8192
text-embedding-ada-002	12 500	61,0 %	8192

Casos de uso

Aquí mostramos algunos casos de uso representativos con el conjunto de datos de reseñas de alimentos gourmet de Amazon.

Obtener los embeddings

El conjunto de datos contiene un total de 568 454 reseñas de alimentos publicadas por usuarios de Amazon hasta octubre de 2012. Usamos un subconjunto de las 1000 reseñas más recientes a modo de ejemplo. Las reseñas están en inglés y tienden a ser positivas o negativas. Cada reseña tiene un ProductId, un UserId, un Score, un título (Summary) y un cuerpo (Text). Por ejemplo:

ID del producto	ID del usuario	Puntuación	Resumen	Texto
B001E4KFG0	A3SGXH7AUHU8GW	5	Alimento para perros de buena calidad	He comprado varios de los productos enlatados de Vitality...
B00813GRG4	A1D87F6ZCVE5NK	1	No es como se anuncia	El producto llegó etiquetado como maní salado jumbo...

A continuación, combinamos el resumen y el texto de la reseña en un solo texto. El modelo codifica este texto combinado y genera un único embedding vectorial.

Get_embeddings_from_dataset.ipynb

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import { mkdir, writeFile } from "node:fs/promises";
import OpenAI from "openai";

const client = new OpenAI();
const reviews = ["A rich cup of coffee.", "A bright herbal tea."];

const response = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: reviews.map((review) => review.replaceAll("\n", " ")),
});

const csvField = (value) => `"${value.replaceAll('"', '""')}"`;
const rows = response.data.map(({ embedding }, index) =>
  [csvField(reviews[index]), csvField(JSON.stringify(embedding))].join(",")
);

await mkdir("output", { recursive: true });
await writeFile(
  "output/embedded_1k_reviews.csv",
  ["combined,ada_embedding", ...rows].join("\n") + "\n"
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14from openai import OpenAI

client = OpenAI()


def get_embedding(text, model="text-embedding-3-small"):
    text = text.replace("\n", " ")
    return client.embeddings.create(input=[text], model=model).data[0].embedding


df["ada_embedding"] = df.combined.apply(
    lambda x: get_embedding(x, model="text-embedding-3-small")
)
df.to_csv("output/embedded_1k_reviews.csv", index=False)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

static String csvField(String value) {
  return "\"" + value.replace("\"", "\"\"") + "\"";
}

List<String> reviews = List.of("A rich cup of coffee.", "A bright herbal tea.");
Path output = Path.of("output", "embedded_1k_reviews.csv");
Files.createDirectories(output.getParent());
try (var writer = Files.newBufferedWriter(output)) {
  writer.write("combined,ada_embedding\n");
  for (String review : reviews) {
    var embedding =
        client
            .embeddings()
            .create(
                EmbeddingCreateParams.builder()
                    .model("text-embedding-3-small")
                    .inputOfArrayOfStrings(List.of(review.replace("\n", " ")))
                    .build())
            .data()
            .get(0)
            .embedding();
    writer.write(csvField(review) + "," + csvField(embedding.toString()) + "\n");
  }
}
System.out.println(output);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20require "csv"
require "fileutils"
require "json"
require "openai"

client = OpenAI::Client.new
reviews = ["A rich cup of coffee.", "A bright herbal tea."]

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: reviews.map { |review| review.tr("\n", " ") }
)

FileUtils.mkdir_p("output")
CSV.open("output/embedded_1k_reviews.csv", "w") do |csv|
  csv << ["combined", "ada_embedding"]
  response.data.each do |embedding|
    csv << [reviews.fetch(embedding.index), JSON.generate(embedding.embedding)]
  end
end

Para cargar los datos desde un archivo guardado, puedes ejecutar lo siguiente:

1
2
3
4import pandas as pd

df = pd.read_csv("output/embedded_1k_reviews.csv")
df["ada_embedding"] = df.ada_embedding.apply(eval).apply(np.array)

Usar embeddings más grandes, por ejemplo, almacenándolos en un almacén vectorial para su recuperación, suele costar más y consumir más recursos de cómputo, memoria y almacenamiento que usar embeddings más pequeños.

Nuestros dos nuevos modelos de embeddings se entrenaron con una técnica que permite a los desarrolladores equilibrar el rendimiento y el costo de usar embeddings. En concreto, los desarrolladores pueden acortar los embeddings (es decir, eliminar algunos números del final de la secuencia) sin que pierdan su capacidad de representar conceptos, mediante el parámetro dimensions de la API. Por ejemplo, en la evaluación MTEB, un embedding de text-embedding-3-large puede reducirse a un tamaño de 256 y aun así superar el rendimiento de un embedding de text-embedding-ada-002 sin acortar, con un tamaño de 1536. Puedes leer más sobre cómo los cambios en las dimensiones afectan el rendimiento en nuestra publicación del blog sobre el lanzamiento de embeddings v3.

En general, se recomienda usar el parámetro dimensions al crear el embedding. En ciertos casos, es posible que necesites cambiar la dimensionalidad del embedding después de generarlo. Cuando la cambies manualmente, asegúrate de normalizar las dimensiones del embedding como se muestra a continuación.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import OpenAI from "openai";

const client = new OpenAI();

const response = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: "Testing 123",
  encoding_format: "float",
});

const shortened = response.data[0].embedding.slice(0, 256);
const magnitude = Math.hypot(...shortened);
const normalized = shortened.map((value) =>
  magnitude === 0 ? 0 : value / magnitude
);

console.log(normalized);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26from openai import OpenAI
import numpy as np

client = OpenAI()


def normalize_l2(x):
    x = np.array(x)
    if x.ndim == 1:
        norm = np.linalg.norm(x)
        if norm == 0:
            return x
        return x / norm
    else:
        norm = np.linalg.norm(x, 2, axis=1, keepdims=True)
        return np.where(norm == 0, x, x / norm)


response = client.embeddings.create(
    model="text-embedding-3-small", input="Testing 123", encoding_format="float"
)

cut_dim = response.data[0].embedding[:256]
norm_dim = normalize_l2(cut_dim)

print(norm_dim)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.util.List;

private static List<Double> normalizeL2(List<Float> embedding) {
  double norm = Math.sqrt(embedding.stream().mapToDouble(value -> value * value).sum());
  return embedding.stream().map(value -> norm == 0 ? 0.0 : value / norm).toList();
}

var embedding =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .input("Testing 123")
                .encodingFormat(EmbeddingCreateParams.EncodingFormat.FLOAT)
                .build());

List<Float> shortened = embedding.data().get(0).embedding().subList(0, 256);
System.out.println(normalizeL2(shortened));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20using OpenAI.Embeddings;

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
string model = "text-embedding-3-small";
EmbeddingClient client = new(model, key);

OpenAIEmbedding embedding = await client.GenerateEmbeddingAsync("Testing 123");

float[] shortened = embedding.ToFloats().Span[..256].ToArray();
double magnitude = Math.Sqrt(shortened.Sum(value => value * value));
float[] normalized =
    magnitude == 0
        ? shortened
        : shortened.Select(value => (float)(value / magnitude)).ToArray();

Console.WriteLine($"Dimensions: {normalized.Length}");
Console.WriteLine($"First value: {normalized[0]:F6}");
Console.WriteLine(
    $"L2 norm: {Math.Sqrt(normalized.Sum(value => value * value)):F3}"
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15require "openai"

client = OpenAI::Client.new

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: "Testing 123",
  encoding_format: :float
)

shortened = response.data.fetch(0).embedding.first(256)
magnitude = Math.sqrt(shortened.sum { |value| value**2 })
normalized = shortened.map { |value| magnitude.zero? ? 0 : value / magnitude }

puts(normalized)

Cambiar las dimensiones de forma dinámica permite un uso muy flexible. Por ejemplo, al usar un almacén de datos vectoriales que solo admite embeddings de hasta 1024 dimensiones, los desarrolladores ahora pueden usar nuestro mejor modelo de embeddings, text-embedding-3-large, y especificar un valor de 1024 para el parámetro dimensions de la API. Esto acorta el embedding desde sus 3072 dimensiones originales y sacrifica algo de exactitud a cambio de un vector más pequeño.

Question_answering_using_embeddings.ipynb

En muchos casos habituales, el modelo no se entrenó con datos que contengan los hechos y la información clave que quieres que estén disponibles al generar respuestas a una consulta del usuario. Una forma de resolver esto, como se muestra a continuación, es agregar información a la ventana de contexto del modelo. Esto es eficaz en muchos casos de uso, pero aumenta el costo en tokens. En este notebook, exploramos las ventajas y desventajas de este enfoque frente a la búsqueda basada en embeddings.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25import OpenAI from "openai";

const client = new OpenAI();
const article =
  "At the 2022 Winter Olympics, Great Britain won women's curling and Sweden won men's curling.";
const question = `Use the article below to answer the question. If the answer cannot be found, say "I don't know."

Article:
${article}

Question: Which athletes won the gold medal in curling at the 2022 Winter Olympics?`;

const response = await client.chat.completions.create({
  model: "gpt-4.1-mini",
  messages: [
    {
      role: "system",
      content: "You answer questions about the 2022 Winter Olympics.",
    },
    { role: "user", content: question },
  ],
  temperature: 0,
});

console.log(response.choices[0].message.content);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22query = f"""Use the below article on the 2022 Winter Olympics to answer the subsequent question. If the answer cannot be found, write "I don't know."

Article:
\"\"\"
{wikipedia_article_on_curling}
\"\"\"

Question: Which athletes won the gold medal in curling at the 2022 Winter Olympics?"""

response = client.chat.completions.create(
    messages=[
        {
            "role": "system",
            "content": "You answer questions about the 2022 Winter Olympics.",
        },
        {"role": "user", "content": query},
    ],
    model=GPT_MODEL,
    temperature=0,
)

print(response.choices[0].message.content)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionCreateParams;

String article =
    "At the 2022 Winter Olympics, Great Britain won women's curling and Sweden won men's curling.";
String question =
    "Use the below article on the 2022 Winter Olympics to answer the subsequent question. "
        + "If the answer cannot be found, write \"I don't know.\"\n\n"
        + "Article:\n"
        + article
        + "\n\nQuestion: Which athletes won the gold medal in curling at the 2022 Winter Olympics?";

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-4.1-mini")
        .addSystemMessage("You answer questions about the 2022 Winter Olympics.")
        .addUserMessage(question)
        .temperature(0)
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29require "openai"

client = OpenAI::Client.new
article = "At the 2022 Winter Olympics, Great Britain won women's curling and Sweden won men's curling."
question = <<~QUESTION
  Use the article below to answer the question. If the answer cannot be found, say "I don't know."

  Article:
  #{article}

  Question: Which athletes won the gold medal in curling at the 2022 Winter Olympics?
QUESTION

response = client.chat.completions.create(
  model: "gpt-4.1-mini",
  messages: [
    {
      role: :system,
      content: "You answer questions about the 2022 Winter Olympics."
    },
    {
      role: :user,
      content: question
    }
  ],
  temperature: 0
)

puts(response.choices.fetch(0).message.content)

Semantic_text_search_using_embeddings.ipynb

Para recuperar los documentos más relevantes, usamos la similitud del coseno entre los vectores de embeddings de la consulta y de cada documento, y devolvemos los documentos con las puntuaciones más altas.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import OpenAI from "openai";

const client = new OpenAI();
const reviews = [
  "A rich cup of coffee.",
  "Smooth beans in tomato sauce.",
  "Dark chocolate with orange.",
];

const { data } = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: [...reviews, "delicious beans"],
});

const query = data.at(-1).embedding;
const similarity = (embedding) => {
  const dotProduct = embedding.reduce(
    (total, value, index) => total + value * query[index],
    0
  );
  return dotProduct / (Math.hypot(...embedding) * Math.hypot(...query));
};

const results = reviews
  .map((review, index) => ({
    review,
    score: similarity(data[index].embedding),
  }))
  .sort((left, right) => right.score - left.score)
  .slice(0, 3);

console.log(results);

1
2
3
4
5
6
7
8
9
10def search_reviews(df, product_description, n=3, pprint=True):
    embedding = get_embedding(product_description, model="text-embedding-3-small")
    df["similarities"] = df.ada_embedding.apply(
        lambda x: cosine_similarity(x, embedding)
    )
    res = df.sort_values("similarities", ascending=False).head(n)
    return res


res = search_reviews(df, "delicious beans", n=3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;

List<String> reviews =
    List.of(
        "A rich cup of coffee.",
        "Smooth beans in tomato sauce.",
        "Dark chocolate with orange.");
var reviewEmbeddings =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .inputOfArrayOfStrings(reviews)
                .build())
        .data();
List<Float> query =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .inputOfArrayOfStrings(List.of("delicious beans"))
                .build())
        .data()
        .get(0)
        .embedding();

IntStream.range(0, reviews.size())
    .boxed()
    .sorted(
        Comparator.comparingDouble(
                (Integer index) ->
                    cosineSimilarity(query, reviewEmbeddings.get(index).embedding()))
            .reversed())
    .limit(3)
    .map(reviews::get)
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30require "openai"

client = OpenAI::Client.new
reviews = [
  "A rich cup of coffee.",
  "Smooth beans in tomato sauce.",
  "Dark chocolate with orange."
]

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: reviews + ["delicious beans"]
)

query = response.data.fetch(-1).embedding
similarity = lambda do |embedding|
  dot_product = embedding.zip(query).sum { |value, query_value| value * query_value }
  magnitude = Math.sqrt(embedding.sum { |value| value**2 })
  query_magnitude = Math.sqrt(query.sum { |value| value**2 })
  dot_product / (magnitude * query_magnitude)
end

results = reviews.map.with_index do |review, index|
  {
    review: review,
    score: similarity.call(response.data.fetch(index).embedding)
  }
end.sort_by { |result| -result.fetch(:score) }.first(3)

puts(results)

Code_search.ipynb

La búsqueda de código funciona de manera similar a la búsqueda de texto basada en embeddings. Proporcionamos un método para extraer funciones de Python de todos los archivos de Python de un repositorio determinado. Luego, cada función se indexa con el modelo text-embedding-3-small.

Para realizar una búsqueda de código, generamos un embedding de la consulta en lenguaje natural con el mismo modelo. Luego, calculamos la similitud del coseno entre el embedding resultante de la consulta y cada uno de los embeddings de las funciones. Los resultados con mayor similitud del coseno son los más relevantes.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import OpenAI from "openai";

const client = new OpenAI();
const functions = [
  "function add(a, b) { return a + b; }",
  "function complete(prompt) { return prompt; }",
];

const { data } = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: [...functions, "Completions API tests"],
});

const query = data.at(-1).embedding;
const similarity = (embedding) => {
  const dotProduct = embedding.reduce(
    (total, value, index) => total + value * query[index],
    0
  );
  return dotProduct / (Math.hypot(...embedding) * Math.hypot(...query));
};

const results = functions
  .map((source, index) => ({
    source,
    score: similarity(data[index].embedding),
  }))
  .sort((left, right) => right.score - left.score);

console.log(results);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16df["code_embedding"] = df["code"].apply(
    lambda x: get_embedding(x, model="text-embedding-3-small")
)


def search_functions(df, code_query, n=3, pprint=True, n_lines=7):
    embedding = get_embedding(code_query, model="text-embedding-3-small")
    df["similarities"] = df.code_embedding.apply(
        lambda x: cosine_similarity(x, embedding)
    )

    res = df.sort_values("similarities", ascending=False).head(n)
    return res


res = search_functions(df, "Completions API tests", n=3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;

List<String> functions =
    List.of("def add(a, b): return a + b", "def complete(prompt): return prompt");
var functionEmbeddings =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .inputOfArrayOfStrings(functions)
                .build())
        .data();
List<Float> query =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .input("Completions API tests")
                .build())
        .data()
        .get(0)
        .embedding();
IntStream.range(0, functions.size())
    .boxed()
    .sorted(
        Comparator.comparingDouble(
                (Integer index) ->
                    cosineSimilarity(query, functionEmbeddings.get(index).embedding()))
            .reversed())
    .map(functions::get)
    .forEach(System.out::println);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29require "openai"

client = OpenAI::Client.new
functions = [
  "function add(a, b) { return a + b; }",
  "function complete(prompt) { return prompt; }"
]

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: functions + ["Completions API tests"]
)

query = response.data.fetch(-1).embedding
similarity = lambda do |embedding|
  dot_product = embedding.zip(query).sum { |value, query_value| value * query_value }
  magnitude = Math.sqrt(embedding.sum { |value| value**2 })
  query_magnitude = Math.sqrt(query.sum { |value| value**2 })
  dot_product / (magnitude * query_magnitude)
end

results = functions.map.with_index do |source, index|
  {
    source: source,
    score: similarity.call(response.data.fetch(index).embedding)
  }
end.sort_by { |result| -result.fetch(:score) }

puts(results)

Recommendation_using_embeddings.ipynb

Como las distancias más cortas entre los vectores de embeddings representan una mayor similitud, los embeddings pueden ser útiles para generar recomendaciones.

A continuación, mostramos un sistema básico de recomendaciones. Recibe una lista de cadenas y una cadena de “referencia”, calcula sus embeddings y devuelve las cadenas ordenadas de mayor a menor similitud. Como ejemplo concreto, el notebook enlazado a continuación aplica una versión de esta función al conjunto de datos de noticias AG (reducido a una muestra de 2000 descripciones de artículos de noticias) para devolver los 5 artículos más similares a un artículo de referencia determinado.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28import OpenAI from "openai";

const client = new OpenAI();
const strings = [
  "A cheetah is a fast land animal.",
  "A peregrine falcon is a fast bird.",
  "A tortoise moves slowly.",
];

const { data } = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: strings,
});

const query = data[0].embedding;
const recommendations = data
  .map(({ embedding }, index) => {
    const dotProduct = embedding.reduce(
      (total, value, dimension) => total + value * query[dimension],
      0
    );
    const similarity =
      dotProduct / (Math.hypot(...embedding) * Math.hypot(...query));
    return { index, text: strings[index], similarity };
  })
  .sort((left, right) => right.similarity - left.similarity);

console.log(recommendations);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23def recommendations_from_strings(
    strings: list[str],
    index_of_source_string: int,
    model="text-embedding-3-small",
) -> list[int]:
    """Return nearest neighbors of a given string."""

    # get embeddings for all strings
    embeddings = [embedding_from_string(string, model=model) for string in strings]

    # get the embedding of the source string
    query_embedding = embeddings[index_of_source_string]

    # get distances between the source embedding and other embeddings (function from embeddings_utils.py)
    distances = distances_from_embeddings(
        query_embedding, embeddings, distance_metric="cosine"
    )

    # get indices of nearest neighbors (function from embeddings_utils.py)
    indices_of_nearest_neighbors = indices_of_nearest_neighbors_from_distances(
        distances
    )
    return indices_of_nearest_neighbors

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;

List<String> strings =
    List.of(
        "A cheetah is a fast land animal.",
        "A peregrine falcon is a fast bird.",
        "A tortoise moves slowly.");

var embeddings =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .inputOfArrayOfStrings(strings)
                .build())
        .data();

List<Float> query = embeddings.get(0).embedding();
var nearestNeighbors =
    IntStream.range(0, embeddings.size())
        .boxed()
        .sorted(
            Comparator.comparingDouble(
                (Integer index) -> {
                  List<Float> candidate = embeddings.get(index).embedding();
                  double dotProduct = 0;
                  double queryMagnitude = 0;
                  double candidateMagnitude = 0;
                  for (int dimension = 0; dimension < query.size(); dimension++) {
                    dotProduct += query.get(dimension) * candidate.get(dimension);
                    queryMagnitude += query.get(dimension) * query.get(dimension);
                    candidateMagnitude += candidate.get(dimension) * candidate.get(dimension);
                  }
                  return 1 - dotProduct / Math.sqrt(queryMagnitude * candidateMagnitude);
                }))
        .toList();

System.out.println(nearestNeighbors);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31require "openai"

client = OpenAI::Client.new
strings = [
  "A cheetah is a fast land animal.",
  "A peregrine falcon is a fast bird.",
  "A tortoise moves slowly."
]

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: strings
)

query = response.data.fetch(0).embedding
similarity = lambda do |embedding|
  dot_product = embedding.zip(query).sum { |value, query_value| value * query_value }
  magnitude = Math.sqrt(embedding.sum { |value| value**2 })
  query_magnitude = Math.sqrt(query.sum { |value| value**2 })
  dot_product / (magnitude * query_magnitude)
end

recommendations = response.data.map.with_index do |embedding, index|
  {
    index: index,
    text: strings.fetch(index),
    similarity: similarity.call(embedding.embedding)
  }
end.sort_by { |recommendation| -recommendation.fetch(:similarity) }

puts(recommendations)

Visualizing_embeddings_in_2D.ipynb

El tamaño de los embeddings varía según la complejidad del modelo subyacente. Para visualizar estos datos de alta dimensionalidad, usamos el algoritmo t-SNE para transformarlos a dos dimensiones.

Asignamos un color a cada reseña según la calificación en estrellas que le dio su autor:

1 estrella: rojo
2 estrellas: naranja oscuro
3 estrellas: dorado
4 estrellas: turquesa
5 estrellas: verde oscuro

Calificaciones de Amazon visualizadas a partir del lenguaje mediante t-SNE

La visualización parece haber producido aproximadamente 3 grupos, uno de los cuales contiene principalmente reseñas negativas.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import numpy as np
import pandas as pd
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
import matplotlib

df = pd.read_csv("output/embedded_1k_reviews.csv")
matrix = np.array(df.ada_embedding.apply(eval).to_list())

# Create a t-SNE model and transform the data
tsne = TSNE(
    n_components=2, perplexity=15, random_state=42, init="random", learning_rate=200
)
vis_dims = tsne.fit_transform(matrix)

colors = ["red", "darkorange", "gold", "turquoise", "darkgreen"]
x = [x for x, y in vis_dims]
y = [y for x, y in vis_dims]
color_indices = df.Score.values - 1

colormap = matplotlib.colors.ListedColormap(colors)
plt.scatter(x, y, c=color_indices, cmap=colormap, alpha=0.3)
plt.title("Amazon ratings visualized in language using t-SNE")

Regression_using_embeddings.ipynb

Un embedding puede usarse como codificador general de características de texto libre dentro de un modelo de aprendizaje automático. Incorporar embeddings mejorará el rendimiento de cualquier modelo de aprendizaje automático si algunas de las entradas relevantes son texto libre. Un embedding también puede usarse como codificador de características categóricas dentro de un modelo de aprendizaje automático. Esto aporta más valor cuando los nombres de las variables categóricas tienen significado y son numerosos, como los nombres de puestos de trabajo. Los embeddings de similitud suelen ofrecer un mejor rendimiento que los embeddings de búsqueda para esta tarea.

Observamos que, en general, la representación mediante embeddings es muy rica y concentra mucha información. Por ejemplo, reducir la dimensionalidad de las entradas mediante SVD o PCA, incluso en un 10 %, suele empeorar el rendimiento en tareas específicas posteriores.

Este código divide los datos en un conjunto de entrenamiento y uno de prueba, que se usarán en los dos casos de uso siguientes: regresión y clasificación.

1
2
3
4
5from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    list(df.ada_embedding.values), df.Score, test_size=0.2, random_state=42
)

Regresión con las características de los embeddings

Los embeddings ofrecen una forma elegante de predecir un valor numérico. En este ejemplo, predecimos la calificación en estrellas que dio el autor a partir del texto de su reseña. Como los embeddings contienen mucha información semántica, la predicción es aceptable incluso con muy pocas reseñas.

Suponemos que la calificación es una variable continua entre 1 y 5, y permitimos que el algoritmo prediga cualquier valor de punto flotante. El algoritmo de aprendizaje automático minimiza la distancia entre el valor predicho y la calificación real, y alcanza un error absoluto medio de 0,39. Esto significa que, en promedio, la predicción se desvía menos de media estrella.

1
2
3
4
5from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=100)
rfr.fit(X_train, y_train)
preds = rfr.predict(X_test)

Classification_using_embeddings.ipynb

Esta vez, en lugar de hacer que el algoritmo prediga cualquier valor entre 1 y 5, intentaremos clasificar las reseñas según su número exacto de estrellas en 5 categorías, de 1 a 5 estrellas.

Tras el entrenamiento, el modelo aprende a predecir las reseñas de 1 y 5 estrellas mucho mejor que las reseñas con más matices (de 2 a 4 estrellas), probablemente porque expresan sentimientos más extremos.

1
2
3
4
5
6from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score

clf = RandomForestClassifier(n_estimators=100)
clf.fit(X_train, y_train)
preds = clf.predict(X_test)

Zero-shot_classification_with_embeddings.ipynb

Podemos usar embeddings para realizar una clasificación sin ejemplos, sin datos de entrenamiento etiquetados. Para cada clase, generamos un embedding de su nombre o de una descripción breve. Para clasificar un texto nuevo sin ejemplos, comparamos su embedding con los de todas las clases y predecimos la clase con mayor similitud.

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21import OpenAI from "openai";

const client = new OpenAI();
const labels = ["negative", "positive"];

const { data } = await client.embeddings.create({
  model: "text-embedding-3-small",
  input: [...labels, "The coffee arrived quickly and tastes great."],
});

const review = data.at(-1).embedding;
const similarity = (embedding) => {
  const dotProduct = embedding.reduce(
    (total, value, index) => total + value * review[index],
    0
  );
  return dotProduct / (Math.hypot(...embedding) * Math.hypot(...review));
};

const [negative, positive] = data.map(({ embedding }) => similarity(embedding));
console.log(positive > negative ? "positive" : "negative");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18df = df[df.Score != 3]
df["sentiment"] = df.Score.replace(
    {1: "negative", 2: "negative", 4: "positive", 5: "positive"}
)

labels = ["negative", "positive"]
label_embeddings = [get_embedding(label, model=model) for label in labels]


def label_score(review_embedding, label_embeddings):
    return cosine_similarity(review_embedding, label_embeddings[1]) - cosine_similarity(
        review_embedding, label_embeddings[0]
    )


prediction = (
    "positive" if label_score(get_embedding("Sample Review", model=model), label_embeddings) > 0 else "negative"
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.embeddings.EmbeddingCreateParams;
import java.util.List;

var embeddings =
    client
        .embeddings()
        .create(
            EmbeddingCreateParams.builder()
                .model("text-embedding-3-small")
                .inputOfArrayOfStrings(List.of("negative", "positive", "Sample Review"))
                .build())
        .data();

List<Float> review = embeddings.get(2).embedding();
double negative = cosineSimilarity(review, embeddings.get(0).embedding());
double positive = cosineSimilarity(review, embeddings.get(1).embedding());
System.out.println(positive > negative ? "positive" : "negative");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22require "openai"

client = OpenAI::Client.new
labels = ["negative", "positive"]

response = client.embeddings.create(
  model: "text-embedding-3-small",
  input: labels + ["The coffee arrived quickly and tastes great."]
)

review = response.data.fetch(-1).embedding
similarity = lambda do |embedding|
  dot_product = embedding.zip(review).sum { |value, review_value| value * review_value }
  magnitude = Math.sqrt(embedding.sum { |value| value**2 })
  review_magnitude = Math.sqrt(review.sum { |value| value**2 })
  dot_product / (magnitude * review_magnitude)
end

negative, positive = response.data.first(2).map do |embedding|
  similarity.call(embedding.embedding)
end
puts((positive > negative) ? "positive" : "negative")

User_and_product_embeddings.ipynb

Podemos obtener el embedding de un usuario calculando el promedio de todas sus reseñas. Del mismo modo, podemos obtener el embedding de un producto calculando el promedio de todas las reseñas sobre ese producto. Para mostrar la utilidad de este enfoque, usamos un subconjunto de 50 000 reseñas que nos permite abarcar más reseñas por usuario y por producto.

Evaluamos la utilidad de estos embeddings con un conjunto de prueba independiente, en el que graficamos la similitud entre el embedding del usuario y el del producto en función de la calificación. Curiosamente, con este enfoque podemos predecir si al usuario le gustaría el producto con una precisión superior al azar, incluso antes de que lo reciba.

Diagrama de cajas agrupado por calificación

user_embeddings = df.groupby("UserId").ada_embedding.apply(np.mean)
prod_embeddings = df.groupby("ProductId").ada_embedding.apply(np.mean)

Clustering.ipynb

El agrupamiento es una forma de dar sentido a un gran volumen de datos textuales. Los embeddings son útiles para esta tarea porque proporcionan representaciones vectoriales que capturan el significado de cada texto. Así, el agrupamiento permite descubrir grupos ocultos en nuestro conjunto de datos de forma no supervisada.

En este ejemplo, descubrimos cuatro grupos distintos: uno centrado en comida para perros, otro en reseñas negativas y dos en reseñas positivas.

Grupos identificados en el texto, visualizados en 2D mediante t-SNE

1
2
3
4
5
6
7
8
9import numpy as np
from sklearn.cluster import KMeans

matrix = np.vstack(df.ada_embedding.values)
n_clusters = 4

kmeans = KMeans(n_clusters=n_clusters, init="k-means++", random_state=42)
kmeans.fit(matrix)
df["Cluster"] = kmeans.labels_

Preguntas frecuentes

¿Cómo puedo saber cuántos tokens tiene una cadena antes de generar su embedding?

En Python, puedes dividir una cadena en tokens con tiktoken, el tokenizador de OpenAI.

Código de ejemplo:

1
2
3
4
5
6
7
8
9
10
11import tiktoken


def num_tokens_from_string(string: str, encoding_name: str) -> int:
    """Returns the number of tokens in a text string."""
    encoding = tiktoken.get_encoding(encoding_name)
    num_tokens = len(encoding.encode(string))
    return num_tokens


num_tokens_from_string("tiktoken is great!", "cl100k_base")

Para los modelos de embeddings de tercera generación, como text-embedding-3-small, usa la codificación cl100k_base.

Encontrarás más detalles y código de ejemplo en la guía del Cookbook de OpenAI sobre cómo contar tokens con tiktoken.

¿Cómo puedo recuperar rápidamente los K vectores de embeddings más cercanos?

Para buscar rápidamente entre muchos vectores, recomendamos usar una base de datos vectorial. Puedes encontrar ejemplos de cómo trabajar con bases de datos vectoriales y la API de OpenAI en nuestro Cookbook en GitHub.

¿Qué función de distancia debo usar?

Recomendamos la similitud del coseno. Por lo general, la elección de la función de distancia no influye demasiado.

Los embeddings de OpenAI están normalizados a una longitud de 1, lo que significa que:

La similitud del coseno se puede calcular un poco más rápido usando solo un producto escalar
La similitud del coseno y la distancia euclidiana producen el mismo orden de resultados

Sí, los clientes son propietarios de los datos que ingresan a nuestros modelos y de los resultados que obtienen, incluidos los embeddings. Es tu responsabilidad asegurarte de que el contenido que ingresas a nuestra API no infrinja ninguna ley aplicable ni nuestros Términos de uso.

¿Los modelos de embeddings V3 conocen los acontecimientos recientes?

No, los modelos text-embedding-3-large y text-embedding-3-small no tienen conocimiento de los acontecimientos ocurridos después de septiembre de 2021. Por lo general, esto no supone una limitación tan grande como para los modelos de generación de texto, pero puede reducir el rendimiento en ciertos casos excepcionales.

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Recursos

API heredadas

Elige un modelo

Texto y código

Diseño de prompts

Razonamiento

Imágenes y video

Tiempo real y audio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Búsqueda y recuperación

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Contenido multimedia

GPT-Live

Realtime API

Desarrollar con voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos fundamentales

Plan

Build

Test and publish

Conversion specs

Guías

Recursos

Primeros pasos

Guías

File Upload

API

Measurement

Advertiser API

Referencia de la API

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las capacidades de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Extender y automatizar

Entornos

Crear con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Seguridad cibernética

Primeros pasos

ChatGPT Work

Identidad y autenticación

Acceso, políticas y modelos del espacio de trabajo

Controles de complementos y conectores

Uso, gobernanza y cumplimiento

Implementación y proveedores de modelos

Comunidad

Blog

Comunidad

Blog