OpenSearch:Penguraian dan vektorisasi data multimodal

Kasus penggunaan

Pipeline pra-pemrosesan data multimodal memproses dokumen dan gambar tak terstruktur melalui lima layanan: penguraian dokumen, penguraian gambar, pemisahan dokumen (document chunking), penyematan teks (text embedding), dan penyematan teks sparse. Semua layanan dipanggil melalui API Platform Terbuka Pencarian AI, dan Anda dikenai biaya berdasarkan penggunaan aktual.

Prasyarat

• Platform Terbuka Pencarian AI telah diaktifkan. Aktifkan Layanan.

• Titik akhir API dan Kunci API Anda sudah siap. Kueri titik akhir layanan, Kelola Kunci API.

  Anda dapat memanggil layanan melalui Internet atau melalui VPC. Panggilan lintas wilayah (cross-region) melalui VPC didukung di wilayah Tiongkok (Shanghai), Tiongkok (Hangzhou), Tiongkok (Shenzhen), Tiongkok (Beijing), Tiongkok (Zhangjiakou), dan Tiongkok (Qingdao).

Buat pipeline pra-pemrosesan data multimodal

Langkah 1: Pilih layanan dan unduh kode

Prosedur ini menggunakan Python SDK untuk membuat pipeline pra-pemrosesan data multimodal.

1. Masuk ke Konsol Platform Terbuka Pencarian AI.

2. Pilih wilayah Tiongkok (Shanghai), alihkan ke AI Search Open Platform, lalu alihkan ke ruang kerja target.

   Catatan

   • Platform Terbuka Pencarian AI hanya tersedia di wilayah Tiongkok (Shanghai) dan Jerman (Frankfurt).

   • Pengguna di wilayah Tiongkok (Hangzhou), Tiongkok (Shenzhen), Tiongkok (Beijing), Tiongkok (Zhangjiakou), dan Tiongkok (Qingdao) dapat menggunakan titik akhir VPC untuk memanggil layanan Platform Terbuka Pencarian AI lintas wilayah.

3. Di panel navigasi sebelah kiri, pilih Scene Center. Temukan Multimodal Data Preprocessing - Data Parsing and Vectorization dan klik Enter.

4. Dari daftar drop-down, pilih layanan yang Anda butuhkan. Anda dapat melihat informasi detail setiap layanan di halaman Service Details.

   Catatan

   • Setiap layanan memerlukan ID layanan (service_id). Misalnya, ID layanan penguraian dokumen adalah ops-document-analyze-001.

   • service_id dalam kode yang dihasilkan akan diperbarui secara otomatis saat Anda mengganti layanan. Anda juga dapat mengubah service_id secara manual setelah mengunduh kode.

   Tahap	Deskripsi
   Penguraian konten dokumen	Layanan Penguraian Konten Dokumen (ops-document-analyze-001): Mengekstraksi struktur logis seperti judul dan paragraf dari dokumen tak terstruktur (teks, tabel, dan gambar) serta mengembalikan konten terstruktur.
   Penguraian konten gambar	Layanan Pemahaman Konten Gambar (ops-image-analyze-vlm-001): Menggunakan LLM multimodal untuk mengurai konten gambar dan mengenali teks guna pengambilan (retrieval) dan tanya jawab berbasis gambar. Layanan Pengenalan Teks Gambar (ops-image-analyze-ocr-001): Menggunakan OCR untuk mengenali teks dalam gambar guna pengambilan dan tanya jawab.
   Pemisahan dokumen	Layanan Pemisahan Dokumen (ops-document-split-001): Memisahkan data terstruktur dalam format HTML, Markdown, dan TXT berdasarkan paragraf, semantik, atau aturan kustom. Juga mengekstraksi kode, gambar, dan tabel dari rich text.
   Penyematan teks	Layanan penyematan teks OpenSearch-001 (ops-text-embedding-001): Mendukung lebih dari 40 bahasa. Input maksimum: 300 token. Output: vektor berdimensi 1.536. Layanan penyematan teks umum OpenSearch-002 (ops-text-embedding-002): Mendukung lebih dari 100 bahasa. Input maksimum: 8.192 token. Output: vektor berdimensi 1.024. Layanan penyematan teks OpenSearch-Khusus Mandarin-001 (ops-text-embedding-zh-001): Khusus bahasa Mandarin. Input maksimum: 1.024 token. Output: vektor berdimensi 768. Layanan penyematan teks OpenSearch-Khusus Inggris-001 (ops-text-embedding-en-001): Khusus bahasa Inggris. Input maksimum: 512 token. Output: vektor berdimensi 768.
   Penyematan teks sparse	Mengonversi teks menjadi representasi vektor sparse. Vektor sparse membutuhkan penyimpanan lebih sedikit dan menangkap kata kunci serta frekuensi istilah. Gabungkan dengan vektor padat untuk pencarian hibrida guna meningkatkan pengambilan (retrieval). Layanan penyematan teks sparse OpenSearch (ops-text-sparse-embedding-001): Mendukung lebih dari 100 bahasa. Input maksimum: 8.192 token.

