565 ការអាន
565 ការអាន

អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់

ដោយ Superlinked18m2025/06/26
Read on Terminal Reader

យូរ​ពេក; អាន

វាត្រូវបានបង្កើតឡើងដោយកម្មវិធីស្រាវជ្រាវអេឡិចត្រូនិចក្នុងអំឡុងពេលដោយប្រើការស្វែងរក vector នៃ Superlinked ។ វាត្រូវបានផ្លាស់ប្តូរបំពង់ RAG ដែលមានភាពងាយស្រួលដោយការរួមបញ្ចូលនិងការសួរឯកសារដោយផ្ទាល់ - ធ្វើឱ្យការស្រាវជ្រាវយ៉ាងឆាប់រហ័ស, ជាការងាយស្រួលនិងប្រសើរជាងមុន។
featured image - អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់
Superlinked HackerNoon profile picture
0-item
1-item


តើធ្វើដូចម្តេចដើម្បីបង្កើតអេក្រង់ AI សម្រាប់ការស្វែងរកសៀវភៅស្រាវជ្រាវ, Search និង Summarization

តើធ្វើដូចម្តេចដើម្បីបង្កើតអេក្រង់ AI សម្រាប់ការស្វែងរកសៀវភៅស្រាវជ្រាវ, Search និង Summarization

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

សៀវភៅនេះពាក់ព័ន្ធអំពីការបង្កើតអេក្រង់ស្រាវជ្រាវ AI ដូចគ្នានេះដោយប្រើសមត្ថភាពបណ្តុះបណ្តាលឯកសារដែលមានភាពងាយស្រួលរបស់ Superlinked ។ ដោយការរួមបញ្ចូលគ្នានេះដោយសារធាតុអាសអាភាសនិងពេលវេលាយើងជួសជុលការតម្រូវការសម្រាប់ការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តាល។

សៀវភៅនេះពាក់ព័ន្ធអំពីការបង្កើតអេក្រង់ស្រាវជ្រាវ AI ដូចគ្នានេះដោយប្រើសមត្ថភាពបណ្តុះបណ្តាលឯកសារដែលមានភាពងាយស្រួលរបស់ Superlinked ។ ដោយការរួមបញ្ចូលគ្នានេះដោយសារធាតុអាសអាភាសនិងពេលវេលាយើងជួសជុលការតម្រូវការសម្រាប់ការបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តុះបណ្តាល។

TL;DR:

វាត្រូវបានបង្កើតឡើងដោយកម្មវិធីស្រាវជ្រាវអេឡិចត្រូនិចក្នុងអំឡុងពេលដោយប្រើការស្វែងរក vector នៃ Superlinked ។ វាត្រូវបានផ្លាស់ប្តូរបំពង់ RAG ដែលមានភាពងាយស្រួលដោយការរួមបញ្ចូលនិងការសួរឯកសារដោយផ្ទាល់ - ធ្វើឱ្យការស្រាវជ្រាវយ៉ាងឆាប់រហ័ស, ជាការងាយស្រួលនិងប្រសើរជាងមុន។

(ចង់បង្វិលដោយផ្ទាល់ទៅនឹងកូដនេះទេ? សូមពិនិត្យមើលកូដបង្វិលនៅលើ GitHub នៅទីនេះ។ រចនាឡើងដើម្បីធ្វើការស្រាវជ្រាវបង្វិលសម្រាប់ការប្រើប្រាស់ agentic របស់អ្នក? យើងនៅទីនេះដើម្បីជួយ។)

សូមពិនិត្យមើលកម្មវិធី Open Source នៅលើ GitHubទីនេះ.ទីនេះទីនេះយើងនៅទីនេះដើម្បីhelp.ការជួយការជួយ

សៀវភៅនេះបានបង្ហាញពីរបៀបដើម្បីបង្កើតប្រព័ន្ធអេក្រង់ដោយប្រើអេក្រង់ kernel ដើម្បីដោះស្រាយបញ្ហា។ ប្រសិនបើអ្នកចង់តាមដាននិងដំណើរការកូដនៅក្នុងបណ្តាញរបស់អ្នក,here’s the សត្វ.

សត្វ.សត្វ

តើធ្វើដូចម្តេចដើម្បីចាប់ផ្តើមការបង្កើតប្រព័ន្ធអ្នកគាំទ្រការស្រាវជ្រាវ?

