របៀបសន្សំ $70K បង្កើត Knowledge Graph សម្រាប់ RAG នៅលើទំព័រ Wikipedia 6M

ការប្រើប្រាស់ក្រាហ្វចំណេះដឹងដើម្បីកែលម្អលទ្ធផលនៃកម្មវិធី retrieval-augmented generation (RAG) បានក្លាយជាប្រធានបទក្តៅ។ ឧទាហរណ៍ភាគច្រើនបង្ហាញពីរបៀបបង្កើតក្រាហ្វចំណេះដឹងដោយប្រើឯកសារមួយចំនួនតូច។ នេះប្រហែលជាដោយសារតែវិធីសាស្រ្តធម្មតា – ទាញយកព័ត៌មានដែលមានលក្ខណៈល្អិតល្អន់ អង្គភាពជាចំណុចកណ្តាល – គ្រាន់តែមិនធ្វើមាត្រដ្ឋាន។ ការដំណើរការឯកសារនីមួយៗតាមរយៈគំរូមួយដើម្បីទាញយកអង្គភាព (ថ្នាំង) និងទំនាក់ទំនង (គែម) ចំណាយពេលយូរពេក (និងចំណាយច្រើន) ដើម្បីដំណើរការលើសំណុំទិន្នន័យធំ។

យើង​បាន​ប្រកែក​អ៊ីចឹង ក្រាហ្វចំណេះដឹងដែលផ្តោតលើខ្លឹមសារ - ហាងវ៉ិចទ័រដែលអនុញ្ញាតឱ្យមានតំណភ្ជាប់រវាងកំណាត់ - គឺជាវិធីសាស្រ្តងាយស្រួលប្រើ និងមានប្រសិទ្ធភាពជាង។ នៅទីនេះយើងដាក់ឱ្យសាកល្បង។ យើងផ្ទុកសំណុំរងនៃអត្ថបទវិគីភីឌាពី 2 វិគីមេលធីហប សំណុំទិន្នន័យដោយប្រើបច្ចេកទេសទាំងពីរ ហើយពិភាក្សាអំពីអត្ថន័យនៃការផ្ទុកសំណុំទិន្នន័យទាំងមូល។ យើងបង្ហាញលទ្ធផលនៃសំណួរមួយចំនួនលើទិន្នន័យដែលបានផ្ទុក។ យើងក៏នឹងផ្ទុកសំណុំទិន្នន័យទាំងមូល - ជិត 6 លានឯកសារ - ទៅក្នុងមាតិកាដែលផ្តោតសំខាន់ GraphVectorStore .

អង្គភាពផ្តោត៖ LLMGraphTransformer

ការផ្ទុកឯកសារទៅក្នុងហាងក្រាហ្វដែលផ្តោតលើអង្គភាពដូចជា Neo4j ត្រូវបានធ្វើឡើងដោយប្រើ LLMGraphTransformer របស់ LangChain ។ កូដគឺផ្អែកលើ LangChain's "របៀបបង្កើតក្រាហ្វចំណេះដឹង។"

 from langchain_core.documents import Document from langchain_experimental.graph_transformers import LLMGraphTransformer from langchain_openai import ChatOpenAI llm = ChatOpenAI(temperature=0, model_name="gpt-4-turbo") llm_transformer = LLMGraphTransformer(llm=llm) from time import perf_counter start = perf_counter() documents_to_load = [Document(page_content=line) for line in lines_to_load] graph_documents = llm_transformer.convert_to_graph_documents(documents_to_load) end = perf_counter() print(f"Loaded (but NOT written) {NUM_LINES_TO_LOAD} in {end - start:0.2f}s")

មាតិកាផ្តោតសំខាន់៖ GraphVectorStore