Setelah memilih layanan, klik After the configuration is completed, enter the code query untuk melihat dan mengunduh kode. Tabel berikut menjelaskan alur waktu proses pipeline pra-pemrosesan data.

Di bawah Code Query, pilih Document Parsing and Vectorization. Klik Copy Code atau Download File untuk menyimpan kode secara lokal.

Langkah 2: Konfigurasi lingkungan dan uji pipeline

Konfigurasikan parameter berikut setelah mengunduh kode.

# Konfigurasi Platform Terbuka Pencarian AI
api_key = "xxx"
host = "http://xxx.platform-cn-shanghai.opensearch.aliyuncs.com"
workspace_name = "default"
# konfigurasi ID layanan
service_id_config = {"extract": "ops-document-analyze-001", "split": "ops-document-split-001", "emb": "ops-text-embedding-001"}

Jalankan kode di Python 3.8.1 atau versi yang lebih baru untuk memverifikasi hasilnya.

Contoh output dari pra-pemrosesan dokumen Pengantar Platform Terbuka Pencarian AI:

C:\Users\issuser\PycharmProjects\pythonProject630Demo\.venv\Scripts\python.exe C:\Users\issuser\PycharmProjects\pythonProject3\.venv\Lib\site-packages\alibabacloud_searchplat2...
document_analyze task_id:f6dd92de-01e4-46a2-96c4-b80e7b120239
document_analyze done
document-split done, chunks count: 6 rich text count:9
image analyze :https://img.alicdn.com/imgextra/i2/O1CN01bYc1m81RrcSAyOjMu_!!6000000002165-54-tps-60-60.apng
https://img.alicdn.com/imgextra/i2/O1CN01bYc1m81RrcSAyOjMu_!!6000000002165-54-tps-60-60.apng is  unanalysable.
image analyze :https://help-static-aliyun-doc.aliyuncs.com/assets/img/zh-CN/3873436171/p802381.png
image analyze :https://help-static-aliyun-doc.aliyuncs.com/assets/img/zh-CN/0517992271/p821030.png
image analyze ://gw.alicdn.com/tfs/TB16xwdSXXXXXa.aXXXXXXXXXXX-65-70.gif
https://gw.alicdn.com/tfs/TB16xwdSXXXXXa.aXXXXXXXXXXX-65-70.gif is  unanalysable.
image analyze ://img.alicdn.com/tfs/TB1..50QpXXXXX7XpXXXXXXXXXX-40-40.png
image analyze :https://img.alicdn.com/tfs/TB1UdKEM6TpK1RjSZKPXXa3UpXa-256-256.png
image analyze :https://img.alicdn.com/tfs/TB1A0dINW6qK1RjSZFmXXX0PFXa-258-258.jpg
image analyze ://gw.alicdn.com/tfs/TB16xwdSXXXXXa.aXXXXXXXXXXX-65-70.gif
https://gw.alicdn.com/tfs/TB16xwdSXXXXXa.aXXXXXXXXXXX-65-70.gif is  unanalysable.
image analyze ://img.alicdn.com/tfs/TB1..50QpXXXXX7XpXXXXXXXXXX-40-40.png
text-embedding done.
Process finished with exit code 0

