Function process_single_sample

tasks/AutoMem/code/eval.py:230–350

Process a single sample and return results.

(sample_data: tuple, model: str, backend: str, retrieve_k: int,
                         temperature_c5: float, sglang_host: str, sglang_port: int,
                         memories_dir: str, allow_categories: list)

    return logger

def process_single_sample(sample_data: tuple, model: str, backend: str, retrieve_k: int,
                         temperature_c5: float, sglang_host: str, sglang_port: int,
                         memories_dir: str, allow_categories: list) -> dict:
    """Process a single sample and return results."""
    sample_idx, sample = sample_data

    # Create agent for this sample
    agent = advancedMemAgent(model, backend, retrieve_k, temperature_c5, sglang_host, sglang_port)

    # Create memory cache filename based on sample index
    memory_cache_file = os.path.join(
        memories_dir,
        f"memory_cache_sample_{sample_idx}.pkl"
    )
    retriever_cache_file = os.path.join(
        memories_dir,
        f"retriever_cache_sample_{sample_idx}.pkl"
    )
    retriever_cache_embeddings_file = os.path.join(
        memories_dir,
        f"retriever_cache_embeddings_sample_{sample_idx}.npy"
    )

    # Check if cached memories exist
    if os.path.exists(memory_cache_file):
        print(f"[Sample {sample_idx}] Loading cached memories")
        with open(memory_cache_file, 'rb') as f:
            cached_memories = pickle.load(f)
        # Restore memories to agent
        agent.memory_system.memories = cached_memories
        if os.path.exists(retriever_cache_file):
            print(f"[Sample {sample_idx}] Found retriever cache files")
            agent.memory_system.retriever = agent.memory_system.retriever.load(
                retriever_cache_file, retriever_cache_embeddings_file
            )
        else:
            print(f"[Sample {sample_idx}] No retriever cache found, loading from memory")
            agent.memory_system.retriever = agent.memory_system.retriever.load_from_local_memory(
                cached_memories,
                'all-MiniLM-L6-v2'
            )
        print(f"[Sample {sample_idx}] Successfully loaded {len(cached_memories)} memories")
    else:
        print(f"[Sample {sample_idx}] No cached memories found. Creating new memories.")

        for _, turns in sample.conversation.sessions.items():
            for turn in turns.turns:
                turn_datatime = turns.date_time
                conversation_tmp = "Speaker " + turn.speaker + "says : " + turn.text
                agent.add_memory(conversation_tmp, time=turn_datatime)

        memories_to_cache = agent.memory_system.memories
        with open(memory_cache_file, 'wb') as f:
            pickle.dump(memories_to_cache, f)
        agent.memory_system.retriever.save(retriever_cache_file, retriever_cache_embeddings_file)
        print(f"[Sample {sample_idx}] Successfully cached {len(memories_to_cache)} memories")

    # Process questions for this sample