English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original
智柴网 中文原文

Self-Graph Reasoning: How Open-Source LLMs Beat GPT-4o on Logic Tasks

Forum topic · 小凯 · 2026-02-21

Summary

This article explains Self-Graph Reasoning (SGR), a new technique introduced by researchers from the University of Tokyo and collaborators in the paper "From Chains to Graphs: Self-Structured Reasoning for General-Domain LLMs" (arXiv:2601.03597). SGR replaces linear Chain-of-Thought prompting with a graph-structured reasoning process in which the model itself generates branching nodes (steps) and edges (logical dependencies) before producing an answer. Trained with LoRA on about 10K GPT-4o-generated reasoning graphs, SGR-LLaMA-3.3-70B delivers a 17.74% average improvement over its base model and reaches 57.50% on the Alice-in-Wonderland (AIW) logic benchmark, compared with 32.50% for GPT-4o and only 19.50% for the baseline LLaMA. The model also improves on MedQA and MathQA, runs at roughly 42% of GPT-4o CoT cost, and offers traceable, interpretable reasoning. The piece covers the training pipeline, a worked example with the Alice brothers/sisters puzzle, benchmark results, and open questions about scaling.

From Chains to Graphs: Self-Graph Reasoning Explained

This guide breaks down Self-Graph Reasoning (SGR), a new technique from the University of Tokyo and collaborators that lets an open-source LLM outperform GPT-4o on logic reasoning. The original paper is *From Chains to Graphs: Self-Structured Reasoning for General-Domain LLMs* (arXiv:2601.03597), with code released at https://github.com/Yingjian-Chen/SGR-Self-Graph-Reasoning.

Key points

  • The problem with linear CoT. Chain-of-Thought prompting forces the model to reason in a single linear sequence. A small mistake early on (the paper calls this "logical drift") can cascade into an incorrect final answer, even when the visible reasoning looks plausible.
  • SGR's core idea. Instead of a chain, the model generates a reasoning graph: branching nodes for intermediate steps, directed edges for logical dependencies, and explicit aggregation nodes that combine branches into the final answer. Reasoning becomes nonlinear and parallelizable, closer to System-2 thinking.
  • Training pipeline.
    • 1. GPT-4o acts as a teacher, sampled at temperature 0.9 to produce k candidate reasoning graphs per question. 2. Only graphs whose reasoning actually yields the correct answer are kept, producing ~10K high-quality samples. 3. LLaMA-3.3-70B is fine-tuned with LoRA to minimize cross-entropy on both the graph structure and the final answer; every node must be justified by its parents.
  • Headline numbers.
  • Average gain over the base model: +17.74%.
  • AIW benchmark: SGR-LLaMA 57.50% vs. GPT-4o 32.50% (Claude-3.5-Haiku scored 2.50%).
  • LogiQA: 69.91% (vs. GPT-4o 74.01%, base LLaMA 64.01%).
  • AR-LSAT: 31.74% (essentially tied with GPT-4o at 31.75%).
  • MedQA: 78.81% (vs. GPT-4o 88.29%, base LLaMA 63.55%).
  • MathQA: 67.17% (vs. GPT-4o 81.05%, base LLaMA 38.09%).
  • Overall average: SGR-LLaMA 61.03% vs. GPT-4o 61.52% — parity, achieved with an open-source 70B model.
  • Cost and efficiency. On LogiQA, SGR runs at roughly $33.6, about 42% of GPT-4o CoT cost (~$80).
  • Worked example — the Alice puzzle. "Alice has 3 brothers and 2 sisters. How many sisters does Alice's brother have?" Correct answer: 3 (the 2 sisters + Alice herself). Linear CoT often fails this perspective-shift; the SGR-generated graph explicitly creates a *perspective-switch node* and an *aggregation node* to combine counts, resolving the trap.
  • Why it works.
  • Many-to-one dependencies: real reasoning often merges several premises; graphs capture this naturally.
  • Explicit parent–child justification tightly couples reasoning and answer, reducing logical drift.
  • Parallel branches allow the model to explore alternatives and backtrack.
  • Errors become traceable — each node is inspectable.
  • Limitations noted by the authors. Training set is only ~10K samples; experiments cover a single 70B model; 8B-scale models do not yet benefit much from SGR and need stronger base reasoning.
  • Open questions for the community. Will graph-structured reasoning become a default inference-time template? Can it be combined with retrieval, tools, or reinforcement learning? How do we scale it without exploding compute?

    • Resources

  • Paper: https://arxiv.org/abs/2601.03597
  • Code: https://github.com/Yingjian-Chen/SGR-Self-Graph-Reasoning
  • AIW benchmark: https://arxiv.org/abs/2406.02061
  • Related work on Graph-of-Thoughts and System-2-style reasoning is referenced in the original article.

Tags

#self-graph-reasoning#llm#chain-of-thought#logical-reasoning#llama#gpt-4o#open-source-ai#graph-of-thoughts

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/177168534