Kode pipeline lengkap:

# Pipeline pemrosesan data multimodal
# Persyaratan:
# Versi Python: 3.8.1 atau lebih baru
# Persyaratan paket:
# pip install alibabacloud_searchplat20240529
# Konfigurasi Platform Terbuka Pencarian AI
aisearch_endpoint = "xxx.platform-cn-shanghai.opensearch.aliyuncs.com"
api_key = "OS-xxx"
workspace_name = "default"
service_id_config = {"document_analyze": "ops-document-analyze-001",
                     "split": "ops-document-split-001",
                     "text_embedding": "ops-text-embedding-001",
                     "text_sparse_embedding": "ops-text-sparse-embedding-001",
                     "image_analyze": "ops-image-analyze-ocr-001"}
# URL dokumen input. Dokumen contoh adalah pengantar Platform Terbuka Pencarian AI.
document_url = "https://www.alibabacloud.com/help/zh/open-search/search-platform/product-overview/introduction-to-search-platform?spm=a2c4g.11186623.0.0.7ab93526WDzQ8z"
import asyncio
from operator import attrgetter
from typing import List
from Tea.exceptions import TeaException, RetryError
from alibabacloud_tea_openapi.models import Config
from alibabacloud_searchplat20240529.client import Client
from alibabacloud_searchplat20240529.models import GetDocumentSplitRequest, CreateDocumentAnalyzeTaskRequest, \
    CreateDocumentAnalyzeTaskRequestDocument, GetDocumentAnalyzeTaskStatusRequest, \
    GetDocumentSplitRequestDocument, GetTextEmbeddingRequest, GetTextEmbeddingResponseBodyResultEmbeddings, \
    GetTextSparseEmbeddingRequest, GetTextSparseEmbeddingResponseBodyResultSparseEmbeddings, \
    GetImageAnalyzeTaskStatusResponse, CreateImageAnalyzeTaskRequest, GetImageAnalyzeTaskStatusRequest, \
    CreateImageAnalyzeTaskRequestDocument, CreateImageAnalyzeTaskResponse
async def poll_doc_analyze_task_result(ops_client, task_id, service_id, interval=5):
    while True:
        request = GetDocumentAnalyzeTaskStatusRequest(task_id=task_id)
        response = await ops_client.get_document_analyze_task_status_async(workspace_name, service_id, request)
        status = response.body.result.status
        if status == "PENDING":
            await asyncio.sleep(interval)
        elif status == "SUCCESS":
            return response
        else:
            print("error: " + response.body.result.error)
            raise Exception("document analyze task failed")
def is_analyzable_url(url:str):
    if not url:
        return False
    image_extensions = {'.jpg', '.jpeg', '.png', '.bmp', '.tiff'}
    return url.lower().endswith(tuple(image_extensions))
async def image_analyze(ops_client, url):
    try:
        print("image analyze :" + url)
        if url.startswith("//"):
            url = "https:" + url
        if not is_analyzable_url(url):
            print(url + " is  unanalysable.")
            return url
        image_analyze_service_id = service_id_config["image_analyze"]
        document = CreateImageAnalyzeTaskRequestDocument(
            url=url,
        )
        request = CreateImageAnalyzeTaskRequest(document=document)
        response: CreateImageAnalyzeTaskResponse = ops_client.create_image_analyze_task(workspace_name, image_analyze_service_id, request)
        task_id = response.body.result.task_id
        while True:
            request = GetImageAnalyzeTaskStatusRequest(task_id=task_id)
            response: GetImageAnalyzeTaskStatusResponse = ops_client.get_image_analyze_task_status(workspace_name, image_analyze_service_id, request)
            status = response.body.result.status
            if status == "PENDING":
                await asyncio.sleep(5)
            elif status == "SUCCESS":
                return url + response.body.result.data.content
            else:
                print("image analyze error: " + response.body.result.error)
                return url
    except Exception as e:
        print(f"image analyze Exception : {e}")
