ការប្រើប្រាស់ក្រាហ្វចំណេះដឹងដើម្បីកែលម្អលទ្ធផលនៃកម្មវិធី retrieval-augmented generation (RAG) បានក្លាយជាប្រធានបទក្តៅ។ ឧទាហរណ៍ភាគច្រើនបង្ហាញពីរបៀបបង្កើតក្រាហ្វចំណេះដឹងដោយប្រើឯកសារមួយចំនួនតូច។ នេះប្រហែលជាដោយសារតែវិធីសាស្រ្តធម្មតា – ទាញយកព័ត៌មានដែលមានលក្ខណៈល្អិតល្អន់ អង្គភាពជាចំណុចកណ្តាល – គ្រាន់តែមិនធ្វើមាត្រដ្ឋាន។ ការដំណើរការឯកសារនីមួយៗតាមរយៈគំរូមួយដើម្បីទាញយកអង្គភាព (ថ្នាំង) និងទំនាក់ទំនង (គែម) ចំណាយពេលយូរពេក (និងចំណាយច្រើន) ដើម្បីដំណើរការលើសំណុំទិន្នន័យធំ។  យើង​បាន​ប្រកែក​អ៊ីចឹង  - ហាងវ៉ិចទ័រដែលអនុញ្ញាតឱ្យមានតំណភ្ជាប់រវាងកំណាត់ - គឺជាវិធីសាស្រ្តងាយស្រួលប្រើ និងមានប្រសិទ្ធភាពជាង។ នៅទីនេះយើងដាក់ឱ្យសាកល្បង។ យើងផ្ទុកសំណុំរងនៃអត្ថបទវិគីភីឌាពី  សំណុំទិន្នន័យដោយប្រើបច្ចេកទេសទាំងពីរ ហើយពិភាក្សាអំពីអត្ថន័យនៃការផ្ទុកសំណុំទិន្នន័យទាំងមូល។ យើងបង្ហាញលទ្ធផលនៃសំណួរមួយចំនួនលើទិន្នន័យដែលបានផ្ទុក។ យើងក៏នឹងផ្ទុកសំណុំទិន្នន័យទាំងមូល - ជិត 6 លានឯកសារ - ទៅក្នុងមាតិកាដែលផ្តោតសំខាន់  .   ក្រាហ្វចំណេះដឹងដែលផ្តោតលើខ្លឹមសារ   2 វិគីមេលធីហប   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  ដោយ   , DataStax Ben Chambers

The is an opinion piece based on the author’s POV and does not necessarily reflect the views of HackerNoon.

DataStax Astra DB is the vector database for getting GenAI apps into production, fast. Try it for free today!

DataStax

សំឡេងនេះផលិតជាភាសាដើមនៃរឿង!

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

About Author

មតិយោបល់

ព្យួរស្លាក

អត្ថបទនេះត្រូវបានបង្ហាញនៅក្នុង

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps