Bagikan melalui

Tutorial: Membangun solusi generasi yang ditingkatkan dengan pengambilan

Tutorial ini menjelaskan cara membuat solusi retrieval-augmented generation (RAG) menggunakan Azure Content Understanding di Foundry Tools. Ini mencakup langkah-langkah utama untuk membangun sistem RAG yang kuat, menawarkan tips untuk meningkatkan relevansi dan akurasi, dan menunjukkan cara terhubung dengan layanan Azure lainnya. Pada akhirnya, Anda dapat menggunakan Content Understanding untuk menangani data multimodal, meningkatkan pengambilan, dan membantu model AI memberikan respons yang akurat dan bermakna.

Latihan yang disertakan dalam tutorial ini

Prasyarat

Untuk memulai, Anda memerlukan langganan Azure aktif. Jika Anda tidak memiliki akun Azure, Anda dapat membuat langganan gratis.

  • Setelah Anda memiliki langganan Azure, buat sumber daya Microsoft Foundry di portal Microsoft Azure.

    • Sumber daya ini tercantum di bawah Foundry>Foundry di portal.

      Cuplikan layar halaman sumber daya multi-layanan di portal Azure.

  • Sumber Daya Pencarian Azure AI: Siapkan sumber daya Azure AI Search untuk mengaktifkan pengindeksan dan pengambilan data multimodal.

  • Penyebaran Model Obrolan Azure OpenAI: Menyebarkan model obrolan Azure OpenAI yang memungkinkan interaksi percakapan.

  • Penyebaran Model Penyematan: Pastikan Anda memiliki model penyematan yang disebarkan untuk menghasilkan representasi vektor untuk pencarian semantik.

  • Versi API: Tutorial ini menggunakan versi API pratinjau terbaru.

  • Lingkungan Python: Instal Python 3.11 untuk menjalankan sampel kode dan skrip yang disediakan.

  • Tutorial ini mengikuti kode sampel ini dapat ditemukan di notebook Python kami. Ikuti README untuk membuat sumber daya penting, memberikan sumber daya peran Kontrol akses (IAM) yang tepat dan menginstal semua paket yang diperlukan untuk tutorial ini.

  • Data multimodal yang digunakan dalam tutorial ini terdiri dari dokumen, gambar, audio, dan video. Mereka dirancang untuk memandu Anda melalui proses membangun solusi RAG yang kuat dengan Azure Content Understanding di Foundry Tools.

Ekstrak data

Retrieval-augmented generation (RAG*) adalah metode yang meningkatkan fungsionalitas Model Bahasa Besar (LLM) dengan mengintegrasikan data dari sumber pengetahuan eksternal. Membangun solusi RAG multimodal yang kuat dimulai dengan mengekstrak dan menyusun data dari berbagai jenis konten. Azure Content Understanding menyediakan tiga komponen utama untuk memfasilitasi proses ini: ekstraksi konten, ekstraksi bidang, dan penganalisis. Bersama-sama, komponen-komponen ini membentuk fondasi untuk membuat alur data terpadu, dapat digunakan kembali, dan ditingkatkan untuk alur kerja RAG.

Langkah penerapan

Untuk menerapkan ekstraksi data dalam Pemahaman Konten, ikuti langkah-langkah berikut:

  1. Membuat Analyzer: Tentukan penganalisis menggunakan REST API atau sampel kode Python kami.

  2. Lakukan Ekstraksi Konten: Gunakan penganalisis untuk memproses file dan mengekstrak konten terstruktur.

  3. (Opsional) Tingkatkan dengan Ekstraksi Bidang: Secara opsional, tentukan bidang yang dihasilkan AI untuk memperkaya konten yang diekstrak dengan metadata tambahan.

Membuat penganalisis

Penganalisis adalah komponen yang dapat digunakan kembali dalam Pemahaman Konten yang menyederhanakan proses ekstraksi data. Setelah penganalisis dibuat, penganalisis dapat digunakan berulang kali untuk memproses file dan mengekstrak konten atau bidang berdasarkan skema yang telah ditentukan sebelumnya. Penganalisis bertindak sebagai cetak biru tentang bagaimana data harus diproses, memastikan konsistensi dan efisiensi di beberapa file dan jenis konten.

