00:00:00

Share Your Feedback 🏝️

LLM as Compilers

LLM as Compilers

MinWoo(Daniel) Park | Tech Blog

Read more
Previous: Inferece-optimal MoE Next: Hyper CLOVA X

LLM as Compilers

  • Related Project: Private
  • Category: Paper Review
  • Date: 2024-04-04

Language Models as Compilers: Simulating Pseudocode Execution Improves Algorithmic Reasoning in Language Models

  • url: https://arxiv.org/abs/2404.02575
  • pdf: https://arxiv.org/pdf/2404.02575
  • abstract: Algorithmic reasoning refers to the ability to understand the complex patterns behind the problem and decompose them into a sequence of reasoning steps towards the solution. Such nature of algorithmic reasoning makes it a challenge for large language models (LLMs), even though they have demonstrated promising performance in other reasoning tasks. Within this context, some recent studies use programming languages (e.g., Python) to express the necessary logic for solving a given instance/question (e.g., Program-of-Thought) as inspired by their strict and precise syntaxes. However, it is non-trivial to write an executable code that expresses the correct logic on the fly within a single inference call. Also, the code generated specifically for an instance cannot be reused for others, even if they are from the same task and might require identical logic to solve. This paper presents Think-and-Execute, a novel framework that decomposes the reasoning process of language models into two steps. (1) In Think, we discover a task-level logic that is shared across all instances for solving a given task and then express the logic with pseudocode; (2) In Execute, we further tailor the generated pseudocode to each instance and simulate the execution of the code. With extensive experiments on seven algorithmic reasoning tasks, we demonstrate the effectiveness of Think-and-Execute. Our approach better improves LMs’ reasoning compared to several strong baselines performing instance-specific reasoning (e.g., CoT and PoT), suggesting the helpfulness of discovering task-level logic. Also, we show that compared to natural language, pseudocode can better guide the reasoning of LMs, even though they are trained to follow natural language instructions.

TL;DR


  1. THINK-AND-EXECUTE는 문제 해결에 필요한 공통 논리를 찾아 이를 구체적인 예제에 적용하는 프레임워크이다.
  2. 이 프레임워크는 LLM이 메타 프롬프트를 통해 문제의 공통 논리를 분석하고 이를 의사코드(pseudocode)로 변환한 후, 실행 단계에서 해당 논리를 따라 예측을 수행한다.
  3. THINK-AND-EXECUTE는 알고리즘 문제 해결 성능을 향상시키며, 자연어 대신 의사코드를 사용하여 문제 해결 논리를 표현하는 것이 더 효과적임을 입증한다.

1. 서론

대규모 언어모델(LLM)의 인퍼런스 능력은 문제의 논리적 구조를 분석하고, 이를 일련의 인퍼런스 단계로 실현하여 최종 답을 도출하는 것을 포함한다. (Zhou et al., 2022a;b; Hao et al., 2023) 특히, 알고리즘적 인퍼런스은 복잡한 인퍼런스 패턴을 자세히 검토하고 이를 긴 인퍼런스 단계로 번역해야 하기 때문에 LLM에게 오래된 챌린지이다. (Suzgun et al., 2022; Valmeekam et al., 2022; Pan et al., 2023)

기존 연구들은 주로 두 가지 방향으로 LLM의 인퍼런스 능력을 향상시키려 했다. 첫 번째 방향은 자연어 설명(Chain-of-Thought)이나 코드 조각(Program-of-Thought)을 생성하여 인퍼런스 실행 단계를 강화하는 것이다. 그러나 이런 접근 방식은 전용 계획 단계 없이 실시간으로 단계별 인퍼런스를 수행하며, 이는 LLM이 단일 인퍼런스 호출 내에서 논리를 분석하고 실행해야 함을 의미한다. 이는 모델의 표현력을 제한하며, 비슷한 문제에 직면했을 때 이전에 이해한 논리를 재사용할 수 없게 만든다.

두 번째 방향은 LLM을 통해 자연어로 기술된 계획을 명시적으로 생성하는 것이다. 그러나 자연어는 문제의 논리를 설명하는 최적의 매체가 아닐 수 있으며, 단일 인스턴스를 관찰하여 계획을 생성하는 것은 유사한 인스턴스 간의 핵심 인퍼런스 패턴을 분석하는 데 방해가 된다.

  • THINK-AND-EXECUTE

    이를 해결하기 위해, THINK-AND-EXECUTE라는 알고리즘 프레임워크를 도입했다. 이 프레임워크는 주어진 작업의 공통된 인퍼런스 패턴을 반영하는 논리를 발견하고 이를 각 인스턴스에 맞춰 적용한다. THINK-AND-EXECUTE는 세 가지 단계로 구성된다. 먼저 LLM이 몇 가지 예제 질문을 제공받아 작업의 공통 인퍼런스 패턴에 대해 생각하도록 요청한다. 그 후 LLM은 논리의 자연어 설명을 의사코드로 번역한다. 마지막으로, 실행 단계에서는 LLM이 의사코드의 논리를 따라 예측을 수행한다.

  • 데이터셋과 벤치마크

    Big-Bench Hard(Suzgun et al., 2022)의 7개 알고리즘 인퍼런스 작업을 사용하여 THINK-AND-EXECUTE의 효과를 입증했다. 이 작업들은 단계별 인퍼런스 능력을 측정하도록 설계되었으며, 0-shot 설정에서 평가되었다.


