Datasets:

Darsala
/

GraphRAG-Bench-Georgian

import os
import argparse
import json
import logging
from typing import Dict, List
from dotenv import load_dotenv
from pathlib import Path
from transformers import AutoTokenizer
from tqdm import tqdm

# Load environment variables
load_dotenv()

# Set CUDA device
os.environ["CUDA_VISIBLE_DEVICES"] = "1"

# Import HippoRAG components after setting environment
from src.hipporag.HippoRAG import HippoRAG
from src.hipporag.utils.misc_utils import string_to_bool
from src.hipporag.utils.config_utils import BaseConfig

# Configure logging
logging.basicConfig(
    format="%(asctime)s - %(levelname)s - %(message)s",
    level=logging.INFO,
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler("hipporag_processing.log")
    ]
)

def group_questions_by_source(question_list: List[dict]) -> Dict[str, List[dict]]:
    """Group questions by their source"""
    grouped_questions = {}
    for question in question_list:
        source = question.get("source")
        if source not in grouped_questions:
            grouped_questions[source] = []
        grouped_questions[source].append(question)
    return grouped_questions

def split_text(
    text: str, 
    tokenizer: AutoTokenizer, 
    chunk_token_size: int = 256, 
    chunk_overlap_token_size: int = 32
) -> List[str]:
    """Split text into chunks based on token length with overlap"""
    tokens = tokenizer.encode(text, add_special_tokens=False)
    chunks = []

    start = 0
    while start < len(tokens):
        end = min(start + chunk_token_size, len(tokens))
        chunk_tokens = tokens[start:end]
        chunk_text = tokenizer.decode(
            chunk_tokens, 
            skip_special_tokens=True, 
            clean_up_tokenization_spaces=True
        )
        chunks.append(chunk_text)
        if end == len(tokens):
            break
        start += chunk_token_size - chunk_overlap_token_size
    return chunks

def process_corpus(
    corpus_name: str,
    context: str,
    base_dir: str,
    model_name: str,
    embed_model_path: str,
    llm_base_url: str,
    llm_api_key: str,
    questions: List[dict],
    sample: int
):
    """Process a single corpus: index it and answer its questions"""
    logging.info(f"📚 Processing corpus: {corpus_name}")
    
    # Prepare output directory
    output_dir = f"./results/hipporag2/{corpus_name}"
    os.makedirs(output_dir, exist_ok=True)
    output_path = os.path.join(output_dir, f"predictions_{corpus_name}.json")
    
    # Initialize tokenizer for text splitting
    try:
        tokenizer = AutoTokenizer.from_pretrained(embed_model_path)
        logging.info(f"✅ Loaded tokenizer: {embed_model_path}")
    except Exception as e:
        logging.error(f"❌ Failed to load tokenizer: {e}")
        return
    
    # Split text into chunks
    chunks = split_text(context, tokenizer)
    logging.info(f"✂️ Split corpus into {len(chunks)} chunks")
    
    # Format chunks as documents
    docs = [f'{idx}:{chunk}' for idx, chunk in enumerate(chunks)]
    
    # Get questions for this corpus
    corpus_questions = questions.get(corpus_name, [])
    if not corpus_questions:
        logging.warning(f"⚠️ No questions found for corpus: {corpus_name}")
        return
    
    # Sample questions if requested
    if sample and sample < len(corpus_questions):
        corpus_questions = corpus_questions[:sample]
    
    logging.info(f"🔍 Found {len(corpus_questions)} questions for {corpus_name}")
    
    # Prepare queries and gold answers
    all_queries = [q["question"] for q in corpus_questions]
    gold_answers = [[q['answer']] for q in corpus_questions]
    
    # Configure HippoRAG
    config = BaseConfig(
        save_dir=os.path.join(base_dir, corpus_name),
        llm_base_url=llm_base_url,
        llm_name=model_name,
        embedding_model_name=embed_model_path.split('/')[-1],
        force_index_from_scratch=True,
        force_openie_from_scratch=True,
        rerank_dspy_file_path="src/hipporag/prompts/dspy_prompts/filter_llama3.3-70B-Instruct.json",
        retrieval_top_k=5,
        linking_top_k=5,
        max_qa_steps=3,
        qa_top_k=5,
        graph_type="facts_and_sim_passage_node_unidirectional",
        embedding_batch_size=8,
        max_new_tokens=None,
        corpus_len=len(docs),
        openie_mode="online"
    )
    
    # Initialize HippoRAG
    hipporag = HippoRAG(global_config=config)
    
    # Index the corpus content
    hipporag.index(docs)
    logging.info(f"✅ Indexed corpus: {corpus_name}")
    
    # Process questions
    results = []

    queries_solutions, _, _, _, _ = hipporag.rag_qa(queries=all_queries, gold_docs=None, gold_answers=gold_answers)
    solutions = [query.to_dict() for query in queries_solutions]
    
    for question in corpus_questions:
        solution = next((sol for sol in solutions if sol['question'] == question['question']), None)
        if solution:
            results.append({
                "id": question["id"],
                "question": question["question"],
                "source": corpus_name,
                "context": solution.get("docs", ""),
                "evidence": question.get("evidence", ""),
                "question_type": question.get("question_type", ""),
                "generated_answer": solution.get("answer", ""),
                "gold_answer": question.get("answer", "")
            })
    
    # Save results
    with open(output_path, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)
    
    logging.info(f"💾 Saved {len(results)} predictions to: {output_path}")