Sampel kode berikut menunjukkan cara membuat penganalisis untuk setiap modalitas, menentukan data terstruktur yang akan diekstrak, seperti bidang kunci, ringkasan, atau klasifikasi. Penganalisis ini berfungsi sebagai fondasi untuk mengekstrak dan memperkaya konten dalam solusi RAG Anda.

Memuat semua variabel lingkungan dan pustaka yang diperlukan dari Langchain


import os
from dotenv import load_dotenv
load_dotenv()

# Load and validate Foundry Tools configs
AZURE_AI_SERVICE_ENDPOINT = os.getenv("AZURE_AI_SERVICE_ENDPOINT")
AZURE_AI_SERVICE_API_VERSION = os.getenv("AZURE_AI_SERVICE_API_VERSION") or "2024-12-01-preview"
AZURE_DOCUMENT_INTELLIGENCE_API_VERSION = os.getenv("AZURE_DOCUMENT_INTELLIGENCE_API_VERSION") or "2024-11-30"

# Load and validate Azure OpenAI configs
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
AZURE_OPENAI_CHAT_DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_CHAT_DEPLOYMENT_NAME")
AZURE_OPENAI_CHAT_API_VERSION = os.getenv("AZURE_OPENAI_CHAT_API_VERSION") or "2024-08-01-preview"
AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME")
AZURE_OPENAI_EMBEDDING_API_VERSION = os.getenv("AZURE_OPENAI_EMBEDDING_API_VERSION") or "2023-05-15"

# Load and validate Azure Search Services configs
AZURE_SEARCH_ENDPOINT = os.getenv("AZURE_SEARCH_ENDPOINT")
AZURE_SEARCH_INDEX_NAME = os.getenv("AZURE_SEARCH_INDEX_NAME") or "sample-doc-index"

# Import libraries from Langchain
from langchain import hub
from langchain_openai import AzureChatOpenAI
from langchain_openai import AzureOpenAIEmbeddings
from langchain.schema import StrOutputParser
from langchain.schema.runnable import RunnablePassthrough
from langchain.text_splitter import MarkdownHeaderTextSplitter
from langchain.vectorstores.azuresearch import AzureSearch
from langchain_core.prompts import ChatPromptTemplate
from langchain.schema import Document
import requests
import json
import sys
import uuid
from pathlib import Path
from dotenv import find_dotenv, load_dotenv
from azure.identity import DefaultAzureCredential, get_bearer_token_provider

# Add the parent directory to the path to use shared modules
parent_dir = Path(Path.cwd()).parent
sys.path.append(str(parent_dir))

Sampel kode: membuat penganalisis

from pathlib import Path
from python.content_understanding_client import AzureContentUnderstandingClient
credential = DefaultAzureCredential()
token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")

#set analyzer configs
analyzer_configs = [
    {
        "id": "doc-analyzer" + str(uuid.uuid4()),
        "template_path": "../analyzer_templates/content_document.json",
        "location": Path("../data/sample_layout.pdf"),
    },
    {
        "id": "image-analyzer" + str(uuid.uuid4()),
        "template_path": "../analyzer_templates/image_chart_diagram_understanding.json",
        "location": Path("../data/sample_report.pdf"),
    },
    {
        "id": "audio-analyzer" + str(uuid.uuid4()),
        "template_path": "../analyzer_templates/call_recording_analytics.json",
        "location": Path("../data/callCenterRecording.mp3"),
    },
    {
        "id": "video-analyzer" + str(uuid.uuid4()),
        "template_path": "../analyzer_templates/video_content_understanding.json",
        "location": Path("../data/FlightSimulator.mp4"),
    },
]

# Create Content Understanding client
content_understanding_client = AzureContentUnderstandingClient(
    endpoint=AZURE_AI_SERVICE_ENDPOINT,
    api_version=AZURE_AI_SERVICE_API_VERSION,
    token_provider=token_provider,
    x_ms_useragent="azure-ai-content-understanding-python/content_extraction", # This header is used for sample usage telemetry, please comment out this line if you want to opt out.
)

