Alibaba Cloud Model Studio：Embedding

Multimodal embedding

Model menghasilkan vektor kontinu berdasarkan input pengguna, yang dapat berupa teks, citra, atau video. Ini cocok untuk tugas-tugas seperti klasifikasi video, klasifikasi citra, pengambilan citra-teks, pencarian citra menggunakan teks atau citra lain, serta pencarian video menggunakan teks atau citra.

API mendukung pengunggahan satu segmen teks, satu citra, atau satu file video. API juga memungkinkan kombinasi berbagai jenis (seperti teks dan citra). Beberapa model mendukung beberapa input dari jenis yang sama (seperti beberapa citra). Untuk informasi lebih lanjut, lihat batasan model tertentu.

Format input dan batasan bahasa:

Ubah dimensi embedding

text-embedding-v4 dan text-embedding-v3 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.

• Presisi tinggi: Untuk domain yang membutuhkan presisi tinggi, pilih dimensi 1536 atau 2048. Ini meningkatkan presisi tetapi secara signifikan meningkatkan beban penyimpanan dan komputasi.

• Sumber daya terbatas: Dalam skenario yang sensitif terhadap biaya, pilih dimensi 768 atau lebih rendah. Ini secara signifikan mengurangi konsumsi sumber daya tetapi mengakibatkan kehilangan sebagian 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 come back to buy more"],
    # Setel dimensi embedding menjadi 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 come back to buy more"],
    # Setel dimensi embedding menjadi 256
    dimension=256
)

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

Beda antara teks query dan dokumen (text_type)

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

Untuk mencapai hasil terbaik dalam tugas pencarian, proses berbagai jenis konten dengan metode embedding spesifik berdasarkan tujuan tugas. Hal ini memungkinkan setiap jenis berfungsi secara optimal. Parameter text_type dirancang untuk tujuan ini:

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

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

Saat mencocokkan teks pendek dengan 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.

Tingkatkan kinerja dengan instruksi tugas (instruct)

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

Berikan instruksi bahasa Inggris yang jelas untuk membimbing model text-embedding-v4 agar mengoptimalkan kualitas dan presisi embedding untuk skenario pengambilan tertentu. 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 embedding 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 output vektor untuk memenuhi kebutuhan strategi pengambilan yang berbeda.

Pencarian semantik

Hitung kesamaan vektor antara query dan dokumen untuk mencapai pencocokan semantik yang tepat.

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):
    """Pencarian semantik"""
    # Hasilkan vektor query
    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

Analisis vektor riwayat perilaku pengguna untuk menemukan preferensi pengguna 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 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 vektor untuk 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

Analisis jarak antar vektor untuk mengelompokkan teks serupa secara otomatis.

# 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 sekelompok 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. Susun 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 = [
    "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 at the Olympics",
    "A company releases its latest AI chip",
    "Euro 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

Hitung kesamaan vektor antara teks input dan label yang telah ditentukan untuk mengidentifikasi dan mengklasifikasikan 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 kesamaan cosinus"""
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))


def classify_text_zero_shot(text, labels):
    """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

Hitung kesamaan vektor antara vektor teks dan pusat sampel normal untuk mengidentifikasi data anomali yang berbeda secara signifikan dari pola reguler.

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 komentar normal (rata-rata).
    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 very productive",
    "The project is progressing smoothly",
    "A 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")