Alibaba Cloud Model Studio：Embedding

Multimodal embedding

Model menghasilkan vektor kontinu berdasarkan masukan pengguna, yang dapat berupa teks, gambar, atau video. Ini cocok untuk tugas seperti klasifikasi video, klasifikasi gambar, pengambilan gambar-teks, pencarian gambar-ke-gambar, dan pencarian video-ke-teks/gambar.

Antarmuka mendukung pengunggahan satu segmen teks, satu gambar, atau satu file video. Antarmuka juga memungkinkan kombinasi jenis berbeda (seperti teks + gambar). Beberapa model mendukung beberapa masukan dari jenis yang sama (seperti beberapa gambar). Untuk informasi lebih lanjut, lihat detail batasan untuk model tertentu.

Format masukan dan batasan bahasa:

Ubah dimensi vektor

text-embedding-v4, text-embedding-v3, tongyi-embedding-vision-plus, tongyi-embedding-vision-flash, qwen3-vl-embedding mendukung dimensi vektor kustom. Dimensi yang lebih tinggi mempertahankan informasi semantik yang lebih kaya tetapi juga meningkatkan biaya penyimpanan dan komputasi.

• Skenario umum (Direkomendasikan): Dimensi 1024 menawarkan keseimbangan terbaik antara kinerja dan biaya, cocok untuk sebagian besar tugas pengambilan semantik.

• Skenario presisi tinggi: Untuk domain yang memerlukan presisi tinggi, pilih dimensi 1536 atau 2048. Ini memberikan peningkatan presisi tertentu tetapi secara signifikan meningkatkan overhead penyimpanan dan komputasi.

• Skenario terbatas sumber daya: Dalam skenario yang sensitif biaya, pilih dimensi 768 atau lebih rendah. Ini secara signifikan mengurangi konsumsi sumber daya tetapi mengakibatkan kehilangan informasi semantik.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Berikut ini adalah URL untuk wilayah Singapura. Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti URL dengan: 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 buy from here again"],
    # Setel dimensi vektor ke 256
    dimensions=256
)
print(f"Dimensi vektor: {len(resp.data[0].embedding)}")

import dashscope

# Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti base_url dengan: 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 buy from here again"],
    # Setel dimensi vektor ke 256
    dimension=256
)

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

Bedakan antara teks kueri dan dokumen (text_type)

Parameter ini saat ini hanya dapat diaktifkan melalui SDK dan API DashScope.

Untuk mencapai hasil terbaik dalam tugas pencarian, Anda harus memproses jenis konten yang berbeda dengan vektorisasi yang ditargetkan untuk memanfaatkan sepenuhnya peran masing-masing. Parameter text_type dirancang untuk tujuan ini:

• text_type: 'query': Gunakan untuk teks kueri yang dimasukkan pengguna. Model menghasilkan vektor "seperti judul" yang lebih terarah dan dioptimalkan untuk "bertanya" dan "menemukan".

• text_type: 'document' (default): Gunakan untuk teks dokumen yang disimpan di database. Model menghasilkan vektor "seperti isi" yang berisi informasi lebih komprehensif dan dioptimalkan untuk diambil.

Saat menggunakan teks pendek untuk mencocokkan teks panjang, bedakan antara query dan document. Untuk tugas di mana semua teks memiliki peran yang sama, seperti pengelompokan atau klasifikasi, Anda tidak perlu menyetel parameter ini.

Gunakan instruksi untuk meningkatkan kinerja (instruct)

Parameter ini saat ini hanya dapat diaktifkan melalui SDK dan API DashScope.

Dengan memberikan instruksi bahasa Inggris yang jelas, Anda dapat membimbing model text-embedding-v4 untuk mengoptimalkan kualitas vektor bagi skenario pengambilan tertentu, sehingga secara efektif meningkatkan presisi. Saat menggunakan fitur ini, Anda harus menyetel parameter text_type ke query.

# Skenario: Saat membangun vektor dokumen untuk mesin pencari, Anda dapat menambahkan instruksi untuk mengoptimalkan kualitas vektor untuk pengambilan.
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"
)

Vektor padat dan vektor jarang

Parameter ini saat ini hanya dapat diaktifkan melalui SDK dan API DashScope.

text-embedding-v4 dan text-embedding-v3 mendukung tiga jenis keluaran vektor untuk memenuhi kebutuhan strategi pengambilan yang berbeda.

Pencarian semantik

Anda dapat mencapai pencocokan semantik yang tepat dengan menghitung kesamaan vektor antara kueri dan dokumen.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti base_url dengan: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Hitung kesamaan cosinus"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

def semantic_search(query, documents, top_k=5):
    """Lakukan pencarian semantik"""
    # Hasilkan vektor kueri
    query_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

    # Hasilkan vektor dokumen
    doc_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=documents,
        dimension=1024
    )

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

    # Urutkan dan kembalikan hasil top_k
    similarities.sort(key=lambda x: x[1], reverse=True)
    return [(documents[i], sim) for i, sim in similarities[:top_k]]