ការបង្កើតប្រព័ន្ធដូចគ្នានេះរួមបញ្ចូលទាំងភាពងាយស្រួលនិងការផ្គត់ផ្គង់ឧបករណ៍ធំទូលាយ។ ប្រព័ន្ធស្វែងរកជាធម្មតានៅក្នុងការស្វែងរកកំណត់ទូលំទូលាយដំបូងនៃឯកសារដែលមានមូលដ្ឋានលើភាពងាយស្រួលនិងបន្ទាប់មកអនុវត្តដំណើរការកំណត់ទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូលំទូល

ការបង្កើតប្រព័ន្ធ agentic ជាមួយ Superlinked

អាជីវកម្ម AI នេះអាចធ្វើបីអ្វីជាសំខាន់:

  1. Find Papers: Search for research papers by topic (ឧទាហរណ៍ "ការទិន្នន័យកំដៅ" ) ហើយបន្ទាប់មកជារៀងរាល់ខ្លួនរបស់ពួកគេដោយអត្ថប្រយោជន៍និងចុងក្រោយ។
  2. សៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅ
  3. ឆ្លើយតបសំណួរ: ជ្រើសរើសសំណួរដោយផ្ទាល់ពីសៀវភៅស្រាវជ្រាវពិសេសដោយផ្អែកលើសំណួររបស់អ្នកប្រើដែលមានតម្រូវការ។

Superlinked បាត់បន្ថយការតម្រូវការក្នុងការធ្វើដំណើរការ re-ranking ដោយសារតែវាបានបង្កើនភាពតម្រូវការនៃការស្វែងរក vector ។ ការ RecencySpace នៃ Superlinked នឹងត្រូវបានប្រើសម្រាប់ការកូដទិន្នន័យបច្ចុប្បន្នដែលជាពិសេសការផ្តល់អំណាចសម្រាប់ឯកសារចុងក្រោយក្នុងអំឡុងពេលការស្វែងរកនិងការបាត់បន្ថយការតម្រូវការក្នុងការធ្វើដំណើរការ re-ranking ដែលមានតម្រូវការខ្ពស់។ ឧទាហរណ៍, ប្រសិនបើអត្ថបទពីរមានភាពតម្រូវការដូចគ្នា - អ្នកដែលជាថ្មីបំផុតនឹងមានទីតាំងខ្ពស់ជាងមុន។

ជំហានទី 1 : ការបង្កើត Toolbox

 %pip install superlinked

ដើម្បីធ្វើឱ្យអ្វីដែលមានភាពងាយស្រួលនិងបន្ថែមទៀត។ ខ្ញុំបានបង្កើតក្រុមប្រឹក្សាភិបាលឧបករណ៍បណ្តុះបណ្តាល។ នេះនឹងធ្វើឱ្យដំណើរការនៃការបង្កើតនិងបន្ថែមឧបករណ៍យ៉ាងងាយស្រួល។

import pandas as pd
import superlinked.framework as sl
from datetime import timedelta
from sentence_transformers import SentenceTransformer
from openai import OpenAI
import os
from abc import ABC, abstractmethod
from typing import Any, Optional, Dict
from tqdm import tqdm
from google.colab import userdata

# Abstract Tool Class
class Tool(ABC):
    @abstractmethod
    def name(self) -> str:
        pass

    @abstractmethod
    def description(self) -> str:
        pass

    @abstractmethod
    def use(self, *args, **kwargs) -> Any:
        pass


# Get API key from Google Colab secrets
try:
    api_key = userdata.get('OPENAI_API_KEY')
except KeyError:
    raise ValueError("OPENAI_API_KEY not found in user secrets. Please add it using Tools > User secrets.")

# Initialize OpenAI Client
api_key = os.environ.get("OPENAI_API_KEY", "your-openai-key")  # Replace with your OpenAI API key
if not api_key:
    raise ValueError("Please set the OPENAI_API_KEY environment variable.")

client = OpenAI(api_key=api_key)
model = "gpt-4"


ជំហានទី 2: ការយល់ដឹងអំពី Dataset

