Alibaba Cloud Model Studio:Embedding

Los modelos de incrustación convierten datos como texto, imágenes y videos en vectores para tareas posteriores, incluyendo búsqueda semántica, recomendación, agrupamiento, clasificación y detección de anomalías.

Requisitos previos

Obtenga una clave de API y exporte la clave de API como variable de entorno. Si utiliza el SDK de OpenAI o el SDK de DashScope para realizar llamadas, instale el SDK.

Obtener embeddings

import os
from openai import OpenAI

input_text = "The quality of the clothes is excellent"

client = OpenAI(
    # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),  # If you have not set an environment variable, replace this with your API key.
    # This is the URL for the Singapore region. Replace {WorkspaceId} with your workspace ID.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

completion = client.embeddings.create(
    model="qwen3.7-text-embedding",
    input=input_text
)

print(completion.model_dump_json())

const OpenAI = require("openai");

// Initialize the OpenAI client.
const openai = new OpenAI({
    // If you have not set an environment variable, replace this with your API key.
    // API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    apiKey: process.env.DASHSCOPE_API_KEY,
    // This is the URL for the Singapore region. Replace {WorkspaceId} with your workspace ID.
    baseURL: 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1'
});

async function getEmbedding() {
    try {
        const inputTexts = "The quality of the clothes is excellent";
        const completion = await openai.embeddings.create({
            model: "qwen3.7-text-embedding",
            input: inputTexts,
            dimensions: 1024 // Specify the vector dimension. This parameter is only supported by qwen3.7-text-embedding, text-embedding-v3, and text-embedding-v4.
        });

        console.log(JSON.stringify(completion, null, 2));
    } catch (error) {
        console.error('Error:', error);
    }
}

getEmbedding();

curl --location 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/embeddings' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json' \
--data '{
    "model": "qwen3.7-text-embedding",
    "input": "The quality of the clothes is excellent"
}'

import dashscope
from http import HTTPStatus

# If you use a model in the China (Beijing) region, replace base_url with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

input_text = "The quality of the clothes is excellent"
resp = dashscope.TextEmbedding.call(
    model="qwen3.7-text-embedding",
    input=input_text,
)

if resp.status_code == HTTPStatus.OK:
    print(resp)

import com.alibaba.dashscope.embeddings.TextEmbedding;
import com.alibaba.dashscope.embeddings.TextEmbeddingParam;
import com.alibaba.dashscope.embeddings.TextEmbeddingResult;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.utils.Constants;

import java.util.Collections;
public class Main {
    static {
        Constants.baseHttpApiUrl="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1";
        // If you are using the China (Beijing) region, replace the URL with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
    }
     public static void main(String[] args) {
        String inputTexts = "The quality of the clothes is excellent";
        try {
            // Build the request parameters.
            TextEmbeddingParam param = TextEmbeddingParam
                    .builder()
                    .model("qwen3.7-text-embedding")
                    // Input text.
                    .texts(Collections.singleton(inputTexts))
                    .build();

            // Create a model instance and make a call.
            TextEmbedding textEmbedding = new TextEmbedding();
            TextEmbeddingResult result = textEmbedding.call(param);

            // Print the result.
            System.out.println(result);

        } catch (NoApiKeyException e) {
            // Catch and handle the exception for a missing API key.
            System.err.println("An exception occurred during the API call: " + e.getMessage());
            System.err.println("Please check if your API key is configured correctly.");
            e.printStackTrace();
        }
    }
}

# ======= Important =======
# If you use a model in the China (Beijing) region, replace base_url with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding
# === Remove this comment before running ===

curl --location 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1/services/embeddings/text-embedding/text-embedding' \
--header "Authorization: Bearer $DASHSCOPE_API_KEY" \
--header 'Content-Type: application/json' \
--data '{
    "model": "qwen3.7-text-embedding",
    "input": {
        "texts": [
        "The quality of the clothes is excellent"
        ]
    }
}'

