Incorporação de texto e multimodal

Modelos de incorporação convertem texto, imagens e vídeo em vetores numéricos para pesquisa semântica, recomendações, agrupamento, classificação e detecção de anomalias.

Pré-requisitos

Obtenha uma chave de API e defini-lo como uma variável de ambiente. Para usar o SDK, instale-o.

Obtenha incorporações

Incorporação de texto

Para fazer uma solicitação de API, especifique o texto a ser incorporado e o modelo a ser usado.

OpenAI compatible API

  ```python Python
  import os
  from openai import OpenAI

  input_text = "The quality of the clothes is excellent"

  client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url="https://maas.qwencloudapi.com/compatible-mode/v1",
  )

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

  print(completion.model_dump_json())
  ```

  ```javascript Node.js
  const OpenAI = require("openai");

  const openai = new OpenAI({
    apiKey: process.env.DASHSCOPE_API_KEY,
    baseURL: 'https://maas.qwencloudapi.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
      });

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

  getEmbedding();
  ```

  ```bash curl
  curl --location 'https://maas.qwencloudapi.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"
  }'
  ```

DashScope

  ```python Python
  import dashscope
  from http import HTTPStatus

  dashscope.base_http_api_url = 'https://maas.qwencloudapi.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)
  ```

  ```java Java
  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://maas.qwencloudapi.com/api/v1";
    }
    public static void main(String[] args) {
      String inputTexts = "The quality of the clothes is excellent";
      try {
        TextEmbeddingParam param = TextEmbeddingParam
            .builder()
            .model("qwen3.7-text-embedding")
            .texts(Collections.singleton(inputTexts))
            .build();

        TextEmbedding textEmbedding = new TextEmbedding();
        TextEmbeddingResult result = textEmbedding.call(param);

        System.out.println(result);

      } catch (NoApiKeyException e) {
        System.err.println("An exception occurred when calling the API: " + e.getMessage());
        System.err.println("Please check if your API key is configured correctly.");
        e.printStackTrace();
      }
    }
  }
  ```

  ```bash curl
  curl --location 'https://maas.qwencloudapi.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"
      ]
    }
  }'
  ```

Vetores independentes multimodais

Gere vetores separados para cada modalidade de entrada (texto, imagem ou vídeo). Use isto quando precisar processar cada tipo de conteúdo de forma independente.

A incorporação independente multimodal requer o DashScope SDK ou API. Endpoints compatíveis com OpenAI não são suportados.

Python

```python
import dashscope
import json
import os
from http import HTTPStatus

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# Input can be a video
# video = "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/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(
  api_key=os.getenv('DASHSCOPE_API_KEY'),
  model="tongyi-embedding-vision-plus",
  input=input
)

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

Java

```java
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://maas.qwencloudapi.com/api/v1";
  }
  public static void main(String[] args) {
    try {
      MultiModalEmbedding embedding = new MultiModalEmbedding();
      // Input can be a video
      // MultiModalEmbeddingItemVideo video = new MultiModalEmbeddingItemVideo(
      //     "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/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()
        .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("API call error: " + e.getMessage());
      e.printStackTrace();
    }
  }
}
```

Vetores fundidos multimodais

Combine conteúdo de diferentes modalidades – texto, imagens e vídeos – em um único vetor fundido. Isso permite aplicações como pesquisa de texto para imagem, pesquisa de imagem para imagem, pesquisa de texto para vídeo e recuperação intermodal.

Vetores fundidos multimodais requerem o Python DashScope SDK ou uma chamada direta de API. A API compatível com OpenAI, o Java DashScope SDK e o console não oferecem suporte a esse recurso.

• qwen3-vl-embedding: Suporta vetores fundidos e independentes. Para gerar um vetor fundido, defina o parâmetro booleano enable_fusion para true.
• qwen2.5-vl-embedding: suporta apenas embeddings fundidos, não embeddings independentes.

Python

```python
import dashscope
import json
import os
from http import HTTPStatus

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

# Multimodal fused vector: combines text, an image, and a video into a single fused vector.
# Suitable for 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 enable_fusion.
input_data = [
  {"text": text},
  {"image": image},
  {"video": video}
]

# Use qwen3-vl-embedding to generate a fused vector.
resp = dashscope.MultiModalEmbedding.call(
  api_key=os.getenv('DASHSCOPE_API_KEY'),
  model="qwen3-vl-embedding",
  input=input_data,
  enable_fusion=True,
  # Optional: vector dimension. Supported values: 2560, 2048, 1536, 1024, 768, 512, 256. Default: 2560.
  # dimension = 1024
)

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

Java (HTTP)

```java
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 {
    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://maas.qwencloudapi.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());
  }
}
```

Seleção de modelo

Incorporação de texto

O tamanho do lote é o número máximo de textos por chamada de API. Por exemplo, text-embedding-v4 tem um tamanho de lote de 10, o que permite incluir até 10 textos para vetorização por solicitação, onde cada texto é limitado a 8.192 tokens. Este limite se aplica a:

• Entrada do array de strings: O array pode conter no máximo 10 elementos.
• Entrada de arquivo: O arquivo de texto pode conter no máximo 10 linhas de texto.

All languages supported by qwen3.7-text-embedding

• Sino-Tibetano: Chinês (Chinês Simplificado, Chinês Tradicional, Cantonês), Birmanês, Tibetano, Meitei
• Indo-Europeu: inglês, francês, português, alemão, romeno, sueco, dinamarquês, búlgaro, russo, tcheco, grego, ucraniano, espanhol, holandês, eslovaco, croata, polonês, lituano, norueguês (Bokmal), norueguês Nynorsk, persa, esloveno, guzerate, letão, italiano, occitano, nepalês, marata, bielorrusso, sérvio, luxemburguês, veneziano, assamês, galês, silesiano, asturiano, Chhattisgarhi, Awadhi, Maithili, Bhojpuri, Sindi, irlandês, feroês, hindi, punjabi, bengali, Odia, tadjique, iídiche oriental, lombardo, liguriano, siciliano, friulano, sardo, galego, catalão, islandês, tosk, albanês, limburguês, dari, africâner, macedônio, cingalês, urdu, magahi, bósnio, Armênio, Latgaliano, Gaélico Escocês, Curdo Central, Curdo do Norte, Pashto do Sul, Sânscrito, Dhundari, Marwari, Ahirani, Bagheli, Bagri, Bundeli, Braj, Kumaoni, Caxemira
• Afro-asiático: Árabe (árabe padrão, árabe Najdi, árabe levantino, árabe egípcio, árabe marroquino, árabe mesopotâmico, árabe Taizzi-Adeni, árabe tunisino, árabe do Golfo, árabe argelino, árabe sudanês, árabe líbio), hebraico, maltês, amárico, tigrínia, cabila, somali, centro-oeste oromo, hausa
• Austronésio: Indonésio, Malaio, Tagalo, Cebuano, Javanês, Sudanês, Minangkabau, Balinês, Bangka, Pangasinan, Ilocano, Waray (Filipinas), Plateau Malgaxe, Malgaxe, Buginese, Maori, Samoano, Havaiano, Fijiano
• Dravidiano: Tamil, Telugu, Kannada, Malayalam
• Turco: Turco, Norte do Azerbaijão, Norte do Uzbeque, Cazaque, Bashkir, Tártaro, Tártaro da Crimeia, Quirguistão, Turcomenistão, Uigur
• Kra-Dai: Tailandês, Lao, Shan
• Uralic: finlandês, estoniano, húngaro, Meadow Mari
• Austroasiático: Vietnamita, Khmer
• Níger-Congo: Yoruba, Ewe, Kinyarwanda, Lingala, Northern Sotho, Nyanja, Shona, Southern Sotho, Tswana, Xhosa, Zulu, Luganda, Swati, Tsonga, Tumbuka, Venda, Chokwe, Luba-Kasai, Rundi, Mbundu, Kikuyu, Kongo, Nigeriano Fulfulde, Wolof, Fon, Kabiyé, Mossi, Akan, Twi, Bambara, Igbo
• Outros: japonês, coreano, georgiano, basco, crioulo haitiano, papiamento, crioulo cabo-verdiano, tok pisin, suaíli, aimará central, tulu, naga, pidgin nigeriano, crioulo maurício, sango, ayacucho quéchua, halh mongol, dinka do sudoeste, nuer, guarani

Incorporação multimodal

Dados somente texto? Em vez disso, use text-embedding-v4 – mais rápido, mais barato e com mais opções de dimensão. A incorporação multimodal é para recuperação intermodal (texto+imagem, texto+vídeo).

Suporte de entrada e idioma

Recursos principais

Alternar dimensões de incorporação

qwen3.7-text-embedding, text-embedding-v4, text-embedding-v3, tongyi-embedding-vision-pluse tongyi-embedding-vision-flash suporta dimensões de incorporação personalizadas. Dimensões mais altas retêm informações semânticas mais ricas, mas também aumentam os custos de armazenamento e computação.

• Cenários gerais (recomendado): 1.024 dimensões oferecem o melhor equilíbrio entre desempenho e custo, adequado para a maioria das tarefas de recuperação semântica.
• Cenários de alta precisão: Para aplicações que exigem alta precisão, escolha dimensões 1536 ou 2048. Isso melhora a precisão, mas aumenta significativamente a sobrecarga de armazenamento e computação.
• Cenários com recursos limitados: em cenários sensíveis a custos, escolha dimensões 768 ou inferiores. Isto reduz significativamente o consumo de recursos, mas resulta em alguma perda de informação semântica.

OpenAI compatible API

```python
import os
from openai import OpenAI

client = OpenAI(
  api_key=os.getenv("DASHSCOPE_API_KEY"),
  base_url="https://maas.qwencloudapi.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 embedding dimensions to 256
  dimensions=256
)
print(f"Embedding dimensions: {len(resp.data[0].embedding)}")
```

DashScope

```python
import dashscope

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

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

print(f"Embedding dimensions: {len(resp.output['embeddings'][0]['embedding'])}")
```