ការផ្ទុកទិន្នន័យទៅក្នុង GraphVectorStore គឺប្រហាក់ប្រហែលនឹងការផ្ទុកវាទៅក្នុងហាងវ៉ិចទ័រ។ ការបន្ថែមតែមួយគត់គឺថាយើងគណនាទិន្នន័យមេតាដែលបង្ហាញពីរបៀបដែលទំព័រនីមួយៗភ្ជាប់ទៅទំព័រផ្សេងទៀត។

 import json from langchain_core.graph_vectorstores.links import METADATA_LINKS_KEY, Link def parse_document(line: str) -> Document:    para = json.loads(line)    id = para["id"]    links = {        Link.outgoing(kind="href", tag=id)        for m in para["mentions"]        if m["ref_ids"] is not None        for id in m["ref_ids"]    }    links.add(Link.incoming(kind="href", tag=id))    return Document(        id = id,        page_content = " ".join(para["sentences"]),        metadata = {            "content_id": para["id"],            METADATA_LINKS_KEY: list(links)        },    )

នេះក៏ជាឧទាហរណ៍ដ៏ល្អមួយអំពីរបៀបដែលអ្នកអាចបន្ថែមតំណភ្ជាប់ផ្ទាល់ខ្លួនរបស់អ្នករវាងថ្នាំង។

 from langchain_openai import OpenAIEmbeddings from langchain_community.graph_vectorstores.cassandra import CassandraGraphVectorStore import cassio cassio.init(auto=True) TABLE_NAME = "wiki_load" store = CassandraGraphVectorStore( embedding = OpenAIEmbeddings(), node_table=TABLE_NAME, insert_timeout = 1000.0, ) from time import perf_counter start = perf_counter() from datasets.wikimultihop.load import parse_document kg_documents = [parse_document(line) for line in lines_to_load] store.add_documents(kg_documents) end = perf_counter() print(f"Loaded (and written) {NUM_LINES_TO_LOAD} in {end - start:0.2f}s")

កំពុង​ផ្ទុក​តារាង​ពិន្ទុ

ដំណើរការនៅ 100 ជួរ វិធីសាស្រ្តផ្តោតលើអង្គភាពដោយប្រើ GPT-4o បានយក 405.93s ដើម្បីទាញយក GraphDocuments និង 10.99s ដើម្បីសរសេរពួកវាទៅ Neo4j ខណៈពេលដែលវិធីសាស្រ្តផ្តោតលើខ្លឹមសារបានយក 1.43s ។ Extrapolating វានឹងចំណាយពេល 41 សប្តាហ៍ដើម្បីផ្ទុកទំព័រ 5,989,847 ទាំងអស់ ដោយប្រើវិធីសាស្រ្តផ្តោតលើអង្គភាព និងប្រហែល 24 ម៉ោងដោយប្រើវិធីសាស្រ្តផ្តោតលើខ្លឹមសារ។ ប៉ុន្តែដោយសារភាពស្របគ្នា វិធីសាស្រ្តផ្តោតលើខ្លឹមសារដំណើរការត្រឹមតែ 2.5 ម៉ោងប៉ុណ្ណោះ! ដោយសន្មតថាមានអត្ថប្រយោជន៍ដូចគ្នានេះ វានៅតែត្រូវចំណាយពេលលើសពី 4 សប្តាហ៍ដើម្បីផ្ទុកអ្វីគ្រប់យ៉ាងដោយប្រើវិធីសាស្រ្តដែលផ្តោតលើអង្គភាព។ ខ្ញុំមិនបានសាកល្បងវាទេ ចាប់តាំងពីតម្លៃប៉ាន់ស្មាននឹងមានចំនួន $58,700 — សន្មត់ថាអ្វីៗដំណើរការជាលើកដំបូង!

បន្ទាត់ខាងក្រោម៖ វិធីសាស្រ្តផ្តោតលើអង្គភាពកណ្តាលនៃការទាញយកក្រាហ្វចំណេះដឹងពីខ្លឹមសារដោយប្រើប្រាស់ LLM គឺទាំងពេលវេលា និងតម្លៃហាមឃាត់ក្នុងទំហំ។ ម្យ៉ាងវិញទៀត ការប្រើប្រាស់ GraphVectorStore មានល្បឿនលឿន និងមានតម្លៃថោក។

ចម្លើយឧទាហរណ៍

នៅក្នុងផ្នែកនេះ សំណួរមួយចំនួនដែលត្រូវបានដកចេញពីសំណុំរងនៃឯកសារដែលបានផ្ទុក ត្រូវបានសួរដើម្បីដោះស្រាយគុណភាពនៃចម្លើយ។