import dashscope
import json
import os
from http import HTTPStatus

dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'
# The URL above is for the Singapore region. If you use a model in the Beijing region, replace base_url with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1

# The input can be a video.
# video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/en-US/20250107/lbcemt/new+video.mp4"
# input = [{'video': video}]
# Or an image.
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
input = [{'image': image}]
resp = dashscope.MultiModalEmbedding.call(
    # If you have not set an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    # API keys are region-specific. To get an API key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv('DASHSCOPE_API_KEY'),
    model="tongyi-embedding-vision-plus",
    input=input
)

print(json.dumps(resp.output, indent=4))

import com.alibaba.dashscope.embeddings.MultiModalEmbedding;
import com.alibaba.dashscope.embeddings.MultiModalEmbeddingItemImage;
import com.alibaba.dashscope.embeddings.MultiModalEmbeddingItemVideo;
import com.alibaba.dashscope.embeddings.MultiModalEmbeddingParam;
import com.alibaba.dashscope.embeddings.MultiModalEmbeddingResult;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.NoApiKeyException;
import com.alibaba.dashscope.exception.UploadFileException;
import com.alibaba.dashscope.utils.Constants;

import java.util.Collections;

public class Main {
    static {
        Constants.baseHttpApiUrl="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1";
        // If you are using the China (Beijing) region, replace the URL with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
    }
    public static void main(String[] args) {
        try {
            MultiModalEmbedding embedding = new MultiModalEmbedding();
            // The input can be a video.
            // MultiModalEmbeddingItemVideo video = new MultiModalEmbeddingItemVideo(
            //     "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/en-US/20250107/lbcemt/new+video.mp4");
            // Or an image.
            MultiModalEmbeddingItemImage image = new MultiModalEmbeddingItemImage(
                "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png");

            MultiModalEmbeddingParam param = MultiModalEmbeddingParam.builder()
                // If you have not set an environment variable, add your Model Studio API key by using .apiKey("sk-xxx")
                .model("tongyi-embedding-vision-plus")
                .contents(Collections.singletonList(image))
                .build();

            MultiModalEmbeddingResult result = embedding.call(param);
            System.out.println(result);

        } catch (ApiException | NoApiKeyException | UploadFileException e) {
            System.err.println("An exception occurred during the API call: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import dashscope
import json
import os
from http import HTTPStatus
# The following configuration is for the China (Beijing) region. When making the call, replace {WorkspaceId} with your actual workspace ID. Configurations are region-specific.
dashscope.base_http_api_url = "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1"

# Multimodal fused vector: Combines text, images, and videos into a single fused vector.
# Suitable for use cases like cross-modal retrieval and image search.
text = "This is a test text for generating a multimodal fused vector"
image = "https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png"
video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/en-US/20250107/lbcemt/new+video.mp4"

# The input contains text, an image, and a video. A fused vector is generated by setting the enable_fusion parameter.
input_data = [
    {"text": text},
    {"image": image},
    {"video": video}
]

# Use qwen3-vl-embedding to generate a fused vector.
resp = dashscope.MultiModalEmbedding.call(
    # If you have not set an environment variable, replace the following line with your Model Studio API key: api_key="sk-xxx",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    model="qwen3-vl-embedding",
    input=input_data,
    enable_fusion=True,
    # Optional parameter: Specifies the vector dimension. Supported values: 2560, 2048, 1536, 1024, 768, 512, and 256. Default: 2560.
    # dimension = 1024
)

print(json.dumps(resp.output, indent=4))

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        // If you have not set an environment variable, replace the following line with your Model Studio API key: String apiKey = "sk-xxx";
        String apiKey = System.getenv("DASHSCOPE_API_KEY");

        // Use enable_fusion to combine text, an image, and a video into a single fused vector.
        String requestBody = "{"
                + "\"model\": \"qwen3-vl-embedding\","
                + "\"input\": {"
                + "  \"contents\": ["
                + "    {\"text\": \"This is a test text for generating a multimodal fused vector\"},"
                + "    {\"image\": \"https://dashscope.oss-cn-beijing.aliyuncs.com/images/256_1.png\"},"
                + "    {\"video\": \"https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/en-US/20250107/lbcemt/new+video.mp4\"}"
                + "  ]"
                + "},"
                + "\"parameters\": {"
                + "  \"enable_fusion\": true"
                + "}"
                + "}";

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1/services/embeddings/multimodal-embedding/multimodal-embedding"))
                .header("Authorization", "Bearer " + apiKey)
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Selección de modelo

Elija el modelo adecuado según su tipo de datos de entrada y caso de uso.

• Procesamiento de texto plano o código: Utilice qwen3.7-text-embedding. Es el modelo de mayor rendimiento, que admite funciones avanzadas como instrucciones de tarea y vectores dispersos para cubrir la mayoría de los casos de uso de procesamiento de texto. Para escenarios sensibles a los costos que no requieren vectores dispersos u otras funciones avanzadas, utilice la versión ligera qwen3.7-text-embedding-flash, que mantiene la compatibilidad con 201 idiomas y un contexto de 128K a un precio más rentable.

• Procesamiento de contenido multimodal:

  • Incrustación fusionada: Para representar entradas monomodales o de modalidades mixtas como una incrustación fusionada para casos de uso como la recuperación multimodal y la búsqueda de imágenes, utilice qwen3-vl-embedding. Por ejemplo, puede ingresar una imagen de una camisa con el texto "encuentra un estilo similar que se vea más juvenil", y el modelo fusiona la imagen y la instrucción de tarea en una sola incrustación para su procesamiento.
  • Incrustación independiente: Para generar una incrustación independiente para cada parte de entrada (como una imagen y su subtítulo de texto correspondiente), utilice tongyi-embedding-vision-plus, tongyi-embedding-vision-flash o el modelo multimodal de propósito general multimodal-embedding-v1.

• Procesamiento de datos a gran escala: Para procesar datos de texto a gran escala y no en tiempo real, utilice qwen3.7-text-embedding o text-embedding-v4 con la API por lotes compatible con OpenAI para reducir significativamente los costos.

Esta tabla detalla las especificaciones de todos los modelos de embedding disponibles.

Embedding de texto

Embedding multimodal

Este modelo genera embeddings a partir de entradas de texto, imagen o video. Puede utilizar estos embeddings para tareas como clasificación de video e imagen, recuperación de texto-imagen y búsqueda de texto a imagen o de texto a video.

La API acepta entradas individuales de texto, imagen o video, así como combinaciones como texto e imágenes. Algunos modelos admiten múltiples entradas del mismo tipo, como varias imágenes. Para más detalles, consulte las limitaciones de cada modelo.

Restricciones de entrada e idioma

Características principales

Personalizar dimensiones de vectores

Los modelos qwen3.7-text-embedding, qwen3.7-text-embedding-flash, text-embedding-v4, text-embedding-v3, tongyi-embedding-vision-plus, tongyi-embedding-vision-flash y qwen3-vl-embedding admiten dimensiones de vectores personalizadas. Las dimensiones más altas conservan más información semántica, pero aumentan los costos de almacenamiento y computación.

• Casos de uso generales (Recomendado): Una dimensión de 1024 proporciona un equilibrio óptimo entre rendimiento y costo, lo que lo hace ideal para la mayoría de las tareas de búsqueda semántica.
• Escenarios de alta precisión: Para aplicaciones que requieren alta precisión, puede seleccionar una dimensión de 1536 o 2048. Esto mejora la precisión pero aumenta significativamente la sobrecarga de almacenamiento y cómputo.
• Entornos con recursos limitados: En escenarios sensibles a los costos, seleccione una dimensión de 768 o inferior. Esto reduce significativamente el consumo de recursos a costa de cierta información semántica.

import os
from openai import OpenAI

client = OpenAI(
    # API Keys are region-specific. To get an API Key, see https://www.alibabacloud.com/help/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # This is the base URL for the Singapore region. Replace {WorkspaceId} with your Workspace ID. URLs are region-specific.
    base_url="https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1",
)

resp = client.embeddings.create(
    model="qwen3.7-text-embedding",
    input=["I like it and will buy from here again"],
    # Set the vector dimension to 256
    dimensions=256
)
print(f"Vector dimension: {len(resp.data[0].embedding)}")

import dashscope

# If you use a model in the China (Beijing) region, replace base_http_api_url with: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

resp = dashscope.TextEmbedding.call(
    model="qwen3.7-text-embedding",
    input=["I like it and will buy from here again"],
    # Set the vector dimension to 256
    dimension=256
)

print(f"Vector dimension: {len(resp.output['embeddings'][0]['embedding'])}")

Texto de consulta vs. documento (text_type)

Este parámetro solo está disponible a través del SDK y la API de DashScope.

Para lograr resultados óptimos en tareas de búsqueda, debe vectorizar el contenido de manera diferente según su función. El parámetro text_type está diseñado para este propósito:

• text_type: 'query': Utilícelo para el texto de consulta proporcionado por el usuario. El modelo genera un vector "tipo título" que es más direccional y está optimizado para la recuperación de información.
• text_type: 'document' (predeterminado): Utilícelo para el texto del documento almacenado en su base de conocimientos. El modelo genera un vector "tipo cuerpo" que contiene información más completa y está optimizado para la coincidencia.

Al comparar texto corto con texto largo, debe distinguir entre query y document. Sin embargo, para tareas como clustering o clasificación donde todos los textos tienen la misma función, no necesita establecer este parámetro.

Instrucciones de tarea (instruct)

Este parámetro solo está disponible a través del SDK y la API de DashScope.

Puede proporcionar una instrucción de tarea clara en inglés para guiar a los modelos qwen3.7-text-embedding y text-embedding-v4 en la optimización de la calidad de los vectores para escenarios de recuperación específicos, mejorando la precisión. qwen3.7-text-embedding mejora la capacidad de seguimiento de instrucciones en un 16.4% respecto a text-embedding-v4, por lo que recomendamos utilizarlo primero. Al usar esta función, debe establecer el parámetro text_type en query.

# Example: Add an instruction to optimize retrieval quality when building document vectors.
resp = dashscope.TextEmbedding.call(
    model="qwen3.7-text-embedding",
    input="Research papers on machine learning",
    text_type="query",
    instruct="Given a research paper query, retrieve relevant research paper"
)

Vectores densos y dispersos

Este parámetro solo está disponible a través del SDK y la API de DashScope.

Los modelos qwen3.7-text-embedding, text-embedding-v4 y text-embedding-v3 admiten tres tipos de salida de vectores para adaptarse a diferentes estrategias de recuperación. La incrustación dispersa de qwen3.7-text-embedding utiliza una nueva estrategia de entrenamiento similar a SPLADE que mejora la eficacia en un 8.4% y añade compatibilidad para la recuperación entre idiomas.

Casos de uso

El siguiente código es solo con fines demostrativos. Para producción, precalcule y almacene los embeddings en una base de datos vectorial. De esta manera, solo necesitará generar el embedding de la consulta para la recuperación.

Búsqueda semántica

Realice una coincidencia semántica precisa calculando la similitud entre el embedding de la consulta y los embeddings del documento.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# To use a model from the China (Beijing) region, change base_http_api_url to: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Calculate cosine similarity."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def semantic_search(query, documents, top_k=5):
    """Perform semantic search."""
    # Generate the query embedding.
    query_resp = TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

    # Generate the document embeddings.
    doc_resp = TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=documents,
        dimension=1024
    )

    # Calculate similarities.
    similarities = []
    for i, doc_emb in enumerate(doc_resp.output['embeddings']):
        similarity = cosine_similarity(query_embedding, doc_emb['embedding'])
        similarities.append((i, similarity))

    # Sort and return the top-k results.
    similarities.sort(key=lambda x: x[1], reverse=True)
    return [(documents[i], sim) for i, sim in similarities[:top_k]]

# Example usage
documents = [
    "Artificial intelligence is a branch of computer science",
    "Machine learning is an important method for achieving artificial intelligence",
    "Deep learning is a subfield of machine learning"
]
query = "What is AI?"
results = semantic_search(query, documents, top_k=2)
for doc, sim in results:
    print(f"Similarity: {sim:.3f}, Document: {doc}")

Sistema de recomendación

Analice los embeddings del historial de comportamiento de un usuario para identificar sus intereses y recomendar elementos similares.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# To use a model from the China (Beijing) region, change base_http_api_url to: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Calculate cosine similarity."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
def build_recommendation_system(user_history, all_items, top_k=10):
    """Build a recommendation system."""
    # Generate user history embeddings.
    history_resp = TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=user_history,
        dimension=1024
    )

    # Calculate the user preference embedding by averaging.
    user_embedding = np.mean([
        emb['embedding'] for emb in history_resp.output['embeddings']
    ], axis=0)

    # Generate all item embeddings.
    items_resp = TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=all_items,
        dimension=1024
    )