# Iterate through each config and create an analyzer
for analyzer in analyzer_configs:
    analyzer_id = analyzer["id"]
    template_path = analyzer["template_path"]

    try:

        # Create the analyzer using the content understanding client
        response = content_understanding_client.begin_create_analyzer(
            analyzer_id=analyzer_id,
            analyzer_template_path=template_path
        )
        result = content_understanding_client.poll_result(response)
        print(f"Successfully created analyzer: {analyzer_id}")

    except Exception as e:
        print(f"Failed to create analyzer: {analyzer_id}")
        print(f"Error: {e}")

Nota: Skema ekstraksi bidang bersifat opsional dan tidak diperlukan untuk melakukan ekstraksi konten. Untuk menjalankan ekstraksi konten dan membuat penganalisis tanpa menentukan skema bidang, cukup berikan ID penganalisis dan file yang akan dianalisis.

Skema digunakan dalam tutorial ini. Berikut adalah contoh definisi skema

Dalam contoh berikut, kami menentukan skema untuk mengekstrak informasi dasar dari dokumen faktur.

{
  "description": "Sample invoice analyzer",
  "scenario": "document",
  "config": {
    "returnDetails": true
  },
  "fieldSchema": {
    "fields": {
      "VendorName": {
        "type": "string",
        "method": "extract",
        "description": "Vendor issuing the invoice"
      },
      "Items": {
        "type": "array",
        "method": "extract",
        "items": {
          "type": "object",
          "properties": {
            "Description": {
              "type": "string",
              "method": "extract",
              "description": "Description of the item"
            },
            "Amount": {
              "type": "number",
              "method": "extract",
              "description": "Amount of the item"
            }
          }
        }
      }
    }
  }
}

Ekstraksi isi dan bidang

Ekstraksi konten adalah langkah pertama dalam proses implementasi RAG. Ini mengubah data multimodal mentah menjadi format terstruktur dan dapat dicari. Langkah dasar ini memastikan bahwa konten diatur dan siap untuk pengindeksan dan pengambilan. Meskipun ekstraksi konten menyediakan garis besar untuk pengindeksan dan pengambilan, mungkin tidak sepenuhnya memenuhi kebutuhan khusus domain atau memberikan wawasan kontekstual yang lebih dalam. Pelajari selengkapnya tentang kemampuan ekstraksi konten untuk setiap modalitas.

Ekstraksi bidang dibangun pada ekstraksi konten dengan menggunakan AI untuk menghasilkan metadata lebih lanjut yang memperkaya pangkalan pengetahuan. Langkah ini memungkinkan Anda menentukan bidang kustom yang disesuaikan dengan kasus penggunaan spesifik Anda, memungkinkan pengambilan yang lebih tepat dan relevansi pencarian yang ditingkatkan. Ekstraksi bidang melengkapi ekstraksi konten dengan menambahkan kedalaman dan konteks, membuat data lebih dapat ditindaklanjuti untuk skenario RAG. Pelajari selengkapnya tentang kemampuan ekstraksi bidang untuk setiap modalitas.

Dengan penganalisis yang dibuat untuk setiap modalitas, kita sekarang dapat memproses file untuk mengekstrak konten terstruktur dan metadata yang dihasilkan AI berdasarkan skema yang ditentukan. Bagian ini menunjukkan cara menggunakan penganalisis untuk menganalisis data multimodal dan menyediakan sampel hasil yang dikembalikan oleh API. Hasil ini menunjukkan transformasi data mentah menjadi wawasan yang dapat ditindaklanjuti, membentuk fondasi untuk mengindeks, mengambil, dan alur kerja RAG.

Menganalisis file


#Iterate through each analyzer created and analyze content for each modality

