
Date:2026-07-25
Who this is for: AI, NLP, machine learning direction graduate students; prepare to reproduce method paper, write reading note, do ablation Or a newcomer to select topics from the limitation of the development of the paper; I hope to upgrade "understand the paper" to an engineering-oriented reader who "can be dismantled, reproduced, and questioned"
search date:2026-07-25
Abstract
Method papers are the easiest type to "read the surface and miss the key" in AI research training. You may have read the abstract and know that the author proposes a new module, a new training goal or a new reasoning process; or may remember a few high score results in the experimental table. But if you can't answer four questions, this paper has not actually been disassembled: what task it defines, what the core assumption is, what modules are composed, and how the training goal turns the hypothesis into an optimized signal.
This article gives a set of dismantling frameworks for reproduction and topic selection. It does not treat the paper as a narrative, but as a run, replaceable, rebuttal research system: input, output, constraints, modules, lost, data flow, training process, reasoning process, and chain of evidence. We will use Transformer, LoRA, QLoRA, DPO, Mamba, DeepSeek-R1, Kimi K2 Representative papers and technical reports are used as references, explaining how to restore the real structure of the method from the text, formulas, algorithm boxes, experimental settings and open source code. The key is not to memorize the conclusion of the paper, but to train a scientific research action: split a method paper into the smallest unit that can be reproduced, and then find its own follow-up idea from these units.
Contents
- Why Method Papers Can't Read only "Method Introduction"
- The four-layer skeleton of the methodology paper
- Step 1: Rewrite the task definition
- Step 2: Find out the core assumptions
- Step 3: Draw the module boundaries and data flow
- Step 4: Dismantling training goals and optimization process
- A reading guide to the key papers
- Critical Essay Intensive Reading Examples
- Method / Experimental Comparison Table
- Re-reality operation: from pseudocode to minimum runnable version
- Common misconceptions
- Research questions for graduate students
- Summary
- References
Why Method Papers Can't Read only "Method Introduction"
When many graduate students read Method papers, they will naturally focus on the Method section: what structure the author proposes, what the formula is, and what modules are in the diagram, and the algorithm box is written in several steps. This is of course important, but the introduction of the read-only Method will create a serious illusion: you think that the contribution of the paper in the "new module", in fact, the contribution may be in the task definition, training data construction, loss function weight, at inference time search strategy, baseline Select or Experimental Protocol.
Method papers usually have two sets of structures. The first set is the structure written by the author: Introduction talks about problems, Related Work talks about background, Method talks about models, and Experiments talks about results. The second set is to study the structure of the system: the task definition determines the input and output, assuming why this Method may be valid, the module determines how the information flows, the training target determines what the model is rewarded, and the evaluation protocol determines whether the claim is supported by evidence. When intensively reading Method papers, you need to restore the second set of structures from the first set of structures.
This ability is especially important in 2025-2026. The current AI method papers are becoming more and more like system engineering: a large-model technical report may contain both pre-training data, MoE architecture, long context, reinforcement learning, tool call data and security evaluation; Papers may change data, rewards, sampling, and validators at the same time; an Efficient Training paper may tie video memory optimization, quantization, low rank adaptation and experimental configuration together. If you only ask "what module the author proposes", it is easy to mix multiple variables into a contribution.
More practically, the reproduction failure is often not because you can't understand the formula, but because you haven't disassembled the system boundary: whether the author is fixed backbone, whether it uses additional data, is lost is the main target or auxiliary Objective, the training is divided into several stages, whether the at inference time uses a higher computer budget, and whether the baseline shares the same data and adjust the budget. The purpose of the dismantling method paper is to explicitly make these problems before starting.