# Contoh penggunaan
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"Kesamaan: {sim:.3f}, Dokumen: {doc}")

Sistem rekomendasi

Anda dapat menemukan minat pengguna dan merekomendasikan item serupa dengan menganalisis vektor dari perilaku historis mereka.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti base_url dengan: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Hitung kesamaan cosinus"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
def build_recommendation_system(user_history, all_items, top_k=10):
    """Bangun sistem rekomendasi"""
    # Hasilkan vektor riwayat pengguna
    history_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=user_history,
        dimension=1024
    )

    # Hitung vektor preferensi pengguna (dengan merata-ratakan)
    user_embedding = np.mean([
        emb['embedding'] for emb in history_resp.output['embeddings']
    ], axis=0)

    # Hasilkan semua vektor item
    items_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=all_items,
        dimension=1024
    )

    # Hitung skor rekomendasi
    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))

    # Urutkan dan kembalikan hasil rekomendasi
    recommendations.sort(key=lambda x: x[1], reverse=True)
    return recommendations[:top_k]

# Contoh penggunaan
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"Skor Rekomendasi: {score:.3f}, Film: {movie}")

Pengelompokan teks

Anda dapat mengelompokkan teks serupa secara otomatis dengan menganalisis jarak antara vektor-vektornya.

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

# Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti base_url dengan: 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):
    """Kelompokkan sekumpulan teks"""
    # 1. Dapatkan vektor untuk semua teks
    resp = dashscope.TextEmbedding.call(
        model="text-embedding-v4",
        input=texts,
        dimension=1024
    )
    embeddings = np.array([item['embedding'] for item in resp.output['embeddings']])

    # 2. Gunakan algoritma KMeans untuk pengelompokan
    kmeans = KMeans(n_clusters=n_clusters, random_state=0, n_init='auto').fit(embeddings)

    # 3. Atur dan kembalikan hasilnya
    clusters = {i: [] for i in range(n_clusters)}
    for i, label in enumerate(kmeans.labels_):
        clusters[label].append(texts[i])
    return clusters


# Contoh penggunaan
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}")

Klasifikasi teks

Anda dapat mengenali dan mengklasifikasikan kategori baru tanpa contoh berlabel sebelumnya dengan menghitung kesamaan vektor antara teks masukan dan label yang telah ditentukan.

import dashscope
import numpy as np

# Jika Anda menggunakan model di wilayah Tiongkok (Beijing), ganti base_url dengan: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = 'https://dashscope-intl.aliyuncs.com/api/v1'

def cosine_similarity(a, b):
    """Hitung kesamaan cosinus"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def classify_text_zero_shot(text, labels):
    """Lakukan klasifikasi teks zero-shot"""
    # 1. Dapatkan vektor untuk teks masukan dan semua label
    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. Hitung kesamaan dengan setiap label
    scores = [cosine_similarity(text_embedding, label_emb) for label_emb in label_embeddings]

    # 3. Kembalikan label dengan kesamaan tertinggi
    best_match_index = np.argmax(scores)
    return labels[best_match_index], scores[best_match_index]


# Contoh penggunaan
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"Teks masukan: '{text_to_classify}'")
print(f"Kategori yang paling cocok: '{label}' (Kesamaan: {score:.3f})")

Deteksi anomali

Anda dapat mengidentifikasi data anomali yang berbeda secara signifikan dari pola normal dengan menghitung kesamaan vektor antara vektor teks dan pusat vektor sampel normal.

Ambang batas dalam kode contoh hanya untuk tujuan demonstrasi. Dalam skenario bisnis dunia nyata, nilai kesamaan spesifik bervariasi tergantung pada konten dan distribusi data. Tidak ada ambang batas tetap. Kalibrasi nilai ini berdasarkan dataset Anda sendiri.

import dashscope
import numpy as np


def cosine_similarity(a, b):
    """Hitung kesamaan cosinus"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def detect_anomaly(new_comment, normal_comments, threshold=0.6):
    # 1. Vektorisasi semua komentar normal dan komentar baru
    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. Hitung vektor pusat (nilai rata-rata) komentar normal
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. Hitung kesamaan antara komentar baru dan vektor pusat
    new_comment_embedding = np.array(embeddings[-1])
    similarity = cosine_similarity(new_comment_embedding, normal_center_vector)

    # 4. Tentukan apakah ini anomali
    is_anomaly = similarity < threshold
    return is_anomaly, similarity


# Contoh penggunaan
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("--- Contoh Deteksi Anomali ---")
for desc, comment in test_comments.items():
    is_anomaly, score = detect_anomaly(comment, normal_user_comments)
    result = "Ya" if is_anomaly else "Tidak"
    print(f"Komentar: '{comment}'")
    print(f"Apakah anomali: {result} (Kesamaan dengan sampel normal: {score:.3f})\n")