គំរូនេះប្រើសម្រាប់ទិន្នន័យដែលមានប្រហែល 10,000 សៀវភៅស្រាវជ្រាវ AI ដែលអាចរកបាននៅលើក្លឹបដើម្បីធ្វើឱ្យវាងាយស្រួលតែធ្វើដំណើរកញ្ចក់ខាងក្រោមហើយវាដោយស្វ័យប្រវត្តិនឹងទាញយកទិន្នន័យទៅក្នុងឯកសារការងាររបស់អ្នក។ អ្នកអាចប្រើប្រភពទិន្នន័យរបស់អ្នកដូចជាសៀវភៅស្រាវជ្រាវឬសម្ភារៈសាកលវិទ្យាល័យផ្សេងទៀត។ ប្រសិនបើអ្នកជ្រើសរើសដើម្បីធ្វើដូច្នេះ, អ្វីដែលអ្នកត្រូវធ្វើគឺការកំណត់រចនាសម្រាប់រចនាសម្រាប់រចនាសម្រាប់រចនាសម្រាប់រចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្រាប់ចនាសម្ព័ន្ធ។

import pandas as pd

!wget --no-check-certificate 'https://drive.google.com/uc?export=download&id=1FCR3TW5yLjGhEmm-Uclw0_5PWVEaLk1j' -O arxiv_ai_data.csv


ឥឡូវនេះ, ដើម្បីធ្វើឱ្យការដំណើរការយ៉ាងឆាប់រហ័ស, យើងនឹងប្រើសម្រាប់ការប្រើសម្រាប់សៀវភៅដែលមានតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការតម្រូវការ

df = pd.read_csv('arxiv_ai_data.csv').head(100)

# Convert to datetime but keep it as datetime (more readable and usable)
df['published'] = pd.to_datetime(df['published'])

# Ensure summary is a string
df['summary'] = df['summary'].astype(str)

# Add 'text' column for similarity search
df['text'] = df['title'] + " " + df['summary']
Debug: Columns in original DataFrame: ['authors', 'categories', 'comment', 'doi', 'entry_id', 'journal_ref' 'pdf_url', 'primary_category', 'published', 'summary', 'title', 'updated']

ការយល់ដឹងអំពីទម្រង់ទិន្នន័យ

ខាងក្រោមនេះគឺជាការពិនិត្យឡើងវិញយ៉ាងទូលំទូលាយនៃកញ្ចក់សំខាន់នៅក្នុងទិន្នន័យរបស់យើងដែលនឹងមានសំខាន់នៅក្នុងដំណោះស្រាយបន្ទាប់:

  1. published: The publication date of the research paper.
  2. summary: The abstract of the paper, providing a concise overview.
  3. entry_id: អាសយដ្ឋានតែមួយគត់សម្រាប់ឯកសារទាំងអស់ពី arXiv ។

សម្រាប់ការបង្ហាញនេះយើងផ្តោតលើការបណ្តុះបណ្តាលទាំងបី:entry_idលោកpublishedលោកtitleនិងsummaryដើម្បីបង្កើនគុណភាពការស្វែងរកដែលមានប្រសិទ្ធិភាព, សៀវភៅនិងសៀវភៅនេះត្រូវបានរួមបញ្ចូលទៅក្នុងកញ្ចប់សៀវភៅតែមួយដែលជាមូលដ្ឋាននៃដំណើរការដំឡើងនិងការស្វែងរករបស់យើង។

គោលបំណងអំពី In-Memory Indexer របស់ Superlinked : គោលបំណង in-memory នៃ Superlinked បានផ្ទុកទិន្នន័យរបស់យើងដោយផ្ទាល់ទៅក្នុង RAM ដែលធ្វើឱ្យការស្វែងរកយ៉ាងឆាប់រហ័សយ៉ាងខ្លាំងដែលជាការល្អឥតគិតថ្លៃសម្រាប់ការស្វែងរកពេលវេលាពិតប្រាកដនិងការគំរូល្បឿនលឿន។ សម្រាប់គោលបំណងសាកល្បងនេះជាមួយនឹងសៀវភៅស្រាវជ្រាវ 1,000 នេះការប្រើប្រាស់វិធីសាស្រ្ត in-memory បានបង្កើនប្រសិទ្ធិភាពនៃការស្វែងរកយ៉ាងខ្លាំងដោយការកាត់បន្ថយការឆ្លងកាត់បន្ថយដែលទាក់ទងនឹងការចូលដំណើរការដែក។

ជំហានទី 3: Defining the Superlinked Schema ។

ដើម្បីដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយដោះស្រាយPaperSchemaជាមួយនឹងតំបន់សំខាន់:

lass PaperSchema(sl.Schema):
    text: sl.String
    published: sl.Timestamp  # This will handle datetime objects properly
    entry_id: sl.IdField
    title: sl.String
    summary: sl.String