analyzer_results =[]
extracted_markdown = []
analyzer_content = []
for analyzer in analyzer_configs:
    analyzer_id = analyzer["id"]
    template_path = analyzer["template_path"]
    file_location = analyzer["location"]
    try:
           # Analyze content
            response = content_understanding_client.begin_analyze(analyzer_id, file_location)
            result = content_understanding_client.poll_result(response)
            analyzer_results.append({"id":analyzer_id, "result": result["result"]})
            analyzer_content.append({"id": analyzer_id, "content": result["result"]["contents"]})

    except Exception as e:
            print(e)
            print("Error in creating analyzer. Please double-check your analysis settings.\nIf there is a conflict, you can delete the analyzer and then recreate it, or move to the next cell and use the existing analyzer.")

print("Analyzer Results:")
for analyzer_result in analyzer_results:
    print(f"Analyzer ID: {analyzer_result['id']}")
    print(json.dumps(analyzer_result["result"], indent=2))

# Delete the analyzer if it is no longer needed
#content_understanding_client.delete_analyzer(ANALYZER_ID)

Hasil Ekstraksi

Sampel kode berikut menunjukkan output konten dan ekstraksi bidang menggunakan Azure Content Understanding. Respons JSON berisi beberapa bidang, masing-masing melayani tujuan tertentu dalam mewakili data yang diekstrak.

  • Bidang Markdown: Bidang markdown menyediakan representasi konten yang disederhanakan dan mudah dibaca oleh manusia. Ini sangat berguna untuk pratinjau cepat atau untuk mengintegrasikan data yang diekstrak ke dalam aplikasi yang memerlukan teks terstruktur, seperti pangkalan pengetahuan atau antarmuka pencarian. Misalnya, dengan dokumen, markdown bidang mungkin menyertakan header, paragraf, dan elemen struktural lainnya yang diformat agar mudah dibaca.

  • Output JSON: Output JSON lengkap menyediakan representasi komprehensif dari data yang diekstrak, termasuk konten dan metadata yang dihasilkan selama proses ekstraksi termasuk properti berikut:

    • Bidang: Metadata yang dihasilkan AI seperti ringkasan, topik utama, atau klasifikasi, disesuaikan dengan skema tertentu yang ditentukan dalam penganalisis.
    • Skor Keyakinan: Indikator keandalan data yang diekstrak.
    • Rentang: Informasi tentang lokasi konten yang diekstrak dalam file sumber.
    • Metadata Tambahan: Detail seperti nomor halaman, dimensi, dan informasi kontekstual lainnya.

Hasilnya menunjukkan ekstraksi header, paragraf, tabel, dan elemen struktural lainnya sambil mempertahankan organisasi logis konten. Selain itu, ia menunjukkan kemampuan untuk mengekstrak elemen kunci, menyediakan ekstraksi ringkas dari materi yang panjang.

{
  "id": "bcf8c7c7-03ab-4204-b22c-2b34203ef5db",
  "status": "Succeeded",
  "result": {
    "analyzerId": "training_document_analyzer",
    "apiVersion": "2024-12-01-preview",
    "createdAt": "2024-11-13T07:15:46Z",
    "warnings": [],
    "contents": [
      {
        "markdown": "CONTOSO LTD.\n\n\n# Contoso Training Topics\n\nContoso Headquarters...",
        "fields": {
          "ChapterTitle": {
            "type": "string",
            "valueString": "Risks and Compliance regulations",
            "spans": [ { "offset": 0, "length": 12 } ],
            "confidence": 0.941,
            "source": "D(1,0.5729,0.6582,2.3353,0.6582,2.3353,0.8957,0.5729,0.8957)"
          },
          "ChapterAuthor": {
            "type": "string",
            "valueString": "John Smith",
            "spans": [ { "offset": 0, "length": 12 } ],
            "confidence": 0.941,
            "source": "D(1,0.5729,0.6582,2.3353,0.6582,2.3353,0.8957,0.5729,0.8957)"
          },
          "ChapterPublishDate": {
            "type": "Date",
            "valueString": "04-11-2017",
            "spans": [ { "offset": 0, "length": 12 } ],
            "confidence": 0.941,
            "source": "D(1,0.5729,0.6582,2.3353,0.6582,2.3353,0.8957,0.5729,0.8957)"
          },
        },
        "kind": "document",
        "startPageNumber": 1,
        "endPageNumber": 1,
        "unit": "inch",
        "pages": [
          {
            "pageNumber": 1,
            "angle": -0.0039,
            "width": 8.5,
            "height": 11,
            "spans": [ { "offset": 0, "length": 1650 } ],
            "words": [
              {
               ....
              },
            ],
            "lines": [
              {
                ...
              },
            ]
          }
        ],

      }
    ]
  }
}