def chunk_list(lst, chunk_size):
    for i in range(0, len(lst), chunk_size):
        yield lst[i:i + chunk_size]
async def document_pipeline_execute(document_url: str = None, document_base64: str = None, file_name: str = None):
    # Buat client Platform Terbuka Pencarian AI.
    config = Config(bearer_token=api_key,endpoint=aisearch_endpoint,protocol="http")
    ops_client = Client(config=config)
    # Langkah 1: Penguraian dokumen/gambar
    document_analyze_request = CreateDocumentAnalyzeTaskRequest(document=CreateDocumentAnalyzeTaskRequestDocument(url=document_url, content=document_base64,file_name=file_name, file_type='html'))
    document_analyze_response = await ops_client.create_document_analyze_task_async(workspace_name=workspace_name,service_id=service_id_config["document_analyze"],request=document_analyze_request)
    print("document_analyze task_id:" + document_analyze_response.body.result.task_id)
    extraction_result = await poll_doc_analyze_task_result(ops_client, document_analyze_response.body.result.task_id, service_id_config["document_analyze"])
    print("document_analyze done")
    document_content = extraction_result.body.result.data.content
    content_type = extraction_result.body.result.data.content_type
    # Langkah 2: Pemisahan dokumen
    document_split_request = GetDocumentSplitRequest(
        GetDocumentSplitRequestDocument(content=document_content, content_type=content_type))
    document_split_result = await ops_client.get_document_split_async(workspace_name, service_id_config["split"],
                                                                      document_split_request)
    print("document-split done, chunks count: " + str(len(document_split_result.body.result.chunks))
          + " rich text count:" + str(len(document_split_result.body.result.rich_texts)))
    # Langkah 3: Penyematan teks
    # Ekstrak hasil pemisahan. Untuk chunk gambar, layanan penguraian gambar mengekstraksi konten teks.
    doc_list = ([{"id": chunk.meta.get("id"), "content": chunk.content} for chunk in document_split_result.body.result.chunks]
                + [{"id": chunk.meta.get("id"), "content": chunk.content} for chunk in document_split_result.body.result.rich_texts if chunk.meta.get("type") != "image"]
                + [{"id": chunk.meta.get("id"), "content": await image_analyze(ops_client,chunk.content)} for chunk in document_split_result.body.result.rich_texts if chunk.meta.get("type") == "image"]
                )
    # Maksimal 32 penyematan dapat dihitung per permintaan.
    chunk_size = 32  
    all_text_embeddings: List[GetTextEmbeddingResponseBodyResultEmbeddings] = []
    for chunk in chunk_list([text["content"] for text in doc_list], chunk_size):
        response = await ops_client.get_text_embedding_async(workspace_name,service_id_config["text_embedding"],GetTextEmbeddingRequest(chunk))
        all_text_embeddings.extend(response.body.result.embeddings)
    all_text_sparse_embeddings: List[GetTextSparseEmbeddingResponseBodyResultSparseEmbeddings] = []
    for chunk in chunk_list([text["content"] for text in doc_list], chunk_size):
        response = await ops_client.get_text_sparse_embedding_async(workspace_name,service_id_config["text_sparse_embedding"],GetTextSparseEmbeddingRequest(chunk,input_type="document",return_token=True))
        all_text_sparse_embeddings.extend(response.body.result.sparse_embeddings)
    for i in range(len(doc_list)):
        doc_list[i]["embedding"] = all_text_embeddings[i].embedding
        doc_list[i]["sparse_embedding"] = all_text_sparse_embeddings[i].embedding
    print("text-embedding done.")
if __name__ == "__main__":
    # Jalankan tugas asinkron.
    #    import nest_asyncio # Hapus komentar dua baris berikut jika Anda menjalankannya di notebook Jupyter.
    #    nest_asyncio.apply() # Hapus komentar dua baris berikut jika Anda menjalankannya di notebook Jupyter.
    asyncio.run(document_pipeline_execute(document_url))
    # asyncio.run(document_pipeline_execute(document_base64="eHh4eHh4eHg...", file_name="attention.pdf")) # Metode alternatif pemanggilan