2. 방법

2.1. THINK 단계

  • 메타 프롬프트 구성

    Instructor LM(I)는 주어진 작업(t)의 기본 논리를 발견하고 이를 의사코드로 설명하는 프롬프트를 생성한다. 이를 위해 다른 작업의 예제를 메타 프롬프트로 제공하여 I가 목표 작업의 분석을 생성하도록 유도한다.

  • 대상 작업 분석

    메타 프롬프트를 받은 I는 대상 작업을 해결하는 데 필요한 핵심 인퍼런스 논리를 포함한 분석을 생성한다. 이는 모든 인스턴스에 공통된 인퍼런스 과정을 강조하여 작업 수준의 프롬프트를 만들 수 있도록 한다.

  • 의사코드 프롬프트 생성

    분석을 기반으로 I는 의사코드 형태의 프롬프트를 작성한다. 의사코드는 작업의 논리를 효율적으로 설명하고, 실행 중에 필요한 인퍼런스 단계를 명시할 수 있다.


2.2. EXECUTE 단계

Reasoner LM(R)은 의사코드 프롬프트를 통해 주어진 인스턴스에 맞춰 논리를 적용한다. R은 중간 실행 결과를 생성하며, 이는 변수 상태를 추적하고 최종 답을 도출하는 데 유리하다.

function solution()
    vina := true
    helene := NOT vina
    kandi := vina
    jamey := NOT kandi
    ka := NOT jamey
    if ka then
        return "Yes"
    else
        return "No"
end function

이런 방식으로 R은 의사코드를 컴파일러처럼 실행하여 최종 출력을 예측한다.


3. 실험

THINK-AND-EXECUTE는 CoT와 PoT와 같은 우수한 baseline을 능가하는 성능을 보였다. 특히, 의사코드를 사용한 계획이 자연어 계획보다 더 우수한 성능을 발휘하였다. 이는 의사코드가 문제 해결에 필요한 논리를 더 잘 설명할 수 있기 때문이다.


4. 수학적 논리

4.1. 논리 발견 단계

Instructor LM(I)는 주어진 문제의 예제를 분석하여 공통된 논리를 발견한다. 이 과정에서 삼단 논법을 사용하여 논리를 체계적으로 분석한다.

  1. 전제 1: 주어진 문제에는 공통된 인퍼런스 패턴이 존재한다.
  2. 전제 2: 예제 문제를 분석하여 이 패턴을 발견할 수 있다.
  3. 결론: 발견된 패턴을 바탕으로 의사코드를 생성할 수 있다.

4.2. 의사코드 생성

의사코드 생성을 통해 문제 해결 논리를 구조화한다. 이는 반복문(for loop)과 조건문(if-else)을 사용하여 논리를 체계적으로 표현한다.

function analyze_task(task)
  statements := task.split('\n')
  truth_dict := {}
  for statement in statements
      person1, action, person2 := parse_statement(statement)
      if action == 'says' then
          truth_dict[person1] := NOT truth_dict[person2]
      else
          truth_dict[person1] := truth_dict[person2]
  return truth_dict
end function

4.3 의사코드 실행

Reasoner LM(R)은 생성된 의사코드를 실행하여 각 인스턴스의 논리를 예측한다. 이 과정에서 중간 출력값을 추적하여 변수 상태를 유지하고, 최종 답을 도출한다.

function execute_task(task)
  truth_dict := analyze_task(task)
  final_answer := truth_dict['ka']
  return "Yes" if final_answer else "No"
end function


5. 결론

THINK-AND-EXECUTE는 문제 해결에 필요한 공통 논리를 발견하고 이를 구체적인 예제에 적용하는 효과적인 프레임워크이다. 이를 통해 알고리즘 문제 해결 성능을 크게 향상시킬 수 있으며, 자연어 대신 의사코드를 사용하여 문제 해결 논리를 더 효율적으로 표현할 수 있음을 보였다.

Previous: Inferece-optimal MoE Next: Hyper CLOVA X

post contain ""

    No matching posts found containing ""