    # Calculate recommendation scores.
    recommendations = []
    for i, item_emb in enumerate(items_resp.output['embeddings']):
        score = cosine_similarity(user_embedding, item_emb['embedding'])
        recommendations.append((all_items[i], score))

    # Sort and return the recommendation results.
    recommendations.sort(key=lambda x: x[1], reverse=True)
    return recommendations[:top_k]

# Example usage
user_history = ["Science Fiction", "Action", "Suspense"]
all_movies = ["Future World", "Space Adventure", "Ancient War", "Romantic Journey", "Superhero"]
recommendations = build_recommendation_system(user_history, all_movies)
for movie, score in recommendations:
    print(f"Recommendation Score: {score:.3f}, Movie: {movie}")

Clustering de texto

Agrupe textos similares analizando las distancias entre sus embeddings.

# scikit-learn is required: pip install scikit-learn
import dashscope
import numpy as np
from sklearn.cluster import KMeans

# To use a model from the China (Beijing) region, change base_http_api_url to: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

def cluster_texts(texts, n_clusters=2):
    """Cluster a set of texts."""
    # 1. Get the embeddings for all texts.
    resp = dashscope.TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=texts,
        dimension=1024
    )
    embeddings = np.array([item['embedding'] for item in resp.output['embeddings']])

    # 2. Use the KMeans algorithm for clustering.
    kmeans = KMeans(n_clusters=n_clusters, random_state=0, n_init='auto').fit(embeddings)

    # 3. Organize and return the results.
    clusters = {i: [] for i in range(n_clusters)}
    for i, label in enumerate(kmeans.labels_):
        clusters[label].append(texts[i])
    return clusters

