Alibaba Cloud Model Studio:Embedding

Les modèles d'embedding transforment des données telles que du texte, des images et des vidéos en vecteurs. Ces vecteurs alimentent ensuite diverses tâches comme la recherche sémantique, la recommandation, le clustering, la classification ou la détection d'anomalies.

Prérequis

Obtenir une clé API et exporter cette clé API dans une variable d'environnement. Si vous utilisez le SDK OpenAI ou le SDK DashScope pour effectuer vos appels, installez le SDK.

Obtenir des 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/en/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="text-embedding-v4",
    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/en/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: "text-embedding-v4",
            input: inputTexts,
            dimensions: 1024 // Specify the vector dimension. This parameter is only supported by 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": "text-embedding-v4",
    "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="text-embedding-v4",
    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("text-embedding-v4")
                    // 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": "text-embedding-v4",
    "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/en/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());
    }
}

Choix du modèle

Sélectionnez le modèle approprié selon le type de données d'entrée et votre cas d'usage.

• Traitement de texte brut ou de code : privilégiez text-embedding-v4. Ce modèle offre les meilleures performances et intègre des fonctionnalités avancées telles que les instructions de tâche et les vecteurs creux, couvrant ainsi la majorité des besoins en traitement de texte.

• Traitement de contenu multimodal :

  • Embedding fusionné : pour représenter des entrées unimodales ou mixtes sous forme d'embedding unique, utile notamment pour la récupération intermodale et la recherche d'image, optez pour qwen3-vl-embedding. Par exemple, vous pouvez soumettre l'image d'une chemise accompagnée de la consigne « trouver un style similaire mais plus jeune », et le modèle fusionnera l'image avec l'instruction en un seul embedding pour le traitement.
  • Embedding indépendant : lorsque chaque partie de l'entrée (par exemple une image et sa légende textuelle) doit produire son propre embedding, utilisez tongyi-embedding-vision-plus, tongyi-embedding-vision-flash, ou le modèle multimodal généraliste multimodal-embedding-v1.

• Traitement de données à grande échelle : pour traiter d'importants volumes de textes hors temps réel, combinez text-embedding-v4 avec l'API batch compatible OpenAI afin de réduire considérablement les coûts.

Le tableau suivant détaille les spécifications de tous les modèles d'embedding disponibles.

Embedding de texte

Embedding multimodal

Ce modèle produit des embeddings à partir de textes, d'images ou de vidéos. Ces embeddings servent notamment à la classification d'images et de vidéos, à la récupération image-texte, ainsi qu'à la recherche d'image ou de vidéo par texte.

L'API accepte aussi bien des entrées uniques (texte, image ou vidéo) que des combinaisons telles que texte et image. Certains modèles autorisent plusieurs entrées du même type, par exemple plusieurs images. Consultez les limitations spécifiques à chaque modèle pour plus de détails.

Restrictions d'entrée et de langue

Fonctionnalités principales

Personnalisation des dimensions vectorielles

Les modèles text-embedding-v4, text-embedding-v3, tongyi-embedding-vision-plus, tongyi-embedding-vision-flash, qwen3-vl-embedding permettent de personnaliser les dimensions des vecteurs. Des dimensions plus élevées conservent davantage d'informations sémantiques, mais augmentent les coûts de stockage et de calcul.

• Cas d'usage généraux (recommandé) : une dimension de 1 024 offre un compromis optimal entre performance et coût, ce qui convient à la plupart des tâches de recherche sémantique.
• Scénarios exigeant une haute précision : pour les applications nécessitant une grande exactitude, choisissez une dimension de 1 536 ou 2 048. La précision s'en trouve améliorée, mais cela accroît sensiblement la consommation de ressources de stockage et de calcul.
• Environnements à ressources limitées : dans les contextes sensibles au coût, optez pour une dimension de 768 ou moins. Cela réduit notablement la consommation de ressources, au prix d'une perte partielle d'informations sémantiques.

import os
from openai import OpenAI