paper = PaperSchema()


ការកំណត់ពាណិជ្ជកម្ម Superlinked Spaces for Effective Retrieval

ជំហានសំខាន់ក្នុងការរៀបចំនិងការសួរប្រសិទ្ធិភាពនៃទិន្នន័យរបស់យើងរួមបញ្ចូលទាំងការកំណត់រចនាសម្ព័ន្ធបណ្តាញបណ្តាញពិសេសពីរ: TextSimilaritySpace និង RecencySpace ។

  1. សៀវភៅសៀវភៅ

នេះTextSimilaritySpaceវាត្រូវបានរចនាឡើងដើម្បីកូដទិន្នន័យសៀវភៅដូចជាកំណត់សៀវភៅស្រាវជ្រាវនិងសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភ

text_space = sl.TextSimilaritySpace(
    text=sl.chunk(paper.text, chunk_size=200, chunk_overlap=50),
    model="sentence-transformers/all-mpnet-base-v2"
)


  1. អាសយដ្ឋាន

នេះRecencySpaceវាត្រូវបានរក្សាទុក metadata ក្នុងអំឡុងពេលដែលវាត្រូវបានបង្ហាញថានៅពេលបច្ចុប្បន្ននៃការស្រាវជ្រាវ។ ដោយការកូដស្លាកពេលបច្ចុប្បន្ននេះវាត្រូវបានបង្ហាញថានៅពេលបច្ចុប្បន្ននេះមានអត្ថប្រយោជន៍កាន់តែច្រើនដល់ឯកសារថ្មីជាងនេះ។ ដូច្នេះផលិតផលនៃការស្វែងរកមានភាពរឹងមាំអំពីអត្ថប្រយោជន៍នៃសម្ភារៈជាមួយនឹងពេលបច្ចុប្បន្ននៃការបោះពុម្ព។ ដូច្នេះវាត្រូវបានកំណត់ថានៅពេលបច្ចុប្បន្ន។

recency_space = sl.RecencySpace(
    timestamp=paper.published,
    period_time_list=[
        sl.PeriodTime(timedelta(days=365)),      # papers within 1 year
        sl.PeriodTime(timedelta(days=2*365)),    # papers within 2 years
        sl.PeriodTime(timedelta(days=3*365)),    # papers within 3 years
    ],
    negative_filter=-0.25
)


សូមគិតថា RecencySpace គឺជាឯកសារដែលមានមូលដ្ឋានលើពេលវេលា ដូចជាការប្រៀបធៀបអ៊ីម៉ែលរបស់អ្នកដោយពេលវេលាឬមើលរូបថតនៅលើ Instagram ជាមួយនឹងរូបថតថ្មីបំផុតជាលើកដំបូង។ វាគឺជាការងាយស្រួលក្នុងការឆ្លើយតបទៅនឹងសំណួរ, 'សៀវភៅនេះមានកម្រិតខ្ពស់ជាងនេះទេ?

  • ទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំទំហំ
  • ពេលវេលាធំជាងនេះ (ដូចជា 1095 ថ្ងៃ) បានបង្កើតពេលវេលាធំជាងនេះ។

នេះnegative_filterដើម្បីបង្ហាញវាយ៉ាងច្បាស់លាស់ជាងនេះ, សូមពិនិត្យមើលឧទាហរណ៍ខាងក្រោមដែលបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាពនៃបច្ចុប្បន្នភាព។

Paper A: Published in 1996 
Paper B: Published in 1993

Scoring example:
- Text similarity score: Both papers get 0.8
- Recency score:
  - Paper A: Receives the full recency boost (1.0)
  - Paper B: Gets penalized (-0.25 due to negative_filter)

Final combined scores:
- Paper A: Higher final rank
- Paper B: Lower final rank


វាគឺជាការសំខាន់ក្នុងការធ្វើឱ្យទិន្នន័យកំណត់និងមានប្រសិទ្ធិភាពជាងមុន។ វាត្រូវបានអនុញ្ញាតឱ្យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យទិន្នន័យ។

ជំហានទី 4: បានបង្កើត index

បន្ទាប់មកវាត្រូវបានបំពាក់ទៅក្នុងអេក្រង់ដែលជាមធ្យមនៃម៉ាស៊ីនស្វែងរក:

paper_index = sl.Index([text_space, recency_space])