The four-layer skeleton of the methodology paper
To dismantle a method paper, you can start from four layers.
The first floor is task definition. It answers "what the paper solves the problem". Don't just copy the task name here, but write it as input, output, constraint and success criteria. For example, Machine Translation is not only "translation", but also includes input language, output language, training corpus, decoding conditions and evaluation metrics; Preference Optimization It is not just "making the model more in line with the preferences", but also includes the source of the preference pair, whether the Reference Model is fixed, whether the Reward Model is needed, and whether the optimization goal is stable.
The second floor is core assumption. Method papers must imply a hypothesis: some inductive bias, training signals, data organization, or reasoning can lead to better generalization. One of the key assumptions of Transformer is that attention can replace loops and convolutions to model sequence dependencies; the key hypothesis of LoRA is that there is a low intrinsic rank for large-model adaptation updates; DPO The key assumption is that preference learning can be rewritten as a direct optimization strategy without explicitly training the Reward Model; the key hypothesis of Mamba is that the Selective State Space mechanism can take into account the linear complexity and content selection ability in long-sequence modeling. You have to write these assumptions in your own words, because they decide what to measure in the subsequent ablation.
The third layer is Module Boundary. The module in the method paper is not a few boxes on the figure, but which parameters are trained, which parameters are frozen, which information flows are micro, which steps exist only during training, and which steps only exist in at inference time. Once the module boundary is wrong, the reproduction will become "it seems to have implemented the paper, but the actual implementation is another system".
The fourth floor is training target. The training goal is not formula decoration, but the paper that turns the assumptions into optimization pressure. A method may appear to be architectural innovation, and what really works is auxiliary loss; it may also seem to be RL innovation, and what is really sensitive is Reward Normalization, KL constraints, sample number and data filtering. When dismantling the training target, ask the main loss, auxiliary loss, regular term, constraints, sampling strategy and training stage what is optimized.
These four layers can form a minimum dismantling table:
| dismantle layer | The question you want to rewrite | final product |
|---|---|---|
| task definition | What is the input, what is the output, what are the constraints, and what are the success criteria | Formal Problem Statement |
| core assumption | The author thinks which mechanism will improve which failure mode | 1-3 falsified hypothesis |
| Module Boundary | Which components produce, transform, filter or verify information | Module diagram and data flow diagram |
| training target | What is the behavior of each loss, reward or object | Objective tables and training phase tables |
Step 1: Rewrite the task definition
When dismantling a method paper, the first step is not to look at the formula, but to rewrite the task definition. A good task definition contains at least five elements: input space, output space, training signal, constraints and evaluation criteria.
Take Transformer as an example, if you only say "do machine translation", the granularity is too thick. A more effective way to write is: given the source language token sequence, the model generates the token sequence of the target language through the encoder-decoder attention; training uses the next-token maximum on the parallel corpus likelihood; reasoning uses autoregressive decoding; evaluation uses machine translation metrics and speed/parallel analysis. After writing in this way, you will immediately see that the key to the paper is not only "attention", but also "whether you can still maintain the quality of translation after removing the loop structure, and at the same time improve the training parallelism".
In DPO as an example, the task definition cannot be written as "Alignment Large Model". It's more specific: given prompt and paired preference responses, optimize a policy so that it is more biased towards the reaction policy and away from the rejected response; it tries to replace RLHF Training Reward Model first, and then doing the multi-stage process of Policy Optimization. After rewriting in this way, the follow-up question will be clear: how to choose the reference model, where the preference data comes from, whether the quality difference of chosen/rejected is enough, and how hyperparameters such as beta change the behavior.
Taking Reasoning technical reports such as DeepSeek-R1 as an example, the task definition also distinguishes between "training tasks" and "display tasks". Papers may demonstrate abilities in mathematics, code and general Q&A, but the training involves stages such as Cold-Start Data, Reinforcement Learning, Rejection Sampling, Distinlation, etc. You can't put the Reasoning Ability on the final Benchmark It is directly equivalent to the contribution of a certain module, and it is necessary to track the behavior-oriented behavior of each training stage: format stability, long-chain reasoning, readability, correctness of the answer, alignment style or small model distillation.
You can use this checklist when rewriting a task definition:
- Whether the input is explicit to the data format, context length, modal and sampling sources.
- Whether the output is explicit to the generated object, predicted tag, action sequence, or search result.
- Whether the training signal is clear to the supervised label, preference pair, REWARD, SELF-PLAY feedback or synthetic data.
- Constraints include calculation budget, parameter freezing, data availability, inter-AT Inference time and security restrictions.
- Whether the evaluation criteria really corresponds to the problem that the paper claims to solve.
If these five items are not clearly written, do not rush to read the formula. Because formulas only make sense within a certain task definition.
Step 2: Find out the core assumptions
The assumptions of Method papers are generally not written with "Hypothesis" as titles. It is hidden in the pain points of the Introduction, the design selection of the Method, and the control group of the Ablation. The way to find the Hypothesis is to rewrite the author's contribution sentence into a cause and effect sentence:
"If we introduce X, then Y will improve because Z."
For example, LoRA can be rewritten as: if only the low rank matrix is trained to approximate the weight update, then the downstream task can still be efficiently adapted to the subject of the pretrained model, because the weight change during the adaptation process has a low internal rank. This hypothesis directly derives the reproducing experiment: how the different ranks perform, which layers need LoRA, how the amount of parameters and performance are weighed, and whether the low rank update is true on different tasks.
QLoRA can be rewritten as: if you use 4-bit to quantify the weight of the freezed large model, and train a small number of parameters through low rank adaptation, you can Fine-tune the large model on the limited video memory, and at the same time, try to preserve the full precision. fine-tuning effect. What I want to check here is not the sentence "4-bit is very saving video memory", but how the quantization format, paged optimizer, rank, data quality and task scale can affect the results together.
Mamba can be rewritten as: If the State Space Model has a content-dependent selection mechanism, it can retain the advantages of linear time inference in long sequences, and at the same time improve the problem of traditional SSM insufficient content selection of discrete token content. The problem with this assumption is that the advantages come from the Selective Scan, the overall architecture, the training scale, or the setting of the comparison object.
DPO can be rewritten as: if the preference learning goal can be derived from Reward Modeling as a direct classification Objective, then the policy can learn the preference direction without explicit RL training. This hypothesis is to compare with the same preference data and reference settings with RLHF, PPO, IPO, KTO and other methods, instead of just looking at the final win rate.
The key to dismantling is "falsified". The sentence "our method is more effective" is not a hypothesis; a sentence "module x reduces the z error through the y mechanism in the long dependency scenario" can have the shape that can be tested experimentally. When you read, you can use three-color annotations:
- Green: The assumptions that have been clearly verified by the paper.
- Yellow: The paper is partially verified, but the experimental settings are not enough to isolate the variables.
- Red: The paper claims the effect, but there is no direct evidence or only indirect results.
This annotation will naturally become your follow-up idea source. The yellow and red areas are often more suitable for graduate students to continue doing than the highlights that the author emphasizes.
Step 3: Draw the module boundaries and data flow
The diagrams in the method paper are usually "storytelling pictures", not "reproduction pictures". Reproduction requires you to redraw a more simple system diagram: where the data comes from, which trainable modules go through, which intermediate variables are generated, where the loss is returned to, and which modules are still in at inference time.
You can divide the modules into six categories.
Input processing module: tokenizer, vision encoder, retriever, prompt template, data filter, enhancer. Many papers seem to be model innovations, and the actual sensitive points are in the input structure. For example, in Instruction Tuning and Preference Optimization, both Prompt format, System Message, Response cleaning, and data mixing ratios change the result.
body model module: Encoder, Decoder, Attention Block, SSM Block, MoE Layer, Adapter, Router, Memory Bank, Tool Policy. Here, it is necessary to mark which parameters are initialized in the pre-training model, which are trained from zero and which are frozen.
Intermediate representation module: Retrieved documents, latent state, scratchpad, chain-of-thought, program, tool call, reward feature, hidden activation. Whether the intermediate representation is visible, whether it can be supervised, and whether it is filtered will affect the reproduction and interpretation.
training signal module: Label, Preference Pair, Reward Model, Verifier, Self-Consistency Vote, Teacher Model, Synthetic Data Generator. The training signal module is often written by the paper very short, but it determines the upper limit.
Optimization and scheduling module: Optimizer, Learning Rate Schedule, Batching, Gradient Checkpointing, Precision, Seed, Stage Transition. Engineering implementation is not an appendage of the paper, and is often the premise of the effectiveness of the method in the large-model method.
Inference strategy module: greedy decoding, beam search, or sampling, along with temperature, top-p, reranking, search, tool-based verification, majority voting, KV caching, or speculative decoding. In many papers on reasoning, agents, and code, differences in performance come from the compute used at inference time rather than the architecture used in training.
When drawing, it is recommended to write three types of labels next to each module: trainable / frozen / external, train-only / inference-only / both, claimed contribution / support component / evaluation component. These three tags can help you quickly identify core variables and auxiliary variables in the paper.
Step 4: Dismantling training goals and optimization process
The training goal is the most worthy of slow reading of method papers. Formulas don't need you to remember at a glance, but you can answer what it rewards, what punishes, and what you restrain.
For supervised fine-tuning, the main target is usually token-level maximum likelihood. But that doesn't mean all SFT papers are the same. Data sources, sample weights, Sequence Packing, Loss Mask, Assistant-Only Loss, Multi-Turn format, and abstention samples all change the training pressure.
For Preference Optimization, to dismantle Chosen/Rejected pair, Reference Model, KL or implicit KL, Temperature / Beta, Response Length deviation and preference data noise. There is an important research question behind the formula of DPO: it turns preference learning into a direct goal, but whether this goal is enough to deal with multiple rounds of preference, process preference, Verifier feedback and external Prompt, which requires specific experimental support.
For RL Reasoning, the verifiability and sampling process to dismantle Reward . Mathematics and code tasks often have relatively clear answer validators, and open tasks are much more difficult. Papers like DeepSeek-R1 remind us that the training of Reasoning ability is not a single loss, but a combination of data, cold start, RL, distillation and format control. When reading, write the goals of each stage into tables, rather than merging them into "used RL".
For architecture papers, loss may seem ordinary, but the training process is still critical. The original Transformer paper uses the Sequence-to-Sequence translation task to verify the architecture; Mamba papers usually validate the architecture hypothesis in language modeling, long-sequence tasks, and various scale settings. You have to ask: If the loss does not change, why the structural change will bring benefits; if the data and scale have also changed, whether the experiment can isolate the architecture contribution.
Dismantling the training target can use this table:
| Project | Reading questions | How to reproduce the record |
|---|---|---|
| main goal | What is the final optimized loss / reward | Write formula and code entry |
| Assistant | Is there auxilary loss, kl, entropy, router loss | Weight and start-stop phases |
| data sampling | How each batch constitutes | Record data mixing ratio and filtering rules |
| parameter update | Which parameters are updated | Save Trainable Parameter List |
| training stage | Whether multi-stage training | Separate CheckPoint for each stage |
| inference coupling | Whether the training goal depends on the inference strategy | Fixed decoding/search configuration |
A reading guide to the key papers
The following is not a "must read complete works", but a route to train dismantling ability. Each type of paper is suitable for practicing different dismantling methods.
| Type of paper | Representative essay | What to practice |
|---|---|---|
| Architectural approach | Transformer、Mamba | Demolition contributions from module boundaries and complexity assumptions |
| Efficient parameters fine-tuning | LoRA、QLoRA | Contribution from freezing parameters, low rank hypothesis and video memory budget demolition |
| preference optimization | RLHF series, DPO | Dismantling training signals from Reward / Preference Objective |
| Reasoning training | DeepSeek-R1 and other Reasoning technical reports | Demolition system from multi-stage training and verifiable Rewards |
| Model Technical Report | Kimi K2 et al. MoE / Agentic LLM reports | Evidence of dismantling evidence from architecture, data, post-training, evaluation and code |
| reproduction specification | NeurIPS、ICLR、AAAI、ACL checklist | Information to be provided in the inference of the paper from the experimental disclosure requirements |
The focus of this route is horizontal comparison. Don't read each paper in isolation, but ask: it changes the task definition, module, object, data, or reasoning budget. Fractions on the same BenchMark are interpreted only if these variables are comparable.
Critical Essay Intensive Reading Examples
Transformer: first dismantle the task, then dismantle the architecture
Transformer is most easily read as "Attention is All You Need, so the core is self-attention". This sentence is true, but there are three levels to be dismantled during intensive reading.
First, the task background is Sequence Transduction, and the original paper mainly shows the effect through machine translation experiments. Second, the core hypothesis is that the Attention mechanism can replace the Recurrent/Convolutional structure and improve training efficiency through parallelization. Third, the modules include Multi-head attention, position-wise feed-forward network, positional encoding, resume connection, layer normalization, encoder-decoder attention, and autoregressive decoder. Fourth, the training goal is still the general sequence generation goal, so the architecture contribution should be judged by joint judgment with RNN/CNN baseline, training cost and translation quality.
When reappearing, you don't need to rewrite a modern large model from the start. The better training is to implement the Minimal Transformer with a small-scale translation or language modeling task, and then turn off the positional item by item Encoding, multi-head, feed-forward width, resumedual path, observe Failure Mode. This is more understandable than running the model directly.
LoRA / QLoRA: the module is small and there are many variables
LoRA's paper is very good to practice "parameter boundaries". Its core is not as simple as "adding two matrices", but freezing the pretrained weight, training only low rank updates, and inserting trainable parameters into a specific linear layer. When reading, record rank, alpha, insert layer position, dropout, task type, baseline, full fine-tuning control and training budget.
QLoRA illustrates how many engineering choices can contribute to the results in a methods paper. These include 4-bit quantization, NF4, double quantization, the paged optimizer, the LoRA adapter, dataset selection, and the instruction-tuning setup. Track memory feasibility and preservation of model quality separately. For the first, reproduce the peak GPU memory use at the reported batch size. For the second, run a controlled comparison with the same data, model, and evaluation.
DPO: the data and reference behind the formula
The appeal of DPO is to write preference optimization as a relatively concise goal. But when dismantling, it is necessary to start from the outside of the formula: how to construct the preference data, whether the choice/rejected is only one dimension, how to choose the reference policy, how to control the deviation degree, whether there is a length deviation or a change in safe behavior after training.
For graduate students, the good training of DPO is not to repeat the derivation, but to do a small experiment: fixed basic models and preference data, and compare SFT-only, DPO, different betas, different data noise ratios and different evaluation prompts. You will find that the effect of Preference Optimization comes not only from the objective function, but also from the learnability of the preference data.
Mamba: Complexity CLAIM to separate from the task CLAIM
Mamba-like papers are suitable for training "Don't mix efficiency and effect claims together". Linear time series modeling is complexity CLAIM, language modeling or long-context performance is the task claim, and Selective state space is a mechanism. The three are related, but not the same thing.
When reading, first dismantle the Selective Mechanism to solve the failure mode, and then see if the implementation requires a specific kernel or hardware optimization, and finally see if the experiment covers enough tasks and scales. When reappearing, you can run the sequence task verification function of the small model first, and then compare the throughput and video memory, and finally talk about the large-scale results.
DeepSeek-R1 / Kimi K2: Technical reports to be dismantled by phase
Since 2025, large-model technical reports have become increasingly important, but they are often not single-method papers. Reasoning reports such as DeepSeek-R1 involve reinforcement learning, cold start data, distillation and inference behavior; MoE / Agentic LLM reports such as Kimi K2 will cover the model structure, training system, and agentic at the same time. Data, tool calls and reviews.
When reading this report, the most dangerous practice is to attribute all the results to a name. A better approach is to dismantle the table according to the stage: what to solve in the pre-training stage, what to solve in the post-training stage, what is optimized in the RL stage, and what is the migration stage, and what additional inference settings are provided. For the code repository, model weights, Benchmark numbers and data details, the official page of the paper, arXiv version, the project home page and the current status of the repository shall prevail; the search date of this article is 2026-07-25, the content of the subsequent published version or repository may have changed, and it should be manually verified before publication.
Method / Experimental Comparison Table
After reading a method paper, it is recommended to force a comparison table. Below is a template.
| dimension | Methods of this paper | Key Baseline | Questions that need to be verified |
|---|---|---|---|
| task definition | Whether the input, output and constraints are changed | Is baseline the same task? | Is there a task definition drift |
| Data | Training data, filtering, synthesis, source of preference | Is the baseline the same as the data? | Whether additional invisible data is used |
| Model | New modules, freeze modules, external modules | baseline parameter quantity and architecture | Whether the quantity of parameters or calculation is fair |
| Objective | Main loss, auxiliary loss, reward | baseline objective | Are there more training signals? |
| training budget | steps、tokens、GPU、precision | baseline budget | Whether the budget is different |
| reasoning budget | sampling、search、tools、rerank | baseline reasoning settings | Have you used more test-time compute |
| Evidence | main table、ablation、analysis | control experiment | Whether to isolate core variables |
| reproducibility | code, data, configuration, SEED, log | baseline re-realism | Which one is missing will block the reproduction |
The role of this table is not to be well organized, but to expose incomparable items. As long as you find that "there are more data in this article", "Baseline has no equivalent parameters", "At Inference Time uses more samples", "Ablation does not turn off the core module separately", you should mark red in the reading notes.
Re-reality operation: from pseudocode to minimum runnable version
Repeat of method papers should not first pursue the complete scale. A more stable route is four steps.
The first step is to establish paper spec. Write task definitions, data, modules, Objectives, training phases, and inference settings into a page of YAML or Markdown. Don't write your thoughts, just write executable information. Where the paper is not clearly stated, it is marked as "waiting for manual verification" or "need to confirm from the code".
The second step, do minimal implementation. Only the core variables are implemented, and the code path is used to verify the code using small data, small models and short training steps. The goal is not to reproduce the paper score, but to confirm that Forward, loss, mask, gradient and log are all correct.
The third step, do single-factor ablation. Change only one variable at a time: turn off the module, change the Objective, change the rank, remove the Auxiliary loss, the fixed inference budget, and replace the data filtering rules. Each experiment should have SEED, CONFIG, COMMIT HASH, hardware information and log path.
Step 4, do claim-level reproduction. Go back to the paper master Claim to determine which claims are reproduced by you, which are only partially reproduced, and which cannot be reproduced. The reproduction report should be written by CLAIM, not by experimental number.
A practical reproduction directory can be organized like this:
reproduce_paper_x/
paper_spec.md
configs/
baseline.yaml
method.yaml
ablation_no_module_x.yaml
scripts/
train.py
evaluate.py
logs/
2026-07-25_seed1_method/
notes/
implementation_questions.md
reproduction_report.md
If the paper has official code, don't rush to change it. First run the official minimum demo, record environment, dependency version, data download, checkpoint, default parameters and log format. Then control your own experimental changes to the config layer. Many reproduction failures come from "start refactoring before running the original implementation".
Common misconceptions
Myth 1: Think of the paper map as a realization map. The paper diagram often omits data preprocessing, mask, loss weight, training stage and reasoning strategy. The data flow diagram must be redrawn before reappearing.
Myth 2: Treat the new name as a new contribution. A module has a new name, which does not mean that it has changed the core mechanism. Ask what variable it has compared to baseline.
Misunderstanding 3: Read only Main Result Table. The credibility of method papers is mainly in ABLATION, ANALYSIS, NEGATIVE CASE and experimental protocols, not only in the maximum table.
Misunderstanding 4: Ignore training data. Many differences in model capabilities in 2025-2026 come from data screening, synthesis, preference labeling, distillation and rejection sampling. Just looking at the model structure will make a misjudgment of contributions.
Misunderstanding 5: Take the test-time compute as a training method benefit. If the method uses more sampling, search, tool call, or Verifier in the AT Inference time, the inference budget must be recorded separately.
Misunderstanding 6: When reappearing, only the score is chased, and the mechanism is not pursued. Scores are close to not representing the same mechanism. You also need to check whether the intermediate behavior, failure cases, and ablation support the same interpretation.
Research questions for graduate students
- Methods of dissertation: Select a small field, systematically label the task definition, module, objective, data and reasoning budget of 30 papers, and analyze common incomparable variables.
- Objective sensitivity reproduction: Select DPO, IPO, KTO or GRPO related methods to compare the effects of hyperparameters, noise and reference model on the same preference data.
- Module Contribution Reassessment: Pick an architecture or Adapter paper, reproduce the experiment and add more stringent parameters, training tokens and reasoning budget control.
- Technical Report Evidence Audit: Compare the granularity of their disclosure data, training phases, evaluation and safety limitations with the 2025-2026 Grand Model Technical Report as an object.
- Dissertation to Code Consistency Check: Build tools or artificial protocols, check the inconsistency between paper formulas, algorithm boxes, configuration files and code implementations.
- Ablation Report Template Research: Propose a format-oriented reproduction report format, forcibly organize according to claim, variables and evidence, rather than according to the experimental running account.
None of these questions require the training of the large model at the beginning. The real research value is to dismantle the variables clearly, make the control clean, and write the conclusion that is falsifying.
Summary
The core of the dismantling Method paper is not to translate the Method section into Chinese, but to restore a paper to a research system. You have to rewrite the task definition first, then draw out the core assumptions, then draw the module boundaries and data flow, and finally dismantle the training target, training stage and reasoning settings. Only in this way will the claim in the paper become a reproducible, questionable and extensible object.
For graduate students, the most important training is not "how many essays", but can produce four files for each reading: task definition, hypothesis list, module diagram, and Objective table. After a month, you will find that you are no longer just following the dissertation narrative, but actively auditing the paper. The scientific research topic will also change from "I want to change a module" to "I know which hypothesis has not been fully verified, and how to design experiments to verify it".
References
Search date: 2026-07-25. The following links prefer the paper, the official page of the conference, arXiv, OpenReview, or the project homepage. Model weights, code repository status, benchmark numbers, dataset versions and meeting rules may change over time, and manual verification should be made manually before official release.
- Vaswani et al., “Attention Is All You Need”, arXiv, 2017. https://arxiv.org/abs/1706.03762
- Hu et al., “LoRA: Low-Rank Adaptation of Large Language Models”, arXiv, 2021. https://arxiv.org/abs/2106.09685
- Dettmers et al., “QLoRA: Efficient Finetuning of Quantized LLMs”, arXiv, 2023. https://arxiv.org/abs/2305.14314
- Rafailov et al., “Direct Preference Optimization: Your Language Model is Secretly a Reward Model”, arXiv, 2023. https://arxiv.org/abs/2305.18290
- Gu and Dao, “Mamba: Linear-Time Sequence Modeling with Selective State Spaces”, arXiv, 2023. https://arxiv.org/abs/2312.00752
- DeepSeek-AI, “DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning”, arXiv, 2025. https://arxiv.org/abs/2501.12948
- Moonshot AI, “Kimi K2: Open Agentic Intelligence”, arXiv, 2025. https://arxiv.org/abs/2507.20534
- NeurIPS 2026 Reviewer Guidelines, official conference page. https://neurips.cc/Conferences/2026/ReviewerGuidelines
- ICLR 2026 Call for Papers, official conference page. https://iclr.cc/Conferences/2026/CallForPapers
- AAAI-26 Reproducibility Checklist, official conference page. https://aaai.org/conference/aaai/aaai-26/reproducibility-checklist/
- ACL 2026 Main Conference Calls and submission information, official conference page. https://2026.aclweb.org/
- OpenReview documentation and venue pages for ICLR-style peer review and paper metadata. https://openreview.net/