Distinguir entre consulta e texto do documento (text_type)

Atualmente, este parâmetro só pode ser ativado por meio do SDK e API do DashScope.

Para obter os melhores resultados em tarefas relacionadas à pesquisa, processe diferentes tipos de conteúdo com incorporação direcionada para aproveitar totalmente suas respectivas funções. O text_type parâmetro é projetado para esta finalidade:

• text_type: 'query': use para texto de consulta fornecido pelo usuário. O modelo gera um vetor "semelhante a título" que é mais direcional e otimizado para recuperação de informações.
• text_type: 'document' (padrão): Use para texto de documento armazenado no banco de dados. O modelo gera um vetor “semelhante a um corpo” que contém informações mais abrangentes e é otimizado para ser recuperado.

Ao usar texto curto para corresponder a texto longo, diferencie entre query e document. Para tarefas onde todos os textos têm a mesma função, como agrupamento ou classificação, não é necessário definir este parâmetro.

Use instruções para melhorar o desempenho (instruir)

Atualmente, este parâmetro só pode ser ativado por meio do SDK e API do DashScope.

Você pode fornecer instruções claras de tarefa em inglês para orientar qwen3.7-text-embedding e text-embedding-v4 na otimização da qualidade do vetor para cenários de recuperação específicos, melhorando a precisão. qwen3.7-text-embedding segue as instruções 16,4% melhor que text-embedding-v4 e é a escolha recomendada. Ao usar esse recurso, você deve definir o text_type parâmetro para 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"
)

Vetores densos e esparsos

Atualmente, este parâmetro só pode ser ativado por meio do SDK e API do DashScope.

qwen3.7-text-embedding, text-embedding-v4e text-embedding-v3 suporta três tipos de saída vetorial para acomodar diferentes estratégias de recuperação. As escassas incorporações de qwen3.7-text-embedding use uma nova estratégia de treinamento estilo SPLADE que melhora o desempenho em 8,4%, e o modelo também oferece suporte à recuperação multilíngue.

Usem exemplos.

O código a seguir é apenas para fins de demonstração. Para produção, pré-calcule e armazene embeddings em um banco de dados vetorial. Dessa forma, você só precisa gerar a incorporação da consulta para recuperação.

Pesquisa semântica

Execute uma correspondência semântica precisa calculando a semelhança entre a incorporação da consulta e a incorporação do documento.

import dashscope
import numpy as np
from dashscope import TextEmbedding

dashscope.base_http_api_url = 'https://maas.qwencloudapi.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 vector
  query_resp = TextEmbedding.call(
  model="qwen3.7-text-embedding",
  input=query,
  dimension=1024
  )
  query_embedding = query_resp.output['embeddings'][0]['embedding']

  # Generate the document vectors
  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 recomendação

Analise as incorporações do histórico comportamental de um usuário para identificar seus interesses e recomendar itens semelhantes.

import dashscope
import numpy as np
from dashscope import TextEmbedding

dashscope.base_http_api_url = 'https://maas.qwencloudapi.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 vectors
  history_resp = TextEmbedding.call(
  model="qwen3.7-text-embedding",
  input=user_history,
  dimension=1024
  )

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

  # Generate all item vectors
  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}")

Agrupamento de texto

Agrupe textos semelhantes analisando as distâncias entre seus encaixes.

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

dashscope.base_http_api_url = 'https://maas.qwencloudapi.com/api/v1'

def cluster_texts(texts, n_clusters=2):
  """Cluster a set of texts"""
  # 1. Get the vectors 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}")

Classificação de texto

Execute a classificação de texto zero-shot calculando a semelhança entre a incorporação de um texto de entrada e a incorporação de rótulos predefinidos. Este processo classifica o texto em novas categorias sem exigir exemplos pré-rotulados.

import dashscope
import numpy as np

dashscope.base_http_api_url = 'https://maas.qwencloudapi.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 vectors 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})")

Detecção de anomalias

Identifique dados anômalos calculando a semelhança entre a incorporação de um texto e a incorporação central de amostras normais. Os dados que se desviam significativamente deste padrão são considerados uma anomalia.

O limite no exemplo é para fins de demonstração. O valor ideal varia de acordo com o conteúdo e distribuição dos dados, portanto você deve calibrá-lo usando seu próprio conjunto de dados.

import dashscope
import numpy as np

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. Vectorize 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 vector (average value) 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 and the center vector
  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")

Referência de API

• Detalhes da API para incorporação compatível com OpenAI
• Detalhes da API para incorporação do DashScope
• Referência da API de incorporação multimodal

Códigos de erro

Se uma chamada falhar, consulte Mensagens de erro.

Desempenho do modelo (MTEB/CMTEB)

• MTEB: Massive Text Embedding Benchmark, um benchmark abrangente que avalia o desempenho geral de incorporações de texto em tarefas como classificação, agrupamento e recuperação.
• CMTEB: Benchmark de incorporação de texto massivo em chinês, um benchmark em grande escala especificamente para avaliar incorporações de texto em chinês.
• As pontuações variam de 0 a 100. Um valor mais alto indica melhor desempenho.