# Example usage
documents_to_cluster = [
    "Mobile phone company A releases a new phone",
    "Search engine company B launches a new system",
    "World Cup final: Argentina vs. France",
    "China wins another gold medal at the Olympics",
    "A company releases its latest AI chip",
    "European Cup match report"
]
clusters = cluster_texts(documents_to_cluster, n_clusters=2)
for cluster_id, docs in clusters.items():
    print(f"--- Cluster {cluster_id} ---")
    for doc in docs:
        print(f"- {doc}")

Clasificación de texto

Realice clasificación de texto zero-shot calculando la similitud entre el embedding de un texto de entrada y embeddings de etiquetas predefinidas. Este proceso clasifica el texto en nuevas categorías sin requerir ejemplos preetiquetados.

import dashscope
import numpy as np

# To use a model from the China (Beijing) region, change base_http_api_url to: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Calculate cosine similarity."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def classify_text_zero_shot(text, labels):
    """Perform zero-shot text classification."""
    # 1. Get the embeddings for the input text and all labels.
    resp = dashscope.TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=[text] + labels,
        dimension=1024
    )
    embeddings = resp.output['embeddings']
    text_embedding = embeddings[0]['embedding']
    label_embeddings = [emb['embedding'] for emb in embeddings[1:]]

    # 2. Calculate the similarity with each label.
    scores = [cosine_similarity(text_embedding, label_emb) for label_emb in label_embeddings]

    # 3. Return the label with the highest similarity.
    best_match_index = np.argmax(scores)
    return labels[best_match_index], scores[best_match_index]