បន្ទាប់មក DataFrame ត្រូវបានបណ្តុះបណ្តាលទៅក្នុងគំនិតនិងត្រូវបានផ្ទុកក្នុងដំណាក់កាល (10 សៀវភៅក្នុងមួយពេល) ទៅក្នុងការផ្ទុក in-memory:

# Parser to map DataFrame columns to schema fields
parser = sl.DataFrameParser(
    paper,
    mapping={
        paper.entry_id: "entry_id",
        paper.published: "published",
        paper.text: "text",
        paper.title: "title",
        paper.summary: "summary",
    }
)

# Set up in-memory source and executor
source = sl.InMemorySource(paper, parser=parser)
executor = sl.InMemoryExecutor(sources=[source], indices=[paper_index])
app = executor.run()

# Load the DataFrame with a progress bar using batches
batch_size = 10
data_batches = [df[i:i + batch_size] for i in range(0, len(df), batch_size)]
for batch in tqdm(data_batches, total=len(data_batches), desc="Loading Data into Source"):
    source.put([batch])


ឧបករណ៍ប្រតិបត្តិការ in-memory គឺជាមូលហេតុដែល Superlinked បានពន្លឺនៅទីនេះ—1,000 សៀវភៅអាចបង្ហាញបានយ៉ាងឆាប់រហ័សនៅក្នុង RAM, និងសំណួរអាចដោះស្រាយបានដោយគ្មានបញ្ហាន I / O ។

ជំហានទី 5: Crafting the query

បន្ទាប់មកមានការបង្កើតសំណួរ។ នេះគឺជាកន្លែងដែលគំរូសម្រាប់ការរចនាសំណួរត្រូវបានបង្កើតឡើង។ ដើម្បីគ្រប់គ្រងនេះយើងត្រូវការគំរូសំណួរដែលអាចរៀបរៀបរៀបរៀបការទាំងទូទៅនិងចុងក្រោយ។ នេះគឺដូច្នេះដូច្នេះ:

# Define the query
knowledgebase_query = (
    sl.Query(
        paper_index,
        weights={
            text_space: sl.Param("relevance_weight"),
            recency_space: sl.Param("recency_weight"),
        }
    )
    .find(paper)
    .similar(text_space, sl.Param("search_query"))
    .select(paper.entry_id, paper.published, paper.text, paper.title, paper.summary)
    .limit(sl.Param("limit"))
)


នេះអនុញ្ញាតឱ្យយើងដើម្បីជ្រើសរើសប្រយោជន៍នៃសម្ភារៈ (relevance_weight) ឬប្រយោជន៍ (recency_weight) - ការរួមបញ្ចូលដែលមានប្រយោជន៍ខ្លាំងណាស់សម្រាប់តម្រូវការរបស់អេក្រង់របស់យើង។

ជំហានទី 6 : ការបង្កើតឧបករណ៍

ឥឡូវនេះមកជាផ្នែកមួយនៃឧបករណ៍។

យើងនឹងបង្កើតបីឧបករណ៍ ...

  1. ឧបករណ៍ស្វែងរក : ឧបករណ៍នេះត្រូវបានរចនាឡើងដោយការបំពាក់ចូលទៅក្នុងឧបករណ៍អេក្រង់ Superlinked ដែលអនុញ្ញាតឱ្យវាត្រូវបានបំពាក់ 5 សៀវភៅដំបូងដោយផ្អែកលើការស្វែងរក។ វាត្រូវបានបំពាក់ប្រសិទ្ធភាព (1.0 សៀវភៅ) និងប្រសិទ្ធភាពថ្មី (0.5 សៀវភៅ) ដើម្បីទទួលបានគោលបំណង "ស្វែងរកសៀវភៅ" ។ អ្វីដែលយើងចង់បានគឺដើម្បីរកឃើញសៀវភៅដែលមានប្រសិទ្ធភាពសម្រាប់ការស្វែងរក។ ដូច្នេះប្រសិនបើការស្វែងរកគឺ: "សៀវភៅកូដកូដកូដកូដកូដកូដកូដកូដកូដកូដកូដកូដកូ