def main():
    # Define subset paths
    SUBSET_PATHS = {
        "medical": {
            "corpus": "./Datasets/Corpus/medical.json",
            "questions": "./Datasets/Questions/medical_questions.json"
        },
        "novel": {
            "corpus": "./Datasets/Corpus/novel.json",
            "questions": "./Datasets/Questions/novel_questions.json"
        }
    }
    
    parser = argparse.ArgumentParser(description="HippoRAG: Process Corpora and Answer Questions")
    
    # Core arguments
    parser.add_argument("--subset", required=True, choices=["medical", "novel"], 
                        help="Subset to process (medical or novel)")
    parser.add_argument("--base_dir", default="./hipporag2_workspace", 
                        help="Base working directory for HippoRAG")
    
    # Model configuration
    parser.add_argument("--model_name", default="gpt-4o-mini", 
                        help="LLM model identifier")
    parser.add_argument("--embed_model_path", default="/home/xzs/data/model/contriever", 
                        help="Path to embedding model directory")
    parser.add_argument("--sample", type=int, default=None, 
                        help="Number of questions to sample per corpus")
    
    # API configuration
    parser.add_argument("--llm_base_url", default="https://api.openai.com/v1", 
                        help="Base URL for LLM API")
    parser.add_argument("--llm_api_key", default="", 
                        help="API key for LLM service (can also use OPENAI_API_KEY environment variable)")

    args = parser.parse_args()
    
    logging.info(f"🚀 Starting HippoRAG processing for subset: {args.subset}")
    
    # Validate subset
    if args.subset not in SUBSET_PATHS:
        logging.error(f"❌ Invalid subset: {args.subset}. Valid options: {list(SUBSET_PATHS.keys())}")
        return
    
    # Get file paths for this subset
    corpus_path = SUBSET_PATHS[args.subset]["corpus"]
    questions_path = SUBSET_PATHS[args.subset]["questions"]
    
    # Handle API key security
    api_key = args.llm_api_key or os.getenv("OPENAI_API_KEY", "")
    if not api_key:
        logging.warning("⚠️ No API key provided! Requests may fail.")
    
    # Create workspace directory
    os.makedirs(args.base_dir, exist_ok=True)
    
    # Load corpus data
    try:
        with open(corpus_path, "r", encoding="utf-8") as f:
            corpus_data = json.load(f)
        logging.info(f"📖 Loaded corpus with {len(corpus_data)} documents from {corpus_path}")
    except Exception as e:
        logging.error(f"❌ Failed to load corpus: {e}")
        return
    
    # Sample corpus data if requested
    if args.sample:
        corpus_data = corpus_data[:1]
    
    # Load question data
    try:
        with open(questions_path, "r", encoding="utf-8") as f:
            question_data = json.load(f)
        grouped_questions = group_questions_by_source(question_data)
        logging.info(f"❓ Loaded questions with {len(question_data)} entries from {questions_path}")
    except Exception as e:
        logging.error(f"❌ Failed to load questions: {e}")
        return
    
    # Process each corpus in the subset
    for item in corpus_data:
        corpus_name = item["corpus_name"]
        context = item["context"]
        process_corpus(
            corpus_name=corpus_name,
            context=context,
            base_dir=args.base_dir,
            model_name=args.model_name,
            embed_model_path=args.embed_model_path,
            llm_base_url=args.llm_base_url,
            llm_api_key=api_key,
            questions=grouped_questions,
            sample=args.sample
        )