# Example usage
text_to_classify = "The fabric of this dress is comfortable, and the style is nice too"
possible_labels = ["Digital Products", "Apparel & Accessories", "Food & Beverage", "Home & Living"]

label, score = classify_text_zero_shot(text_to_classify, possible_labels)
print(f"Input text: '{text_to_classify}'")
print(f"Best matching category: '{label}' (Similarity: {score:.3f})")

Detección de anomalías

Identifique datos anómalos calculando la similitud entre el embedding de un texto y el embedding central de muestras normales. Los datos que se desvían significativamente de este patrón se consideran una anomalía.

El valor threshold en el ejemplo es solo con fines demostrativos. El valor ideal varía según el contenido y la distribución de los datos, por lo que debe calibrarlo utilizando su propio conjunto de datos.

import dashscope
import numpy as np

# To use a model from the China (Beijing) region, change base_http_api_url to: https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/api/v1
dashscope.base_http_api_url = "https://{WorkspaceId}.ap-southeast-1.maas.aliyuncs.com/api/v1"

def cosine_similarity(a, b):
    """Calculate cosine similarity."""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def detect_anomaly(new_comment, normal_comments, threshold=0.6):
    # 1. Generate embeddings for all normal comments and the new comment.
    all_texts = normal_comments + [new_comment]
    resp = dashscope.TextEmbedding.call(
        model="qwen3.7-text-embedding",
        input=all_texts,
        dimension=1024
    )
    embeddings = [item['embedding'] for item in resp.output['embeddings']]

    # 2. Calculate the center embedding (average) of the normal comments.
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. Calculate the similarity between the new comment's embedding and the center embedding.
    new_comment_embedding = np.array(embeddings[-1])
    similarity = cosine_similarity(new_comment_embedding, normal_center_vector)

    # 4. Determine if it is an anomaly.
    is_anomaly = similarity < threshold
    return is_anomaly, similarity