class RetrievalTool(Tool):
    def __init__(self, df, app, knowledgebase_query, client, model):
        self.df = df
        self.app = app
        self.knowledgebase_query = knowledgebase_query
        self.client = client
        self.model = model

    def name(self) -> str:
        return "RetrievalTool"

    def description(self) -> str:
        return "Retrieves a list of relevant papers based on a query using Superlinked."

    def use(self, query: str) -> pd.DataFrame:
        result = self.app.query(
            self.knowledgebase_query,
            relevance_weight=1.0,
            recency_weight=0.5,
            search_query=query,
            limit=5
        )
        df_result = sl.PandasConverter.to_pandas(result)
        # Ensure summary is a string
        if 'summary' in df_result.columns:
            df_result['summary'] = df_result['summary'].astype(str)
        else:
            print("Warning: 'summary' column not found in retrieved DataFrame.")
        return df_result


បន្ទាប់ពីនេះគឺជាSummarization Toolឧបករណ៍នេះត្រូវបានរចនាឡើងសម្រាប់ករណីដែលមានតម្រូវការនៃសៀវភៅមួយ។ ដើម្បីប្រើវាវានឹងត្រូវបានផ្តល់នូវpaper_id, ដែលជា ID នៃសៀវភៅដែលត្រូវការកំណត់។ ប្រសិនបើpaper_idប្រសិនបើឧបករណ៍នេះមិនត្រូវបានផ្តល់ជូន, ឧបករណ៍នេះនឹងមិនធ្វើការដូច្នេះ IDs ទាំងនេះគឺជាតម្រូវការដើម្បីស្វែងរកឯកសារដែលសមរម្យនៅក្នុងទិន្នន័យ។

class SummarizationTool(Tool):
    def __init__(self, df, client, model):
        self.df = df
        self.client = client
        self.model = model

    def name(self) -> str:
        return "SummarizationTool"

    def description(self) -> str:
        return "Generates a concise summary of specified papers using an LLM."

    def use(self, query: str, paper_ids: list) -> str:
        papers = self.df[self.df['entry_id'].isin(paper_ids)]
        if papers.empty:
            return "No papers found with the given IDs."
        summaries = papers['summary'].tolist()
        summary_str = "\n\n".join(summaries)
        prompt = f"""
        Summarize the following paper summaries:\n\n{summary_str}\n\nProvide a concise summary.
        """
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
            max_tokens=500
        )
        return response.choices[0].message.content.strip()


ឥឡូវនេះយើងមានQuestionAnsweringToolឧបករណ៍នេះបានកាត់បន្ថយRetrievalToolសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅសៀវភៅ

class QuestionAnsweringTool(Tool):
    def __init__(self, retrieval_tool, client, model):
        self.retrieval_tool = retrieval_tool
        self.client = client
        self.model = model

    def name(self) -> str:
        return "QuestionAnsweringTool"

    def description(self) -> str:
        return "Answers questions about research topics using retrieved paper summaries or general knowledge if no specific context is available."

    def use(self, query: str) -> str:
        df_result = self.retrieval_tool.use(query)
        if 'summary' not in df_result.columns:
            # Tag as a general question if summary is missing
            prompt = f"""
            You are a knowledgeable research assistant. This is a general question tagged as [GENERAL]. Answer based on your broad knowledge, not limited to specific paper summaries. If you don't know the answer, provide a brief explanation of why.

            User's question: {query}
            """
        else:
            # Use paper summaries for specific context
            contexts = df_result['summary'].tolist()
            context_str = "\n\n".join(contexts)
            prompt = f"""
            You are a research assistant. Use the following paper summaries to answer the user's question. If you don't know the answer based on the summaries, say 'I don't know.'

            Paper summaries:
            {context_str}

            User's question: {query}
            """
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
            max_tokens=500
        )
        return response.choices[0].message.content.strip()


ជំហានទី 7 : ការបង្កើតអេក្រង់ kernel

Next is the Kernel Agent. It functions as the central controller, ensuring smooth and efficient operation. Acting as the core component of the system, the Kernel Agent coordinates communication by routing queries according to their intention when multiple agents operate simultaneously. ក្នុងប្រព័ន្ធអេក្រង់តែមួយដូចជានេះ, the Kernel Agent directly uses the relevant tools to manage tasks effectively.

