OpenSearch：Mengurai dan menyematkan data multimodal

Skenario

Pemrosesan data multimodal menyediakan solusi untuk memproses dokumen dan gambar yang tidak terstruktur. Proses ini mencakup penguraian dokumen, penguraian gambar, pemotongan dokumen, penyematan teks, serta vektorisasi teks jarang. Semua layanan ini memerlukan API dari AI Search Open Platform dan akan dikenakan biaya berdasarkan penggunaan aktual.

Prasyarat

• AI Search Open Platform telah diaktifkan. Untuk informasi lebih lanjut, lihat Aktivasi AI Search Open Platform.

• Informasi titik akhir layanan dan otentikasi identitas telah diperoleh. Untuk informasi lebih lanjut, lihat Kueri Titik Akhir Layanan dan Kelola Kunci API.

  AI Search Open Platform mendukung pemanggilan layanan melalui Internet atau virtual private cloud (VPC), termasuk pemanggilan lintas wilayah melalui VPC. Pengguna di wilayah Jerman (Frankfurt) dapat menggunakan titik akhir VPC untuk mengakses layanan di konsol AI Search Open Platform.

Kerangka kerja pengembangan untuk pemrosesan data multimodal

Langkah 1: Pilih layanan dan unduh kode

Dalam contoh ini, SDK untuk Python digunakan sebagai kerangka kerja pengembangan untuk membangun solusi pemrosesan data multimodal.

1. Masuk ke konsol AI Search Open Platform.

2. Di bilah navigasi atas, pilih wilayah Jerman (Frankfurt).

3. Di panel navigasi sisi kiri, pilih Scene Center. Di halaman Scene Center, klik Enter di bagian Multimodal Data Processing Scenario - Data Parsing and Vectorization.

4. Di tab Basic configuration pada tab Scene Development, pilih layanan yang ingin Anda gunakan dari daftar drop-down di kolom Service Name. Di tab Service Details, Anda dapat melihat detail layanan.

   Catatan

   • Jika Anda ingin menggunakan layanan algoritma dalam solusi berbasis RAG dengan memanggil operasi API, tentukan ID layanan menggunakan parameter service_id. Sebagai contoh, ID layanan penguraian konten dokumen adalah ops-document-analyze-001.

   • Setelah memilih layanan, parameter service_id dalam kode yang dihasilkan akan dimodifikasi sesuai. Setelah mengunduh kode ke lingkungan lokal, Anda dapat memodifikasi parameter service_id untuk memanggil layanan lain.

   Layanan	Deskripsi
   Penguraian konten dokumen	Layanan Penguraian Konten Dokumen (ops-document-analyze-001): menyediakan layanan penguraian dokumen umum. Anda dapat menggunakan layanan ini untuk mengekstrak struktur logis, seperti judul dan paragraf, dari dokumen non-struktural, seperti teks, tabel, dan gambar, untuk menghasilkan data terstruktur.
   Penguraian konten gambar	Layanan Pengenalan Konten Gambar 001 (ops-image-analyze-vlm-001): mengurai dan memahami konten gambar serta mengidentifikasi teks berdasarkan model bahasa besar multimodal. Teks yang diurai dapat digunakan untuk skenario pencarian gambar dan penelitian percakapan. Layanan Pengenalan Teks Gambar 001 (ops-image-analyze-ocr-001): menggunakan kemampuan pengenalan karakter optik (OCR) untuk pengenalan teks gambar. Teks yang diurai dapat digunakan untuk skenario pencarian gambar dan penelitian percakapan.
   Pemotongan dokumen	Layanan Pemotongan Dokumen Umum (ops-document-split-001): menyediakan layanan pemotongan teks umum. Anda dapat menggunakan layanan ini untuk membagi data terstruktur dalam format HTML, MARKDOWN, dan TXT berdasarkan paragraf, semantik, dan aturan tertentu. Anda juga dapat mengekstrak kode, gambar, dan tabel dari teks kaya.
   Vektorisasi teks	Layanan Penyematan Teks OpenSearch -001 (ops-text-embedding-001): menyediakan layanan penyematan teks yang mendukung lebih dari 40 bahasa. Panjang maksimum teks input bisa mencapai 300 token, dan dimensi vektor yang dihasilkan adalah 1.536. Layanan Vektorisasi Teks Universal OpenSearch -002 (ops-text-embedding-002): menyediakan layanan penyematan teks yang mendukung lebih dari 100 bahasa. Panjang maksimum teks input bisa mencapai 8.192 token, dan dimensi vektor yang dihasilkan adalah 1.024. Layanan Vektorisasi Teks OpenSearch-Bahasa Cina -001 (ops-text-embedding-zh-001): menyediakan layanan penyematan teks untuk teks Cina. Panjang maksimum teks input bisa mencapai 1.024 token, dan dimensi vektor yang dihasilkan adalah 768. Layanan Vektorisasi Teks OpenSearch-Bahasa Inggris -001 (ops-text-embedding-en-001): menyediakan layanan penyematan teks untuk teks Inggris. Panjang maksimum teks input bisa mencapai 512 token, dan dimensi vektor yang dihasilkan adalah 768.
   Vektorisasi teks jarang	Penyematan teks jarang mengonversi data teks menjadi vektor jarang yang membutuhkan ruang penyimpanan lebih sedikit. Anda dapat menggunakan vektor jarang untuk mengekspresikan kata kunci dan informasi tentang istilah yang sering digunakan. Anda dapat melakukan pencarian hibrida dengan menggunakan vektor jarang dan padat untuk meningkatkan kinerja pengambilan. Layanan Vektorisasi Teks Jarang OpenSearch-generik (ops-text-sparse-embedding-001): menyediakan layanan penyematan teks yang mendukung lebih dari 100 bahasa. Panjang maksimum teks input bisa mencapai 8.192 token.