client = OpenAI(
    # API Keys are region-specific. To get an API Key, see https://www.alibabacloud.com/help/en/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="text-embedding-v4",
    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="text-embedding-v4",
    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'])}")

Texte de requête vs texte de document (text_type)

Ce paramètre est exclusivement disponible via le SDK DashScope et l'API.

Pour optimiser les résultats de recherche, il convient de vectoriser le contenu différemment selon son rôle. Le paramètre text_type répond précisément à ce besoin :

• text_type: 'query' : à utiliser pour le texte de requête fourni par l'utilisateur. Le modèle génère alors un vecteur de type « titre », plus directionnel et optimisé pour la récupération d'information.
• text_type: 'document' (par défaut) : destiné au texte de document stocké dans votre base de connaissances. Le modèle produit un vecteur de type « corps de texte », riche en informations et optimisé pour la mise en correspondance.

Lorsque vous comparez un texte court à un texte long, distinguez clairement query et document. En revanche, pour des tâches comme le clustering ou la classification où tous les textes jouent le même rôle, ce paramètre n'est pas nécessaire.

Instructions de tâche (instruct)

Ce paramètre est exclusivement disponible via le SDK DashScope et l'API.

Vous pouvez fournir une instruction de tâche claire en anglais afin de guider le modèle text-embedding-v4 dans l'optimisation de la qualité vectorielle pour des scénarios de récupération spécifiques, améliorant ainsi la précision. Lors de l'utilisation de cette fonctionnalité, le paramètre text_type doit impérativement être défini sur query.

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

Vecteurs denses et creux

Ce paramètre est exclusivement disponible via le SDK DashScope et l'API.

Les modèles text-embedding-v4 et text-embedding-v3 proposent trois types de sortie vectorielle afin de s'adapter à différentes stratégies de récupération.

Cas d'usage

Le code ci-dessous est fourni à titre illustratif uniquement. En environnement de production, précalculez les embeddings et stockez-les dans une base de données vectorielle. Ainsi, seul l'embedding de requête devra être généré lors de la récupération.

Recherche sémantique

Effectuez une mise en correspondance sémantique précise en calculant la similarité entre l'embedding de la requête et ceux des documents.

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="text-embedding-v4",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

    # Generate the document embeddings.
    doc_resp = TextEmbedding.call(
        model="text-embedding-v4",
        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}")

Système de recommandation

Analysez les embeddings de l'historique comportemental d'un utilisateur afin d'identifier ses centres d'intérêt et de lui recommander des éléments similaires.

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="text-embedding-v4",
        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="text-embedding-v4",
        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 textes

Regroupez des textes similaires en analysant les distances entre leurs embeddings respectifs.

# 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="text-embedding-v4",
        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}")

Classification de textes

Réalisez une classification de textes sans apprentissage préalable (zero-shot) en calculant la similarité entre l'embedding d'un texte d'entrée et les embeddings d'étiquettes prédéfinies. Cette méthode classe le texte dans de nouvelles catégories sans nécessiter d'exemples préétiquetés.

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="text-embedding-v4",
        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})")

Détection d'anomalies

Identifiez les données anormales en calculant la similarité entre l'embedding d'un texte et l'embedding central des échantillons normaux. Toute donnée s'écartant significativement de ce schéma est considérée comme une anomalie.

Le threshold utilisé dans l'exemple est fourni à titre indicatif. La valeur idéale dépend du contenu et de la distribution des données ; il vous appartient donc de la calibrer à l'aide de votre propre jeu de données.

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="text-embedding-v4",
        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")

Référence API

• Embedding de texte général
  • API de traitement synchrone
• Embedding multimodal

  API d'embedding multimodal

Codes d'erreur

Si l'appel au modèle échoue et renvoie un message d'erreur, consultez la rubrique Codes d'erreur pour obtenir des solutions.

Limitation du débit

Pour connaître les conditions de limitation du débit applicables au modèle, reportez-vous à la rubrique Limitation du débit.

Performances des modèles (MTEB/CMTEB)

Benchmarks d'évaluation

• MTEB (Massive Text Embedding Benchmark) : benchmark complet évaluant les performances générales des embeddings de texte sur des tâches telles que la classification, le clustering et la récupération.
• CMTEB (Chinese Massive Text Embedding Benchmark) : benchmark à grande échelle dédié à l'évaluation des embeddings de texte en chinois.
• Les scores s'échelonnent de 0 à 100. Un score élevé indique de meilleures performances.