if __name__ == "__main__":
    main()

	import os
	import argparse
	import json
	import logging
	from typing import Dict, List
	from dotenv import load_dotenv
	from pathlib import Path
	from transformers import AutoTokenizer
	from tqdm import tqdm

	# Load environment variables
	load_dotenv()

	# Set CUDA device
	os.environ["CUDA_VISIBLE_DEVICES"] = "1"

	# Import HippoRAG components after setting environment
	from src.hipporag.HippoRAG import HippoRAG
	from src.hipporag.utils.misc_utils import string_to_bool
	from src.hipporag.utils.config_utils import BaseConfig

	# Configure logging
	logging.basicConfig(
	format="%(asctime)s - %(levelname)s - %(message)s",
	level=logging.INFO,
	handlers=[
	logging.StreamHandler(),
	logging.FileHandler("hipporag_processing.log")
	]
	)

	def group_questions_by_source(question_list: List[dict]) -> Dict[str, List[dict]]:
	"""Group questions by their source"""
	grouped_questions = {}
	for question in question_list:
	source = question.get("source")
	if source not in grouped_questions:
	grouped_questions[source] = []
	grouped_questions[source].append(question)
	return grouped_questions

	def split_text(
	text: str,
	tokenizer: AutoTokenizer,
	chunk_token_size: int = 256,
	chunk_overlap_token_size: int = 32
	) -> List[str]:
	"""Split text into chunks based on token length with overlap"""
	tokens = tokenizer.encode(text, add_special_tokens=False)
	chunks = []

	start = 0
	while start < len(tokens):
	end = min(start + chunk_token_size, len(tokens))
	chunk_tokens = tokens[start:end]
	chunk_text = tokenizer.decode(
	chunk_tokens,
	skip_special_tokens=True,
	clean_up_tokenization_spaces=True
	)
	chunks.append(chunk_text)
	if end == len(tokens):
	break
	start += chunk_token_size - chunk_overlap_token_size
	return chunks

	def process_corpus(
	corpus_name: str,
	context: str,
	base_dir: str,
	model_name: str,
	embed_model_path: str,
	llm_base_url: str,
	llm_api_key: str,
	questions: List[dict],
	sample: int
	):
	"""Process a single corpus: index it and answer its questions"""
	logging.info(f"📚 Processing corpus: {corpus_name}")

	# Prepare output directory
	output_dir = f"./results/hipporag2/{corpus_name}"
	os.makedirs(output_dir, exist_ok=True)
	output_path = os.path.join(output_dir, f"predictions_{corpus_name}.json")

	# Initialize tokenizer for text splitting
	try:
	tokenizer = AutoTokenizer.from_pretrained(embed_model_path)
	logging.info(f"✅ Loaded tokenizer: {embed_model_path}")
	except Exception as e:
	logging.error(f"❌ Failed to load tokenizer: {e}")
	return

	# Split text into chunks
	chunks = split_text(context, tokenizer)
	logging.info(f"✂️ Split corpus into {len(chunks)} chunks")

	# Format chunks as documents
	docs = [f'{idx}:{chunk}' for idx, chunk in enumerate(chunks)]

	# Get questions for this corpus
	corpus_questions = questions.get(corpus_name, [])
	if not corpus_questions:
	logging.warning(f"⚠️ No questions found for corpus: {corpus_name}")
	return

	# Sample questions if requested
	if sample and sample < len(corpus_questions):
	corpus_questions = corpus_questions[:sample]

	logging.info(f"🔍 Found {len(corpus_questions)} questions for {corpus_name}")

	# Prepare queries and gold answers
	all_queries = [q["question"] for q in corpus_questions]
	gold_answers = [[q['answer']] for q in corpus_questions]

	# Configure HippoRAG
	config = BaseConfig(
	save_dir=os.path.join(base_dir, corpus_name),
	llm_base_url=llm_base_url,
	llm_name=model_name,
	embedding_model_name=embed_model_path.split('/')[-1],
	force_index_from_scratch=True,
	force_openie_from_scratch=True,
	rerank_dspy_file_path="src/hipporag/prompts/dspy_prompts/filter_llama3.3-70B-Instruct.json",
	retrieval_top_k=5,
	linking_top_k=5,
	max_qa_steps=3,
	qa_top_k=5,
	graph_type="facts_and_sim_passage_node_unidirectional",
	embedding_batch_size=8,
	max_new_tokens=None,
	corpus_len=len(docs),
	openie_mode="online"
	)

	# Initialize HippoRAG
	hipporag = HippoRAG(global_config=config)

	# Index the corpus content
	hipporag.index(docs)
	logging.info(f"✅ Indexed corpus: {corpus_name}")

	# Process questions
	results = []

	queries_solutions, _, _, _, _ = hipporag.rag_qa(queries=all_queries, gold_docs=None, gold_answers=gold_answers)
	solutions = [query.to_dict() for query in queries_solutions]

	for question in corpus_questions:
	solution = next((sol for sol in solutions if sol['question'] == question['question']), None)
	if solution:
	results.append({
	"id": question["id"],
	"question": question["question"],
	"source": corpus_name,
	"context": solution.get("docs", ""),
	"evidence": question.get("evidence", ""),
	"question_type": question.get("question_type", ""),
	"generated_answer": solution.get("answer", ""),
	"gold_answer": question.get("answer", "")
	})

	# Save results
	with open(output_path, "w", encoding="utf-8") as f:
	json.dump(results, f, indent=2, ensure_ascii=False)

	logging.info(f"💾 Saved {len(results)} predictions to: {output_path}")

	def main():
	# Define subset paths
	SUBSET_PATHS = {
	"medical": {
	"corpus": "./Datasets/Corpus/medical.json",
	"questions": "./Datasets/Questions/medical_questions.json"
	},
	"novel": {
	"corpus": "./Datasets/Corpus/novel.json",
	"questions": "./Datasets/Questions/novel_questions.json"
	}
	}

	parser = argparse.ArgumentParser(description="HippoRAG: Process Corpora and Answer Questions")

	# Core arguments
	parser.add_argument("--subset", required=True, choices=["medical", "novel"],
	help="Subset to process (medical or novel)")
	parser.add_argument("--base_dir", default="./hipporag2_workspace",
	help="Base working directory for HippoRAG")

	# Model configuration
	parser.add_argument("--model_name", default="gpt-4o-mini",
	help="LLM model identifier")
	parser.add_argument("--embed_model_path", default="/home/xzs/data/model/contriever",
	help="Path to embedding model directory")
	parser.add_argument("--sample", type=int, default=None,
	help="Number of questions to sample per corpus")

	# API configuration
	parser.add_argument("--llm_base_url", default="https://api.openai.com/v1",
	help="Base URL for LLM API")
	parser.add_argument("--llm_api_key", default="",
	help="API key for LLM service (can also use OPENAI_API_KEY environment variable)")

	args = parser.parse_args()

	logging.info(f"🚀 Starting HippoRAG processing for subset: {args.subset}")

	# Validate subset
	if args.subset not in SUBSET_PATHS:
	logging.error(f"❌ Invalid subset: {args.subset}. Valid options: {list(SUBSET_PATHS.keys())}")
	return

	# Get file paths for this subset
	corpus_path = SUBSET_PATHS[args.subset]["corpus"]
	questions_path = SUBSET_PATHS[args.subset]["questions"]

	# Handle API key security
	api_key = args.llm_api_key or os.getenv("OPENAI_API_KEY", "")
	if not api_key:
	logging.warning("⚠️ No API key provided! Requests may fail.")

	# Create workspace directory
	os.makedirs(args.base_dir, exist_ok=True)

	# Load corpus data
	try:
	with open(corpus_path, "r", encoding="utf-8") as f:
	corpus_data = json.load(f)
	logging.info(f"📖 Loaded corpus with {len(corpus_data)} documents from {corpus_path}")
	except Exception as e:
	logging.error(f"❌ Failed to load corpus: {e}")
	return

	# Sample corpus data if requested
	if args.sample:
	corpus_data = corpus_data[:1]

	# Load question data
	try:
	with open(questions_path, "r", encoding="utf-8") as f:
	question_data = json.load(f)
	grouped_questions = group_questions_by_source(question_data)
	logging.info(f"❓ Loaded questions with {len(question_data)} entries from {questions_path}")
	except Exception as e:
	logging.error(f"❌ Failed to load questions: {e}")
	return

	# Process each corpus in the subset
	for item in corpus_data:
	corpus_name = item["corpus_name"]
	context = item["context"]
	process_corpus(
	corpus_name=corpus_name,
	context=context,
	base_dir=args.base_dir,
	model_name=args.model_name,
	embed_model_path=args.embed_model_path,
	llm_base_url=args.llm_base_url,
	llm_api_key=api_key,
	questions=grouped_questions,
	sample=args.sample
	)

	if __name__ == "__main__":
	main()