class KernelAgent:
    def __init__(self, retrieval_tool: RetrievalTool, summarization_tool: SummarizationTool, question_answering_tool: QuestionAnsweringTool, client, model):
        self.retrieval_tool = retrieval_tool
        self.summarization_tool = summarization_tool
        self.question_answering_tool = question_answering_tool
        self.client = client
        self.model = model

    def classify_query(self, query: str) -> str:
        prompt = f"""
        Classify the following user prompt into one of the three categories:
        - retrieval: The user wants to find a list of papers based on some criteria (e.g., 'Find papers on AI ethics from 2020').
        - summarization: The user wants to summarize a list of papers (e.g., 'Summarize papers with entry_id 123, 456, 789').
        - question_answering: The user wants to ask a question about research topics and get an answer (e.g., 'What is the latest development in AI ethics?').

        User prompt: {query}

        Respond with only the category name (retrieval, summarization, question_answering).
        If unsure, respond with 'unknown'.
        """
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.7,
            max_tokens=10
        )
        classification = response.choices[0].message.content.strip().lower()
        print(f"Query type: {classification}")
        return classification

    def process_query(self, query: str, params: Optional[Dict] = None) -> str:
        query_type = self.classify_query(query)
        if query_type == 'retrieval':
            df_result = self.retrieval_tool.use(query)
            response = "Here are the top papers:\n"
            for i, row in df_result.iterrows():
                # Ensure summary is a string and handle empty cases
                summary = str(row['summary']) if pd.notna(row['summary']) else ""
                response += f"{i+1}. {row['title']} \nSummary: {summary[:200]}...\n\n"
            return response
        elif query_type == 'summarization':
            if not params or 'paper_ids' not in params:
                return "Error: Summarization query requires a 'paper_ids' parameter with a list of entry_ids."
            return self.summarization_tool.use(query, params['paper_ids'])
        elif query_type == 'question_answering':
            return self.question_answering_tool.use(query)
        else:
            return "Error: Unable to classify query as 'retrieval', 'summarization', or 'question_answering'."


នៅពេលនេះប្រព័ន្ធនេះអាចត្រូវបានចាប់ផ្តើមដោយផ្តល់នូវប្រព័ន្ធ Kernel Agent ជាមួយនឹងឧបករណ៍ដែលសមរម្យហើយបន្ទាប់ពីនេះប្រព័ន្ធការស្រាវជ្រាវ Agent នឹងមានប្រតិបត្តិការពេញលេញ។

retrieval_tool = RetrievalTool(df, app, knowledgebase_query, client, model)
summarization_tool = SummarizationTool(df, client, model)
question_answering_tool = QuestionAnsweringTool(retrieval_tool, client, model)

# Initialize KernelAgent
kernel_agent = KernelAgent(retrieval_tool, summarization_tool, question_answering_tool, client, model)


ឥឡូវនេះយើងធ្វើតេស្តប្រព័ន្ធនេះ។

# Test query print(kernel_agent.process_query("Find papers on quantum computing in last 10 years"))

ការធ្វើតេស្តនេះបានបង្កើតកម្មវិធីRetrievalToolវាត្រូវបានទាញយកសៀវភៅដែលមានប្រសិទ្ធភាពនិងចុងក្រោយដោយផ្អែកលើការអនុវត្តនិងផ្លាស់ប្តូរសៀវភៅដែលមានប្រសិទ្ធភាព។ ប្រសិនបើផលិតផលដែលត្រូវបានទាញយករួមមានសៀវភៅសៀវភៅសៀវភៅដែលត្រូវបានទាញយកពីទិន្នន័យនេះវាត្រូវបានប្រើសៀវភៅសៀវភៅដែលមានប្រសិទ្ធភាពនិងផ្លាស់ប្តូរសៀវភៅនេះទៅយើង។

Query type: retrieval
Here are the top papers:
1. Quantum Computing and Phase Transitions in Combinatorial Search 
Summary: We introduce an algorithm for combinatorial search on quantum computers that
is capable of significantly concentrating amplitude into solutions for some NP
search problems, on average. This is done by...

1. The Road to Quantum Artificial Intelligence 
Summary: This paper overviews the basic principles and recent advances in the emerging
field of Quantum Computation (QC), highlighting its potential application to
Artificial Intelligence (AI). The paper provi...

1. Solving Highly Constrained Search Problems with Quantum Computers 
Summary: A previously developed quantum search algorithm for solving 1-SAT problems in
a single step is generalized to apply to a range of highly constrained k-SAT
problems. We identify a bound on the number o...

1. The model of quantum evolution 
Summary: This paper has been withdrawn by the author due to extremely unscientific
errors....

1. Artificial and Biological Intelligence 
Summary: This article considers evidence from physical and biological sciences to show
machines are deficient compared to biological systems at incorporating
intelligence. Machines fall short on two counts: fi...


សូមពិនិត្យឡើងវិញបញ្ហាមួយទៀត, ឥឡូវនេះ, សូមធ្វើការបញ្ជាក់មួយ។