Hasil pra-pemrosesan dari Pemahaman Konten

Setelah data diekstrak menggunakan Azure Content Understanding, langkah selanjutnya adalah menyiapkan output analisis untuk penyematan dalam sistem pencarian. Pra-pemrosesan output memastikan bahwa konten yang diekstrak diubah menjadi format yang cocok untuk pengindeksan dan pengambilan. Langkah ini melibatkan konversi output JSON dari penganalisis menjadi string terstruktur, mempertahankan konten dan metadata untuk integrasi yang mulus ke dalam alur kerja hilir.

Contoh berikut menunjukkan cara melakukan praproses data output dari penganalisis, termasuk dokumen, gambar, audio, dan video. Proses konversi setiap output JSON menjadi string terstruktur meletakkan dasar untuk menyematkan data menjadi sistem pencarian berbasis vektor, memungkinkan pengambilan yang efisien dan alur kerja RAG yang ditingkatkan.


def convert_values_to_strings(json_obj):
    return [str(value) for value in json_obj]

#process all content and convert to string
def process_allJSON_content(all_content):

    # Initialize empty list to store string of all content
    output = []

    document_splits = [
        "This is a json string representing a document with text and metadata for the file located in "+str(analyzer_configs[0]["location"])+" "
        + v
        + "```"
        for v in convert_values_to_strings(all_content[0]["content"])
    ]
    docs = [Document(page_content=v) for v in document_splits]
    output += docs

    #convert image json object to string and append file metadata to the string
    image_splits = [
       "This is a json string representing an image verbalization and OCR extraction for the file located in "+str(analyzer_configs[1]["location"])+" "
       + v
       + "```"
       for v in convert_values_to_strings(all_content[1]["content"])
    ]
    image = [Document(page_content=v) for v in image_splits]
    output+=image

    #convert audio json object to string and append file metadata to the string
    audio_splits = [
        "This is a json string representing an audio segment with transcription for the file located in "+str(analyzer_configs[2]["location"])+" "
       + v
       + "```"
       for v in convert_values_to_strings(all_content[2]["content"])
    ]
    audio = [Document(page_content=v) for v in audio_splits]
    output += audio

    #convert video json object to string and append file metadata to the string
    video_splits = [
        "The following is a json string representing a video segment with scene description and transcript for the file located in "+str(analyzer_configs[3]["location"])+" "
        + v
        + "```"
        for v in convert_values_to_strings(all_content[3]["content"])
    ]
    video = [Document(page_content=v) for v in video_splits]
    output+=video

    return output

all_splits = process_allJSON_content(analyzer_content)

print("There are " + str(len(all_splits)) + " documents.")
# Print the content of all doc splits
for doc in all_splits:
    print(f"doc content", doc.page_content)

Menyematkan dan mengindeks konten yang diekstrak

Setelah praproses data yang diekstrak dari Azure Content Understanding selesai, langkah selanjutnya adalah menyematkan dan mengindeks konten untuk pengambilan yang efisien. Langkah ini melibatkan transformasi string terstruktur menjadi penyematan vektor menggunakan model penyematan dan menyimpannya dalam sistem Azure AI Search. Dengan menyematkan konten, Anda mengaktifkan kemampuan pencarian semantik, memungkinkan sistem untuk mengambil informasi yang paling relevan berdasarkan arti daripada kecocokan kata kunci yang tepat. Langkah ini sangat penting untuk membangun solusi RAG yang kuat, karena memastikan bahwa konten yang diekstrak dioptimalkan untuk alur kerja pencarian dan pengambilan tingkat lanjut.

