Alibaba Cloud Model Studio:エンベディング

マルチモーダルエンベディング

モデルは、テキスト、画像、または動画といったユーザー入力に基づいて連続的なベクターを生成します。これは、動画分類、画像分類、画像テキスト検索、テキストや他の画像を使用した画像検索、テキストや画像を使用した動画検索などのタスクに適しています。

API は、単一のテキストセグメント、単一の画像、または単一の動画ファイルのアップロードをサポートしています。また、異なるタイプの組み合わせ (テキストと画像など) も許可されています。一部のモデルは、同じタイプの複数の入力 (複数の画像など) をサポートしています。詳細については、特定のモデルの制限事項をご参照ください。

入力フォーマットと言語の制限：

エンベディング次元の切り替え

text-embedding-v4 と text-embedding-v3 は、カスタムのエンベディング次元をサポートしています。次元が高いほど豊富なセマンティック情報が保持されますが、ストレージと計算コストも増加します。

• 一般的なシナリオ (推奨)：1024 次元は、パフォーマンスとコストのバランスが最も優れています。これは、ほとんどのセマンティック検索タスクに適しています。

• 高精度：高精度が要求されるドメインでは、1536 または 2048 次元を選択します。これにより精度は向上しますが、ストレージと計算のオーバーヘッドが大幅に増加します。

• リソースに制約がある場合：コストに敏感なシナリオでは、768 以下の次元を選択します。これによりリソース消費は大幅に削減されますが、セマンティック情報の一部が失われます。

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # 以下はシンガポールリージョンの URL です。中国 (北京) リージョンのモデルを使用する場合は、URL を https://dashscope.aliyuncs.com/compatible-mode/v1 に置き換えてください
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

resp = client.embeddings.create(
    model="text-embedding-v4",
    input=["I like it and will come back to buy more"],
    # エンベディング次元を 256 に設定
    dimensions=256
)
print(f"Embedding dimensions: {len(resp.data[0].embedding)}")

import dashscope

# 中国 (北京) リージョンのモデルを使用する場合は、base_url を https://dashscope.aliyuncs.com/api/v1 に置き換えてください
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

resp = dashscope.TextEmbedding.call(
    model="text-embedding-v4",
    input=["I like it and will come back to buy more"],
    # エンベディング次元を 256 に設定
    dimension=256
)

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

クエリとドキュメントテキストの区別 (text_type)

このパラメーターは現在、DashScope SDK と API を通じてのみ有効にできます。

検索タスクで最良の結果を得るには、タスクの目標に基づいて、さまざまな種類のコンテンツを特定のエンベディングメソッドで処理します。これにより、各タイプが最適に機能します。この目的のために text_type パラメーターが設計されています：

• text_type: 'query'：ユーザーが入力したクエリテキストに使用します。モデルは、クエリと検索に最適化された、より指向性の高い「タイトル風」のベクターを生成します。

• text_type: 'document' (デフォルト)：データベースに保存されているドキュメントテキストに使用します。モデルは、より包括的な情報を含み、クエリとの照合に最適化された「本文風」のベクターを生成します。

短いテキストと長いテキストを照合する場合は、query と document を区別します。クラスタリングや分類など、すべてのテキストが同じロールを持つタスクでは、このパラメーターを設定する必要はありません。

タスク命令によるパフォーマンスの向上 (instruct)

このパラメーターは現在、DashScope SDK と API を通じてのみ有効にできます。

明確な英語の命令を提供して text-embedding-v4 モデルをガイドし、特定の検索シナリオに合わせてエンベディングの品質と精度を最適化します。この機能を使用する場合、text_type パラメーターを query に設定します。

# シナリオ: 検索エンジンのドキュメントベクターを構築する際に、検索のためのエンベディング品質を最適化するための命令を追加できます。
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"
)

密ベクトルと疎ベクトル

このパラメーターは現在、DashScope SDK と API を通じてのみ有効にできます。

text-embedding-v4 と text-embedding-v3 は、さまざまな検索戦略のニーズを満たすために、3 種類のベクター出力をサポートしています。

セマンティック検索

クエリとドキュメント間のベクター類似度を計算して、正確なセマンティックマッチングを実現します。

import dashscope
import numpy as np
from dashscope import TextEmbedding

