Alibaba Cloud Model Studio:Penyematan

Penyematan multimodal

Model menghasilkan penyematan vektor dari masukan seperti teks, gambar, atau video. Penyematan ini digunakan untuk klasifikasi video, klasifikasi gambar, pengambilan gambar-teks, pencarian teks-ke-gambar, dan pencarian teks-ke-video.

Anda dapat mengunggah satu segmen teks, gambar, atau file video. API juga mendukung kombinasi jenis masukan, seperti teks dan gambar. Beberapa model mendukung beberapa masukan jenis yang sama, seperti beberapa gambar. Untuk detailnya, lihat batasan masing-masing model.

Batasan masukan dan bahasa

Dimensi vektor kustom

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 presisi tinggi, pilih dimensi 1536 atau 2048. Ini meningkatkan presisi tetapi 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 bervariasi berdasarkan 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 untuk Singapura. Untuk menggunakan model di wilayah Tiongkok (Beijing), ganti `base_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

# Untuk 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"],
    # 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, vektorisasi konten secara berbeda berdasarkan perannya yang dimaksudkan. Parameter text_type dirancang untuk tujuan ini:

• text_type: 'query': Gunakan untuk teks kueri 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.

Saat mencocokkan teks pendek dengan teks panjang, bedakan 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. Saat menggunakan fitur ini, atur 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 hanya tersedia melalui SDK dan API DashScope.

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

Pencarian semantik

Raih pencocokan semantik tepat dengan menghitung kemiripan penyematan 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 kemiripan 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 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 penyematan dari riwayat perilaku pengguna untuk mengidentifikasi minat dan merekomendasikan item serupa.

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 kemiripan 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 penyematan preferensi pengguna (dengan merata-ratakan).
    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

Kelompokkan teks serupa secara otomatis dengan menganalisis jarak antar penyematan 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 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 kemiripan penyematan antara teks masukan dan label yang telah ditentukan. Pendekatan ini mengklasifikasikan teks ke dalam kategori baru tanpa contoh berlabel sebelumnya.

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

Deteksi anomali

Identifikasi data anomali dengan menghitung kemiripan penyematan terhadap penyematan pusat sampel normal. Skor kemiripan rendah menunjukkan anomali.

ambang batas dalam kode contoh hanya untuk demonstrasi. Dalam produksi, skor kemiripan bervariasi berdasarkan konten dan distribusi data, sehingga tidak ada ambang batas universal. Kalibrasi nilai ini pada dataset Anda sendiri.

import dashscope
import numpy as np


def cosine_similarity(a, b):
    """Hitung kemiripan kosinus."""
    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 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 penyematan pusat (rata-rata) komentar normal.
    normal_embeddings = np.array(embeddings[:-1])
    normal_center_vector = np.mean(normal_embeddings, axis=0)

    # 3. Hitung kemiripan antara penyematan komentar baru dan penyematan 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")