Entity-centric បានប្រើ 7324 prompt tokens ហើយចំណាយ $0.03 ដើម្បីបង្កើតចម្លើយដែលគ្មានប្រយោជន៍ជាមូលដ្ឋាន ខណៈពេលដែល content-centric បានប្រើ 450 prompt tokens និងចំណាយអស់ $0.002 ដើម្បីបង្កើតចំលើយសង្ខេបដែលឆ្លើយសំណួរដោយផ្ទាល់។

វាអាចជារឿងគួរឱ្យភ្ញាក់ផ្អើលដែលក្រាហ្វ Neo4j ដែលមានគ្រាប់ល្អ ផ្តល់ចម្លើយដែលគ្មានប្រយោជន៍។ ក្រឡេកទៅមើលការកាប់ឈើពីខ្សែសង្វាក់ យើងឃើញមូលហេតុខ្លះដែលវាកើតឡើង៖

 > Entering new GraphCypherQAChain chain... Generated Cypher: cypher MATCH (a:Album {id: 'The Circle'})-[:RELEASED_BY]->(r:Record_label) RETURN a.id, r.id Full Context: [{'a.id': 'The Circle', 'r.id': 'Restless'}] > Finished chain. {'query': "When was 'The Circle' released?", 'result': "I don't know the answer."}

ដូច្នេះ គ្រោងការណ៍ដែលល្អិតល្អន់បានត្រឡប់តែព័ត៌មានអំពីស្លាកកំណត់ត្រាប៉ុណ្ណោះ។ វាសមហេតុផលដែល LLM មិនអាចឆ្លើយសំណួរដោយផ្អែកលើព័ត៌មានដែលបានទាញយក។

សេចក្តីសន្និដ្ឋាន

ការស្រង់ចេញក្រាហ្វនៃចំណេះដឹងជាក់លាក់របស់អង្គភាពដែលមានលក្ខណៈល្អិតល្អន់ គឺជាពេលវេលា និងទប់ស្កាត់ការចំណាយតាមខ្នាត។ នៅពេលសួរសំណួរអំពីសំណុំរងនៃទិន្នន័យដែលត្រូវបានផ្ទុក លក្ខណៈលម្អិតបន្ថែម (និងការចំណាយបន្ថែមនៃការផ្ទុកក្រាហ្វដែលមានលក្ខណៈល្អិតល្អន់) បានត្រឡប់មកវិញនូវសញ្ញាសម្ងាត់បន្ថែមទៀតដើម្បីរួមបញ្ចូលការបញ្ចូលភ្លាមៗ ប៉ុន្តែបានបង្កើតចម្លើយដែលគ្មានប្រយោជន៍!

GraphVectorStore ប្រើវិធីសាស្រ្តផ្តោតសំខាន់លើខ្លឹមសារ ដែលធ្វើឱ្យវាលឿន និងងាយស្រួលក្នុងការបង្កើតក្រាហ្វចំណេះដឹង។ អ្នកអាចចាប់ផ្តើមជាមួយនឹងកូដដែលមានស្រាប់របស់អ្នកសម្រាប់ការបញ្ចូល VectorStore ដោយប្រើ LangChain ហើយបន្ថែមតំណភ្ជាប់ (គែម) រវាងកំណាត់ដើម្បីកែលម្អដំណើរការទាញយក។

Graph RAG គឺជាឧបករណ៍ដ៏មានប្រយោជន៍សម្រាប់ការបើកកម្មវិធី AI RAG ជំនាន់ដើម ដើម្បីទាញយកបរិបទដែលពាក់ព័ន្ធកាន់តែស៊ីជម្រៅ។ ប៉ុន្តែការប្រើវិធីសាស្រ្តដែលផ្តោតលើផ្នែកល្អិតល្អន់មិនមានទំហំទៅតាមតម្រូវការផលិតកម្មនោះទេ។ ប្រសិនបើអ្នកកំពុងស្វែងរកបន្ថែមសមត្ថភាពក្រាហ្វចំណេះដឹងទៅកម្មវិធី RAG របស់អ្នក សូមសាកល្បង GraphVectorStore .

ដោយ Ben Chambers , DataStax