# 中国 (北京) リージョンのモデルを使用する場合は、base_url を https://dashscope.aliyuncs.com/api/v1 に置き換えてください
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """コサイン類似度を計算"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def semantic_search(query, documents, top_k=5):
    """セマンティック検索"""
    # クエリベクターを生成
    query_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

    # ドキュメントベクターを生成
    doc_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=documents,
        dimension=1024
    )

    # 類似度を計算
    similarities = []
    for i, doc_emb in enumerate(doc_resp.output['embeddings']):
        similarity = cosine_similarity(query_embedding, doc_emb['embedding'])
        similarities.append((i, similarity))

    # ソートして上位 k 件の結果を返す
    similarities.sort(key=lambda x: x[1], reverse=True)
    return [(documents[i], sim) for i, sim in similarities[:top_k]]

# 使用例
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}")

レコメンデーションシステム

ユーザーの行動履歴ベクターを分析してユーザーの嗜好を発見し、類似のアイテムを推奨します。

import dashscope
import numpy as np
from dashscope import TextEmbedding

# 中国 (北京) リージョンのモデルを使用する場合は、base_url を https://dashscope.aliyuncs.com/api/v1 に置き換えてください
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """コサイン類似度を計算"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
def build_recommendation_system(user_history, all_items, top_k=10):
    """レコメンデーションシステムを構築"""
    # ユーザー履歴ベクターを生成
    history_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=user_history,
        dimension=1024
    )

    # ユーザーの嗜好ベクターを計算 (平均化による)
    user_embedding = np.mean([
        emb['embedding'] for emb in history_resp.output['embeddings']
    ], axis=0)

    # すべてのアイテムのベクターを生成
    items_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=all_items,
        dimension=1024
    )

    # レコメンデーションスコアを計算
    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))

    # ソートして推奨結果を返す
    recommendations.sort(key=lambda x: x[1], reverse=True)
    return recommendations[:top_k]

# 使用例
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}")

テキストクラスタリング

ベクター間の距離を分析して、類似したテキストを自動的にグループ化します。

# scikit-learn が必要です: pip install scikit-learn
import dashscope
import numpy as np
from sklearn.cluster import KMeans

# 中国 (北京) リージョンのモデルを使用する場合は、base_url を https://dashscope.aliyuncs.com/api/v1 に置き換えてください
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cluster_texts(texts, n_clusters=2):
    """テキストのグループをクラスタリング"""
    # 1. すべてのテキストのベクターを取得します。
    resp = dashscope.TextEmbedding.call(
        model="text-embedding-v4",
        input=texts,
        dimension=1024
    )
    embeddings = np.array([item['embedding'] for item in resp.output['embeddings']])

    # 2. KMeans アルゴリズムを使用してクラスタリングします。
    kmeans = KMeans(n_clusters=n_clusters, random_state=0, n_init='auto').fit(embeddings)

    # 3. 結果を整理して返します。
    clusters = {i: [] for i in range(n_clusters)}
    for i, label in enumerate(kmeans.labels_):
        clusters[label].append(texts[i])
    return clusters


# 使用例
documents_to_cluster = [
    "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 at the Olympics",
    "A company releases its latest AI chip",
    "Euro 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}")

テキスト分類

入力テキストと事前定義されたラベル間のベクター類似度を計算して、事前ラベル付けされた例なしで新しいカテゴリを識別および分類します。

import dashscope
import numpy as np

# 中国 (北京) リージョンのモデルを使用する場合は、base_url を https://dashscope.aliyuncs.com/api/v1 に置き換えてください
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """コサイン類似度を計算"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def classify_text_zero_shot(text, labels):
    """ゼロショットテキスト分類"""
    # 1. 入力テキストとすべてのラベルのベクターを取得します。
    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. 各ラベルとの類似度を計算します。
    scores = [cosine_similarity(text_embedding, label_emb) for label_emb in label_embeddings]

    # 3. 最も類似度の高いラベルを返します。
    best_match_index = np.argmax(scores)
    return labels[best_match_index], scores[best_match_index]


# 使用例
text_to_classify = "The fabric of this dress is comfortable and the style is nice"
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})")

異常検知

テキストベクターと正常なサンプルの中心とのベクター類似度を計算して、通常のパターンから著しく異なる異常データを識別します。

import dashscope
import numpy as np


def cosine_similarity(a, b):
    """コサイン類似度を計算"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def detect_anomaly(new_comment, normal_comments, threshold=0.6):
    # 1. すべての正常なコメントと新しいコメントをベクター化します。
    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. 正常なコメントの中心ベクターを計算します (平均)。
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. 新しいコメントと中心ベクターの間の類似度を計算します。
    new_comment_embedding = np.array(embeddings[-1])
    similarity = cosine_similarity(new_comment_embedding, normal_center_vector)

    # 4. 異常かどうかを判断します。
    is_anomaly = similarity < threshold
    return is_anomaly, similarity


# 使用例
normal_user_comments = [
    "Today's meeting was very productive",
    "The project is progressing smoothly",
    "A 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")