print(kernel_agent.process_query("Summarize this paper", params={"paper_ids": ["http://arxiv.org/abs/cs/9311101v1"]}))

Query type: summarization
This paper discusses the challenges of learning logic programs that contain the cut predicate (!). Traditional learning methods cannot handle clauses with cut because it has a procedural meaning. The proposed approach is to first generate a candidate base program that covers positive examples, and then make it consistent by inserting cut where needed. Learning programs with cut is difficult due to the need for intensional evaluation, and current induction techniques may need to be limited to purely declarative logic languages.


ខ្ញុំនឹងថាឧទាហរណ៍នេះបានជួយក្នុងការអភិវឌ្ឍអេក្រង់អេក្រង់អេក្រង់អេក្រង់និងប្រព័ន្ធដែលមានមូលដ្ឋាននៅលើអេក្រង់។ លក្ខណៈពិសេសការស្វែងរកដែលបានបង្ហាញនៅទីនេះជាច្រើនត្រូវបានអនុវត្តដោយ Superlinked ដូច្នេះ សូមអរគុណថាអ្នកគិតអំពីការចាប់ផ្តើមនៃកម្មវិធីនេះ។សៀវភៅសម្រាប់គោលបំណងចុងក្រោយនៅពេលដែលសមត្ថភាពស្វែងរកត្រឹមត្រូវត្រូវត្រូវសម្រាប់អេក្រង់ AI របស់អ្នក!

សត្វ

លេខកូដ Notebook

  • ការរួមបញ្ចូលគ្នានៃតម្រូវការអត្ថប្រយោជន៍អាសអាភាសនិងអំឡុងពេល eliminates complex rearanking whileining search accuracy for research papers.
  • ការកាត់បន្ថយលើពេលវេលា (negative_filter=-0.25) អនុញ្ញាតឱ្យការស្រាវជ្រាវចុងក្រោយមានគោលបំណងនៅពេលដែលសៀវភៅមានគោលបំណងសម្ភារៈដូចគ្នា។
  • មជ្ឈមណ្ឌលឧបករណ៍បណ្តុះបណ្តាលម៉ូឌុលអនុញ្ញាតឱ្យឧបករណ៍ឯកទេសដើម្បីដោះស្រាយដំណើរការផ្សេងគ្នានៃតម្រូវការ (ការដោះស្រាយការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់ការបញ្ចប់។
  • ការទាញយកទិន្នន័យនៅក្នុងទម្រង់តូច (batch_size=10) ជាមួយនឹងការរក្សាទុកដំណើរការធ្វើឱ្យប្រសិទ្ធភាពប្រព័ន្ធល្អប្រសើរឡើងនៅពេលដំណើរការទិន្នន័យស្រាវជ្រាវធំ។
  • ទំងន់សំណួរដែលអាចកំណត់បានអនុញ្ញាតឱ្យអ្នកប្រើប្រាស់កំណត់តម្រូវការ (1.0) និងចុងក្រោយ (0.5) ដោយផ្អែកលើតម្រូវការស្រាវជ្រាវពិសេស។
  • សម្ភារៈដែលមានការឆ្លើយតបទៅនឹងសំណួរត្រូវបានកាត់បន្ថយទៅនឹងការយល់ដឹងជាទូទៅនៅពេលដែលគំនិតឯកសារពិសេសគឺមិនអាចរកបាន, ការពារបទពិសោធន៍អ្នកប្រើដែលមិនមានលក្ខណៈពិសេស។

ការរក្សាទុកពេលវេលាជាមួយនឹងចំនួនធំទូលំទូលាយនៃសៀវភៅស្រាវជ្រាវដែលបានបោះពុម្ពជាទូទៅអាចជាការជំរុញនិងរក្សាទុកពេលវេលា។ ការដំណើរការការងារអេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេក្រង់អេ

អ្នកជំនួយ

  • លោក Vipul Maheshwari, អ្នកនិពន្ធ
  • លោក Filip Makraduli, យោបល់


L O A D I N G
. . . comments & more!

About Author

Superlinked HackerNoon profile picture
Superlinked@superlinked
Turning complex data into vector embeddings for better AI/ML results.

ព្យួរស្លាក

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

Trending Topics

blockchaincryptocurrencyhackernoon-top-storyprogrammingsoftware-developmenttechnologystartuphackernoon-booksBitcoinbooks