Alibaba Cloud Model Studio:Embedding

Multimodal embedding

Model ini menghasilkan embedding dari input teks, gambar, atau video. Anda dapat menggunakan embedding ini untuk tugas seperti klasifikasi video dan gambar, pengambilan gambar-teks, serta pencarian teks-ke-gambar atau teks-ke-video.

API menerima input teks, gambar, atau video tunggal, serta kombinasi seperti teks dan gambar. Beberapa model mendukung beberapa input dari jenis yang sama, seperti beberapa gambar. Untuk detailnya, lihat batasan untuk setiap model.

Batasan input dan bahasa

Menyesuaikan dimensi vektor

Model 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 lebih banyak informasi semantik tetapi meningkatkan biaya penyimpanan dan komputasi.

• Kasus penggunaan umum (Direkomendasikan): Dimensi 1024 memberikan keseimbangan optimal antara performa dan biaya, menjadikannya ideal untuk sebagian besar tugas pencarian semantik.

• Skenario presisi tinggi: Untuk aplikasi yang memerlukan presisi tinggi, Anda dapat memilih dimensi 1536 atau 2048. Hal ini meningkatkan presisi tetapi secara signifikan meningkatkan beban penyimpanan dan komputasi.

• Lingkungan dengan sumber daya terbatas: Dalam skenario yang sensitif terhadap biaya, pilih dimensi 768 atau lebih rendah. Hal ini secara signifikan mengurangi konsumsi sumber daya dengan mengorbankan sebagian informasi semantik.

import os
from openai import OpenAI

client = OpenAI(
    # Kunci API bersifat spesifik per wilayah. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Ini adalah URL dasar untuk wilayah Singapura. Ganti {WorkspaceId} dengan ID Ruang Kerja Anda. URL bersifat spesifik per wilayah.
    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"],
    # Atur 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_http_api_url dengan: 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"],
    # Atur dimensi vektor ke 256
    dimension=256
)

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

Teks kueri vs. dokumen (text_type)

Parameter ini hanya tersedia melalui SDK dan API DashScope.

Untuk mencapai hasil optimal dalam tugas pencarian, Anda harus melakukan vektorisasi konten secara berbeda berdasarkan perannya. Parameter text_type dirancang untuk tujuan ini:

• text_type: 'query': Gunakan untuk teks kueri yang diberikan pengguna. Model menghasilkan vektor "seperti judul" yang lebih terarah dan dioptimalkan untuk pengambilan informasi.

• text_type: 'document' (default): Gunakan untuk teks dokumen yang disimpan dalam basis pengetahuan Anda. Model menghasilkan vektor "seperti isi" yang berisi informasi lebih komprehensif dan dioptimalkan untuk pencocokan.

Saat mencocokkan teks pendek dengan teks panjang, Anda harus membedakan antara query dan document. Namun, untuk tugas seperti pengelompokan atau klasifikasi di mana semua teks memiliki peran yang sama, Anda tidak perlu mengatur parameter ini.

Instruksi tugas (instruct)

Parameter ini hanya tersedia melalui SDK dan API DashScope.

Anda dapat memberikan instruksi tugas berbahasa Inggris yang jelas untuk membimbing model text-embedding-v4 dalam mengoptimalkan kualitas vektor untuk skenario pengambilan tertentu, sehingga meningkatkan presisi. Saat menggunakan fitur ini, Anda harus mengatur parameter text_type ke query.

# Contoh: Tambahkan instruksi untuk mengoptimalkan kualitas pengambilan saat membangun vektor dokumen.
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 hanya tersedia melalui SDK dan API DashScope.

Model text-embedding-v4 dan text-embedding-v3 mendukung tiga jenis output vektor untuk mengakomodasi strategi pengambilan yang berbeda.

Pencarian semantik

Lakukan pencocokan semantik yang tepat dengan menghitung kemiripan antara embedding kueri dan embedding dokumen.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Untuk menggunakan model dari wilayah Tiongkok (Beijing), ubah base_http_api_url menjadi: 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):
    """Hitung kemiripan 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 embedding kueri.
    query_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

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

    # Hitung kemiripan.
    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"Kemiripan: {sim:.3f}, Dokumen: {doc}")

Sistem rekomendasi

Analisis embedding riwayat perilaku pengguna untuk mengidentifikasi minat mereka dan merekomendasikan item serupa.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Untuk menggunakan model dari wilayah Tiongkok (Beijing), ubah base_http_api_url menjadi: 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):
    """Hitung kemiripan 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 embedding riwayat pengguna.
    history_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=user_history,
        dimension=1024
    )

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

    # Hasilkan embedding semua 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

Kelompokkan teks serupa dengan menganalisis jarak antara embedding-nya.

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

# Untuk menggunakan model dari wilayah Tiongkok (Beijing), ubah base_http_api_url menjadi: 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):
    """Kelompokkan sekumpulan teks."""
    # 1. Dapatkan embedding 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"--- Kluster {cluster_id} ---")
    for doc in docs:
        print(f"- {doc}")

Klasifikasi teks

Lakukan klasifikasi teks zero-shot dengan menghitung kemiripan antara embedding teks input dan embedding label yang telah ditentukan. Proses ini mengklasifikasikan teks ke dalam kategori baru tanpa memerlukan contoh berlabel sebelumnya.

import dashscope
import numpy as np

# Untuk menggunakan model dari wilayah Tiongkok (Beijing), ubah base_http_api_url menjadi: 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):
    """Hitung kemiripan 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 embedding 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 kemiripan dengan setiap label.
    scores = [cosine_similarity(text_embedding, label_emb) for label_emb in label_embeddings]

    # 3. Kembalikan label dengan kemiripan 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 too"
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}' (Kemiripan: {score:.3f})")

Deteksi anomali

Identifikasi data anomali dengan menghitung kemiripan antara embedding teks dan embedding pusat sampel normal. Data yang secara signifikan menyimpang dari pola ini dianggap sebagai anomali.

threshold dalam contoh ini hanya untuk tujuan demonstrasi. Nilai ideal bervariasi berdasarkan konten dan distribusi data, sehingga Anda harus mengkalibrasinya menggunakan dataset Anda sendiri.

import dashscope
import numpy as np

# Untuk menggunakan model dari wilayah Tiongkok (Beijing), ubah base_http_api_url menjadi: 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):
    """Hitung kemiripan 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. Hasilkan embedding untuk 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 embedding pusat (rata-rata) komentar normal.
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. Hitung kemiripan antara embedding komentar baru dan embedding 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} (Kemiripan dengan sampel normal: {score:.3f})\n")