# Embed the splitted documents and insert into Azure Search vector store
def embed_and_index_chunks(docs):
    aoai_embeddings = AzureOpenAIEmbeddings(
        azure_deployment=AZURE_OPENAI_EMBEDDING_DEPLOYMENT_NAME,
        openai_api_version=AZURE_OPENAI_EMBEDDING_API_VERSION,  # e.g., "2023-12-01-preview"
        azure_endpoint=AZURE_OPENAI_ENDPOINT,
        azure_ad_token_provider=token_provider
    )

    vector_store: AzureSearch = AzureSearch(
        azure_search_endpoint=AZURE_SEARCH_ENDPOINT,
        azure_search_key=None,
        index_name=AZURE_SEARCH_INDEX_NAME,
        embedding_function=aoai_embeddings.embed_query
    )
    vector_store.add_documents(documents=docs)
    return vector_store


# embed and index the docs:
vector_store = embed_and_index_chunks(all_splits)

Pengambilan gugus semantik

Dengan konten yang diekstrak yang disematkan dan diindeks, langkah selanjutnya adalah menggunakan kekuatan kesamaan dan pencarian vektor untuk mengambil potongan informasi yang paling relevan. Bagian ini menunjukkan cara menjalankan kesamaan dan pencarian hibrid, memungkinkan sistem untuk menampilkan konten berdasarkan arti semantik daripada kecocokan kata kunci yang tepat. Dengan mengambil potongan yang relevan secara kontekstual, Anda dapat meningkatkan presisi alur kerja RAG Anda dan memberikan respons yang lebih akurat dan bermakna terhadap kueri pengguna.

# Set your query
query = "japan"

# Perform a similarity search
docs = vector_store.similarity_search(
    query=query,
    k=3,
    search_type="similarity",
)
for doc in docs:
    print(doc.page_content)

# Perform a hybrid search using the search_type parameter
docs = vector_store.hybrid_search(query=query, k=3)
for doc in docs:
    print(doc.page_content)

Menggunakan OpenAI untuk berinteraksi dengan data

Dengan konten yang diekstrak yang disematkan dan diindeks, langkah terakhir dalam membangun solusi RAG yang kuat adalah mengaktifkan interaksi percakapan menggunakan model obrolan OpenAI. Bagian ini menunjukkan cara mengkueri data terindeks Anda dan menerapkan model obrolan OpenAI untuk memberikan jawaban yang ringkas dan kaya secara kontekstual. Dengan mengintegrasikan AI percakapan, Anda dapat mengubah solusi RAG Anda menjadi sistem interaktif yang memberikan wawasan yang bermakna dan meningkatkan keterlibatan pengguna. Contoh berikut memandu Anda menyiapkan alur percakapan yang didukung dengan peningkatan pengambilan, memastikan integrasi yang mulus antara data Anda dan model percakapan OpenAI.

# Setup rag chain
prompt_str = """You are an assistant for question-answering tasks. Use the following pieces of retrieved context to answer the question. If you don't know the answer, just say that you don't know. Use three sentences maximum and keep the answer concise.
Question: {question}
Context: {context}
Answer:"""


def setup_rag_chain(vector_store):
    retriever = vector_store.as_retriever(search_type="similarity", k=3)

    prompt = ChatPromptTemplate.from_template(prompt_str)
    llm = AzureChatOpenAI(
        openai_api_version=AZURE_OPENAI_CHAT_API_VERSION,
        azure_deployment=AZURE_OPENAI_CHAT_DEPLOYMENT_NAME,
        azure_ad_token_provider=token_provider,
        temperature=0.7,
    )

    def format_docs(docs):
        return "\n\n".join(doc.page_content for doc in docs)

    rag_chain = (
        {"context": retriever | format_docs, "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
    )
    return rag_chain


# Setup conversational search
def conversational_search(rag_chain, query):
    print(rag_chain.invoke(query))


rag_chain = setup_rag_chain(vector_store)
while True:
    query = input("Enter your query: ")
    if query=="":
        break
    conversational_search(rag_chain, query)

Langkah selanjutnya

  • Last updated on