Setelah memilih layanan, klik After the configuration is completed, enter the code query untuk melihat dan mengunduh kode berdasarkan alur eksekusi ketika aplikasi memanggil solusi pemrosesan data.

Di tab Code Query, klik Text Parsing and Vectorization. Di editor kode, klik Copy Code atau Download File untuk mengunduh kode ke perangkat Anda.

Langkah 2: Uji kode di lingkungan lokal

Setelah mengunduh file kode ke perangkat Anda, tentukan parameter dalam kode. Tabel berikut menjelaskan parameter tersebut.

Setelah menyelesaikan konfigurasi parameter, jalankan kode di Python 3.8.1 atau versi lebih tinggi untuk menguji apakah hasilnya benar.

Jika Anda memproses data AI Search Open Platform di kode, hasil yang dijalankan adalah sebagai berikut.

Penguraian dokumen dan penyematan file:

# Solusi pemrosesan data multimodal

# Persyaratan lingkungan berikut terpenuhi:
# Versi Python 3.7 atau lebih baru telah diinstal.


# Dependensi berikut diinstal:
# pip install alibabacloud_searchplat20240529


# Konfigurasi AI Search Open Platform
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"}

# Tentukan URL dokumen. Dalam contoh ini, dokumen deskripsi produk OpenSearch digunakan.
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):

    # Generate an AI Search Open Platform client.
    config = Config(bearer_token=api_key,endpoint=aisearch_endpoint,protocol="http")
    ops_client = Client(config=config)

    # Step 1: Parse the document or image.
    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

    # Step 2: Split the document.
    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)))

    # Step 3: Perform text vectorization.
    # Extract the splitting results. Image splitting uses the image parsing service to extract text.
    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"]
                )
    chunk_size = 32  # A maximum of 32 vectors can be generated at a time.
    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__":
    # Run the asynchronous task.
    #    import nest_asyncio # If you run the code in Jupyter Notebook, uncomment this line of code.
    #    nest_asyncio.apply() # If you run the code in Jupyter Notebook, uncomment this line of code.
    asyncio.run(document_pipeline_execute(document_url))
    # asyncio.run(document_pipeline_execute(document_base64="eHh4eHh4eHg...", file_name="attention.pdf")) # You can also use a Base64-encoded file to specify the document to be processed.