Alibaba Cloud Model Studio：Embedding

Multimodal embedding

Model menghasilkan vektor kontinu berdasarkan input pengguna, yang dapat berupa teks, gambar, atau video. Ini cocok untuk tugas seperti klasifikasi video, klasifikasi gambar, pengambilan teks-gambar, 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 input dari jenis yang sama (seperti beberapa gambar). Untuk informasi lebih lanjut, lihat detail batasan untuk model tertentu.

Batasan input:

Mengganti dimensi embedding

text-embedding-v4, text-embedding-v3, tongyi-embedding-vision-plus, tongyi-embedding-vision-flash, dan qwen3-vl-embedding mendukung dimensi embedding 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 membutuhkan 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 embedding ke 256
    dimensions=256
)
print(f"Dimensi embedding: {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 embedding ke 256
    dimension=256
)

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

Membedakan antara teks kueri dan dokumen (text_type)

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

Untuk mencapai hasil terbaik dalam tugas pencarian, proses konten jenis berbeda dengan embedding 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 DashScope SDK dan API.

Berikan instruksi bahasa Inggris yang jelas untuk membimbing text-embedding-v4 mengoptimalkan kualitas vektor untuk skenario pengambilan tertentu, sehingga secara efektif meningkatkan presisi. Saat menggunakan fitur ini, setel 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 jarang

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

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

Pencarian semantik

Mencapai pencocokan semantik presisi 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

Temukan minat pengguna dan rekomendasikan 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 rata-rata)
    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

Otomatis mengelompokkan teks serupa dengan menganalisis jarak antara vektor mereka.

# 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

Kenali dan klasifikasikan kategori baru tanpa contoh berlabel sebelumnya dengan menghitung kesamaan vektor antara teks input 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 input 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 input: '{text_to_classify}'")
print(f"Kategori yang paling cocok: '{label}' (Kesamaan: {score:.3f})")

Deteksi anomali

Identifikasi 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")