# Example usage
normal_user_comments = [
    "Today's meeting was productive",
    "The project is progressing smoothly",
    "The new version will be released next week",
    "User feedback is positive"
]

test_comments = {
    "Normal comment": "The feature works as expected",
    "Anomaly - meaningless garbled text": "asdfghjkl zxcvbnm"
}

print("--- Anomaly Detection Example ---")
for desc, comment in test_comments.items():
    is_anomaly, score = detect_anomaly(comment, normal_user_comments)
    result = "Yes" if is_anomaly else "No"
    print(f"Comment: '{comment}'")
    print(f"Is anomaly: {result} (Similarity to normal samples: {score:.3f})\n")

Referencia de API

• Embedding de texto general
  • API de procesamiento síncrono
• Embedding multimodal

  API de embedding multimodal

Códigos de error

Si la llamada al modelo falla y devuelve un mensaje de error, consulte Códigos de error para su resolución.

Limitación de tasa

Para conocer las condiciones de limitación de tasa del modelo, consulte Limitación de tasa.

Rendimiento del modelo (MTEB/CMTEB)

Evaluaciones comparativas

• MTEB (Massive Text Embedding Benchmark): Un benchmark integral que evalúa el rendimiento de propósito general de los embeddings de texto en tareas como clasificación, clustering y recuperación.
• CMTEB (Chinese Massive Text Embedding Benchmark): Un benchmark a gran escala diseñado específicamente para evaluar embeddings de texto en chino.
• Las puntuaciones oscilan entre 0 y 100. Las puntuaciones más altas indican un mejor rendimiento.