Alibaba Cloud Model Studio:Penyematan

Penyematan multimodal

Model menghasilkan penyematan vektor dari input teks, gambar, atau video. Gunakan penyematan ini untuk klasifikasi video, klasifikasi gambar, pengambilan gambar-teks, pencarian teks-ke-gambar, dan pencarian teks-ke-video.

API mendukung input tunggal berupa teks, gambar, atau video, serta input gabungan seperti teks dan gambar. Beberapa model mendukung beberapa input jenis yang sama, seperti beberapa gambar dalam satu permintaan. Untuk batasan spesifik, lihat keterbatasan masing-masing model.

Batasan input dan bahasa:

Dimensi penyematan kustom

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

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

• Persyaratan presisi tinggi: Untuk aplikasi presisi tinggi, pilih dimensi 1536 atau 2048. Ini meningkatkan presisi tetapi juga secara signifikan meningkatkan overhead penyimpanan dan komputasi.

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

import os
from openai import OpenAI

client = OpenAI(
    # Kunci API berbeda berdasarkan Region. Untuk mendapatkan Kunci API, lihat https://www.alibabacloud.com/help/en/model-studio/get-api-key
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Berikut adalah URL untuk Region Singapura. Jika Anda menggunakan model di Region China (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"],
    # Atur dimensi vektor ke 256
    dimensions=256
)
print(f"Dimensi vektor: {len(resp.data[0].embedding)}")

import dashscope

# Jika Anda menggunakan model di Region China (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"],
    # Atur dimensi vektor ke 256
    dimension=256
)

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

Teks kueri dan dokumen (text_type)

Parameter ini hanya tersedia melalui SDK dan API DashScope.

Untuk mencapai hasil optimal dalam tugas pencarian, proses konten berbeda berdasarkan perannya. 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 dalam basis pengetahuan Anda. Model menghasilkan vektor "seperti isi" yang berisi informasi lebih komprehensif dan dioptimalkan untuk pencocokan.

Ketika Anda 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.

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

# Skenario: Saat membangun vektor dokumen untuk mesin pencari, tambahkan 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 hanya tersedia melalui SDK dan API DashScope.

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

Pencarian semantik

Hitung kesamaan vektor antara kueri dan dokumen untuk melakukan pencarian semantik yang akurat.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Jika Anda menggunakan model di Region China (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 kosinus.""
    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 penyematan kueri.
    query_resp = TextEmbedding.call(
        model="text-embedding-v4",
        input=query,
        dimension=1024
    )
    query_embedding = query_resp.output['embeddings'][0]['embedding']

    # Hasilkan penyematan 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

Analisis vektor dari riwayat perilaku pengguna untuk mengidentifikasi preferensi dan merekomendasikan item serupa.

import dashscope
import numpy as np
from dashscope import TextEmbedding

# Jika Anda menggunakan model di Region China (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 kosinus.""
    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 penyematan 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 penyematan 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

Secara otomatis kelompokkan teks serupa dengan menganalisis jarak antar vektornya.

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

# Jika Anda menggunakan model di Region China (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 penyematan 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 kesamaan vektor antara teks input dan label yang telah ditentukan. Metode ini mengklasifikasikan teks tanpa memerlukan contoh berlabel sebelumnya.

import dashscope
import numpy as np

# Jika Anda menggunakan model di Region China (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 kosinus.""
    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 penyematan 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 dengan menghitung kesamaan vektornya terhadap vektor pusat sampel normal. Skor kesamaan rendah menunjukkan potensi anomali.

Ambang batas dalam kode contoh hanya untuk demonstrasi. Dalam praktiknya, nilai ambang batas ideal bergantung pada konten dan distribusi data Anda, sehingga tidak ada nilai tetap. Kalibrasi nilai ini pada dataset Anda sendiri.

import dashscope
import numpy as np


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


def detect_anomaly(new_comment, normal_comments, threshold=0.6):
    ""Deteksi anomali.""
    # 1. Hasilkan penyematan 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 vektor pusat (rata-rata) komentar normal.
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. Hitung kesamaan antara penyematan 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")