SLearnLLM: A Self-Learning Framework for Efficient Domain-Specific Adaptation of Large Language Models

Huan Hu; Kai Wang; Kohou Wang; Peng Wang; Shiguo Lian; Xiang Liu; Zhaoxiang Liu

REVIEW 4 major objections 5 minor 21 references

SLearnLLM: A Self-Learning Framework for Efficient Domain-Specific Adaptation of Large Language Models

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Fine-tuning a domain model only on the questions it answers incorrectly—as graded by its own chain-of-thought self-check—matches full-dataset fine-tuning in accuracy while cutting total training time substantially.

desk verdict A simple, plausible data-filtering trick for SFT with a genuine novelty and consistent efficiency numbers, but the shared judge between filtering and evaluation makes the comparability claim fragile. read the letter →

arxiv 2505.17470 v1 pith:76Z5JZS3 submitted 2025-05-23 cs.CL cs.AI

Xiang Liu , Zhaoxiang Liu , Peng Wang , Kohou Wang , Huan Hu , Kai Wang , Shiguo Lian This is my paper · ORCID

classification cs.CLcs.AI

keywords largelanguagemodelsself-learningdomain-specificfine-tuningsupervisedchain-of-thoughtknowledgefilteringefficientadaptationlow-rank

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that a target LLM can be adapted to a specialized domain more efficiently by fine-tuning it only on the questions it answers incorrectly, as judged by its own chain-of-thought self-check, instead of on the entire supervised fine-tuning dataset. In experiments with Qwen1.5 models of 7B, 14B, and 32B parameters over agricultural and medical datasets, models fine-tuned on the filtered incorrect-answer set scored within 0.2-0.8 points of full-data fine-tuning while cutting total GPU time by roughly 30-45%. The motivating idea is that much of a typical SFT dataset overlaps with knowledge the model already has, so training on the whole dataset spends compute on what is already learned. If the self-grading filter reliably isolates genuine gaps, the result is a cheap, iterative way to target a model's unknown knowledge.

What carries the argument

The framework's central object is the incorrect-answered QA set, produced by a two-stage Chain-of-Thought self-check prompt in which the target LLM takes the role of 'an expert language teacher'. The model scores its own response against the reference answer for consistency and accuracy, then marks incorrect responses with a 'Yes' flag; this filtered set becomes the training data for LoRA fine-tuning. The self-check prompt carries the whole argument, because it is the mechanism that separates unknown from known knowledge, and the claimed efficiency gain depends on that separation being accurate. LoRA (low-rank adaptation) is the parameter-efficient fine-tuning method used for all training runs.

What would settle it

Have human domain experts grade a random sample of the model responses (e.g., 500 QA pairs per domain) and compare their correct/incorrect labels with the model's self-check labels; if agreement is far below the roughly 40-60% incorrect-answer rates the self-check reports, the filter is not isolating unknown knowledge. A cheaper check: fine-tune on a random subset of the SFT dataset matched in size to the incorrect-answer set—if its validation score matches the SL score, the gains are explained by data quantity, not by the selection of wrong answers.

Watch

Extended reading notes

Core claim

The central discovery is that the incorrect-answered QA set—the subset of a domain SFT dataset that the model itself flags as wrong—carries nearly all of the training signal of the full dataset. Across all six model-domain combinations, validation accuracy after fine-tuning on this filtered set stayed within 0.2-0.8 points of full-data fine-tuning (e.g., 99.1 vs 99.3 for Qwen1.5-32B-Chat in agriculture), while total time fell from 71.8 to 40.2 GPU-hours at the largest scale. The authors present this as evidence that their self-check chain-of-thought scoring reliably identifies the knowledge the model lacks, and that concentrating fine-tuning on that knowledge is sufficient for domain adaptation.

Load-bearing premise

The load-bearing premise is that the model's own step-by-step self-scoring reliably identifies which answers are genuinely wrong; the paper does not validate this grader against human judgments, so if the self-check is noisy the filtered set stops being the unknown knowledge and both the performance and efficiency claims collapse.

Editorial extensions

If this is right

Fine-tuning only on self-identified incorrect answers loses less than one validation point while cutting total GPU time by roughly a third to under a half across the tested scales and domains.
The time savings grow with model size: for Qwen1.5-32B-Chat in agriculture, total time drops from 71.8 to 40.2 GPU-hours, so the method becomes more attractive for larger models.
When fewer than 75% of QA pairs are answered incorrectly, the framework reduces overall time; below 50% the savings are substantial, giving a simple rule of thumb for when to apply it.
Because the method uses only the target model and the SFT dataset, it needs no external knowledge retrieval or extra annotation, and any hallucination-mitigation technique developed for ordinary SFT can be layered on top.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

Beyond the paper: if the self-check grader is reliable, the same filter can be applied iteratively—fine-tune on one incorrect-answer set, re-run the self-check, and fine-tune again—so SLearnLLM naturally extends to a curriculum that may converge with less data than one-shot full fine-tuning.
Beyond the paper: the framework makes a falsifiable comparison: fine-tuning on a random subset of the SFT dataset of the same size should underperform fine-tuning on the self-filtered incorrect set; if it does not, the gains come from data quantity rather than from identifying unknown knowledge.
Beyond the paper: the observed incorrect-answer rate could serve as a cheap proxy for a model's domain competence, which might be reused for data selection or model routing decisions outside this fine-tuning pipeline.
Beyond the paper: the validation scores themselves are produced by GPT-4o grading, so a natural next test is to measure how well that LLM grader agrees with human experts before treating the reported single-point differences as meaningful.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Worth a read if you're doing SFT on a budget. The core move is simple: take an existing SFT dataset, have the target model answer the questions, self-grade against the reference answers with a CoT prompt, and fine-tune only on the answers it got wrong. That filtering step is new relative to the self-improvement methods they cite (response consistency, rationale generation, MCTS, knowledge graphs); those all generate new training data rather than filter an existing set. So the novelty is genuine, if modest.

What the paper does well: the experiments cover six model-domain combinations and consistently show the filtered model within 0.2–0.8 points of full fine-tuning while cutting GPU time by 25–45%. Table 2 is coherent. They also measure total time including answering and scoring, which is the honest way to count the overhead. The limitations section is candid about hallucination risk and weak models.

The soft spots are real but not fatal. No error bars, no multiple seeds, and the evaluation is GPT-4o using the same CoT scoring prompt as the filtering step. That creates a legitimate worry: if the rubric rewards superficial matching to the reference answer, both the filter and the evaluation are biased in the same direction, and the 0.2–0.8 point gap could be understated or overstated. The paper offers no human-agreement check for the self-grader, no confusion matrix, no alternative metric like exact match on true/false and MCQ subsets. The validation set is built from the same corpora as the training data, so there's possible overlap they don't address. No code or data released, so the numbers are hard to reproduce.

That said, the time savings are a directly measured fact, not an artifact of the judge. Even if the performance comparability needs stronger backing, the efficiency gain is there. The central argument—filter by unknown knowledge, fine-tune on that—holds up as a useful practical heuristic.

Who this is for: practitioners adapting models to vertical domains with a fixed SFT dataset and limited GPU budget. It's a production trick, not a field re-organizer.

Recommendation: send it to peer review. It's a simple, plausible idea with a real experimental question worth nailing down. Ask for multiple seeds, human evaluation on a sample, a self-grader accuracy analysis, and ideally released code/data. If the shared-judge concern survives those additions, that's still a publishable efficiency result.

Referee Report

4 major / 5 minor

Summary. The paper presents SLearnLLM, a four-step pipeline for domain-specific supervised fine-tuning (SFT). The target LLM (Qwen1.5-7B/14B/32B) first answers all QA pairs in a domain SFT set; it then uses a chain-of-thought prompt to grade its own answers against the reference answers, treating itself as an 'expert language teacher'; it filters the pairs it marked incorrect; and it fine-tunes on that subset with LoRA. The authors report experiments on agricultural (57,638 QA pairs) and medical (35,000 QA pairs) sets, with evaluation by GPT-4o on 1,000 manually crafted held-out QA pairs per domain. Table 2 shows that models fine-tuned on the filtered subset score within 0.2-0.8 points of models fine-tuned on the full data while using substantially less GPU time. The paper concludes that the unknown-knowledge filtering improves training efficiency.

Significance. The strength of the paper is its direct, parameter-free framework: no extra trainable parameters, standard LoRA fine-tuning, and direct wall-clock time measurements across six model/domain combinations. The reported consistency of the -SL versus -full gap is a useful empirical signal. The significance is currently capped by three omissions: the grading loop is unvalidated against human judgment, the evaluation judge shares its rubric with the filter, and no random-subset or other data-selection baseline is provided. These are common, fixable requirements, but until they are addressed the headline claim of 'comparable improvements' is not fully supported.

major comments (4)

[Section 4.3/Table 2] The headline scores are produced by GPT-4o using the same CoT scoring prompt that defines the filtering criterion in Section 3.2. Because the filter retains data that the target model answers 'incorrectly' according to that rubric, and the evaluation rewards the same rubric, the observed 0.2-0.8 point gaps could partly reflect alignment to the judge rather than real domain competence. The paper reports no human agreement statistics, no confusion matrix for the self-grader, and no alternative metric (e.g., exact match for true/false or multiple-choice items). This is load-bearing for the central comparability claim.
[Section 4.4/Table 2] The claim that focusing on unknown knowledge drives the improvements is not supported by any baseline that controls for subset size. All reported SL results train on the incorrect-answered subset, and the paper does not compare against fine-tuning on a random subset of the same size or against uncertainty/self-consistency filters. Without such a control, the comparable performance could be an artifact of any reduced-size fine-tuning, especially since the models' baseline scores and the large gains suggest much of the QA content is learnable. The authors should add at least a random-subset baseline at matched data volume.
[Section 3.2] The self-check grader is asserted to be accurate ('This step ensures the accuracy and reliability of the scoring results'), but no evidence is provided. The grader is the target model itself, and for open-ended answers the grading requires domain knowledge the model may lack; a 7B model with a 24.3 medical baseline score is being asked to judge correctness of its own medical answers. The authors should validate the self-grader against human labels or a held-out labeled sample and report precision/recall of the filter. Until then, both the performance and efficiency claims rest on an unmeasured premise.
[Section 4.3] The evaluation description is internally confusing. The text says the score is 'normalized by dividing it by the total number of questions in the incorrectly answered QA set,' but the validation set described in the same section has 1,000 QA pairs per domain. If the denominator is the incorrect-answered training set, then the reported percentages in Table 2 are not computed as described; if it is the validation set, the sentence should be corrected. The paper also reports no standard deviations or multiple seeds for any of the scores or time measurements, so the 0.2-0.8 point differences between -full and -SL cannot be assessed statistically.

minor comments (5)

[Section 4.4] The rule that SLearnLLM reduces total time when the incorrect-answer rate is below 75% (and 'significantly' below 50%) is stated without derivation or supporting data; the break-even point should depend on the ratio of training time to inference/filtering time, not only on the data fraction.
[Section 2] Several references are missing spaces and punctuation (e.g., 'Ferdinan[6]proposed...'), and the text would benefit from a careful proofread.
[Table 1] The column header 'Total Incorrect-answered Time/GPU hours' is confusing; it presumably refers to the time spent on answering and self-scoring, but it should be labeled explicitly.
[Section 4.3] The validation set construction is described only as 'manually crafted'; the authors should specify how many annotators, whether experts were used, and how independence from the SFT sets was ensured.
[Section 3.2/Figure 3] The full CoT scoring prompt is not provided verbatim; since the evaluation uses 'the same prompt,' the exact prompt should be included in an appendix for reproducibility.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the filter, fine-tuning, and evaluation are anchored to external reference answers, and the efficiency claim is measured directly.

full rationale

I find no step in the paper's derivation that reduces to its own inputs. The pipeline is: (1) the target model answers SFT questions; (2) the model grades its answers against reference answers from the SFT dataset; (3) incorrectly answered pairs are used for LoRA fine-tuning; (4) held-out validation sets (manually crafted 1,000 QA pairs per domain) are scored by GPT-4o. The training subset is selected by the target LLM's own judgment, but the selection criterion is anchored to the dataset's reference answers, and the reported gains are measured on a separate validation set, so the result is not definitionally forced. Table 2's 'comparable' claim is an empirical comparison against full-dataset fine-tuning; no fitted parameter or normalization makes the SL score equal to the full score by construction. The only methodological weakness is that the evaluation prompt is described as 'the same prompt of scoring the answers in Methods section' (Sec. 4.3), so the filter and evaluator share a rubric; that is a validity/calibration concern, not circularity, because the evaluator is a different model (GPT-4o) and the validation questions are independent of the filtered training set. There are no load-bearing self-citations: all citations are to external prior work. I therefore rate circularity 0.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

The framework introduces no explicit free parameters, but it rests on the assumption that self-grading reliably identifies unknown knowledge. No new entities are introduced. The ledger is light because the main burden is carried by the untested reliability of the self-check step and by the implicit assumption that correct-answer pairs add little when fine-tuning.

assumptions (4)

domain assumption The target LLM's CoT self-check accurately scores its own responses against the reference answers.
Section 3.2 states the process 'ensures the accuracy and reliability of the scoring results' but no ground-truth or human validation of the grading is provided.
domain assumption QA pairs the model answers incorrectly in the self-check are exactly the unknown knowledge that should be fine-tuned on.
This equivalence is asserted in Section 3.2; the paper does not test whether the model would also benefit from training on correctly-answered pairs.
domain assumption Fine-tuning only on the filtered incorrect-answered set leaves the model's already-known knowledge intact.
State-of-the-art SFT assumes fine-tuning updates weights; the paper does not measure forgetting or performance on correctly-answered pairs.
domain assumption Standard SFT via LoRA improves in-domain performance on held-out questions.
Assumed throughout Section 4.2; no comparison to other fine-tuning methods.

how reviews work

0 comments

Cite this review

Pith. "Pith review of SLearnLLM: A Self-Learning Framework for Efficient Domain-Specific Adaptation of Large Language Models." pith.science (2026). https://pith.science/paper/76Z5JZS3

@misc{pith2026250517470,
  author       = {Pith},
  title        = {Pith review of: SLearnLLM: A Self-Learning Framework for Efficient Domain-Specific Adaptation of Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/76Z5JZS3}},
  note         = {Machine review of arXiv:2505.17470}
}

read the original abstract

When using supervised fine-tuning (SFT) to adapt large language models (LLMs) to specific domains, a significant challenge arises: should we use the entire SFT dataset for fine-tuning? Common practice often involves fine-tuning directly on the entire dataset due to limited information on the LLM's past training data. However, if the SFT dataset largely overlaps with the model's existing knowledge, the performance gains are minimal, leading to wasted computational resources. Identifying the unknown knowledge within the SFT dataset and using it to fine-tune the model could substantially improve the training efficiency. To address this challenge, we propose a self-learning framework for LLMs inspired by human learning pattern. This framework takes a fine-tuning (SFT) dataset in a specific domain as input. First, the LLMs answer the questions in the SFT dataset. The LLMs then objectively grade the responses and filter out the incorrectly answered QA pairs. Finally, we fine-tune the LLMs based on this filtered QA set. Experimental results in the fields of agriculture and medicine demonstrate that our method substantially reduces training time while achieving comparable improvements to those attained with full dataset fine-tuning. By concentrating on the unknown knowledge within the SFT dataset, our approach enhances the efficiency of fine-tuning LLMs.

Figures

Figures reproduced from arXiv: 2505.17470 by the authors.

**Figure 1.** An efficient human learning pattern that focuses on learning unknown knowledge. This pattern facilitates knowledge acquisition and consolidation through a continuous learning cycle. In this cycle, students undergo several key steps: doing exercises, check answers, filter out errors and learn from errors. Through this iterative process, students gradually master the knowledge in the exercise set. use. If LLMs yield… view at source ↗

**Figure 2.** The framework of SLearnLLM. The framework comprises four steps: answering questions, scoring responses against the QA sets using the target LLM with robust logical reasoning, filtering out incorrect-answered questions, and fine-tuning the model based on incorrect-answered QA set to enhance performance in specific domains. Through these four steps, we leverage the logical reasoning capabilities of LLMs to filter out … view at source ↗

**Figure 3.** The workflow and example of the self-check process using a Chain of Thought (CoT) prompt. The input comprises a triplet: a question (highlighted in red), the correct answer (also highlighted in red), and the target LLM’s answer (highlighted in green, represented as "student" in the figure). Guided by the CoT prompt, the target LLM evaluates its own response in two stages: (1) Scoring, where the model assesses its re… view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: Prompt for generating QA pairs for specific domains using GPT-4o. The strategy of the prompt involves three steps: 1. Questions generation. 2. Questions correction. 3. Answers generation. This strategy ensures high-quality, consistent QA pairs aligned with the origina…

**Figure 5.** Figure 5: Examples of responses from Qwen1.5-7B-Chat and Qwen1.5-7B-Chat-SL to the same question in Agricultural and Medical domains. The responses from Qwen1.5-7BChat-SL are better in both domains, while the contents highlighted in green indicate errors in the responses from Q…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

21 extracted references · 3 canonical work pages

[1]

arXiv preprint arXiv:2303.08774 (2023)

Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F.L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al.: Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

arXiv 2023
[2]

arXiv preprint arXiv:2305.10403 (2023)

Anil, R., Dai, A.M., Firat, O., Johnson, M., Lepikhin, D., Passos, A., Shakeri, S., Taropa, E., Bailey, P., Chen, Z., et al.: Palm 2 technical report. arXiv preprint arXiv:2305.10403 (2023)

arXiv 2023
[3]

arXiv preprint arXiv:2309.16609 (2023)

Bai, J., Bai, S., Chu, Y., Cui, Z., Dang, K., Deng, X., Fan, Y., Ge, W., Han, Y., Huang, F., et al.: Qwen technical report. arXiv preprint arXiv:2309.16609 (2023)

arXiv 2023
[4]

ACM Transactions on Intelligent Systems and Technology15(3), 1–45 (2024)

Chang, Y., Wang, X., Wang, J., Wu, Y., Yang, L., Zhu, K., Chen, H., Yi, X., Wang, C., Wang, Y., et al.: A survey on evaluation of large language models. ACM Transactions on Intelligent Systems and Technology15(3), 1–45 (2024)

2024
[5]

In: 2016 IEEE Conference on Computational In- telligence and Games (CIG)

De Waard, M., Roijers, D.M., Bakkes, S.C.: Monte carlo tree search with options for general video game playing. In: 2016 IEEE Conference on Computational In- telligence and Games (CIG). pp. 1–8. IEEE (2016)

work page 2016
[6]

Into the Unknown: Self-Learning Large Language Models

Ferdinan, T., Kocoń, J., Kazienko, P.: Into the unknown: Self-learning large lan- guage models. arXiv preprint arXiv:2402.09147 (2024)

work page Pith review arXiv 2024
[7]

Gekhman, Z., Yona, G., Aharoni, R., Eyal, M., Feder, A., Reichart, R., Herzig, J.: Does fine-tuning llms on new knowledge encourage hallucinations? arXiv preprint arXiv:2405.05904 (2024)

arXiv 2024
[8]

arXiv preprint arXiv:2106.09685 (2021)

Hu, E.J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., Chen, W.: Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685 (2021)

arXiv 2021

Show all 21 references

[9]

arXiv preprint arXiv:2210.11610 (2022)

Huang, J., Gu, S.S., Hou, L., Wu, Y., Wang, X., Yu, H., Han, J.: Large language models can self-improve. arXiv preprint arXiv:2210.11610 (2022)

2022 arXiv
[10]

Advances in neural information processing systems35, 22199–22213 (2022)

Kojima, T., Gu, S.S., Reid, M., Matsuo, Y., Iwasawa, Y.: Large language models are zero-shot reasoners. Advances in neural information processing systems35, 22199–22213 (2022)

2022
[11]

arXiv preprint arXiv:2303.08896 (2023)

Manakul, P., Liusie, A., Gales, M.J.: Selfcheckgpt: Zero-resource black-box hallucination detection for generative large language models. arXiv preprint arXiv:2303.08896 (2023)

2023 arXiv
[12]

Advances in neural information processing sys- tems 35, 27730–27744 (2022)

Ouyang, L., Wu, J., Jiang, X., Almeida, D., Wainwright, C., Mishkin, P., Zhang, C., Agarwal, S., Slama, K., Ray, A., et al.: Training language models to follow instructions with human feedback. Advances in neural information processing sys- tems 35, 27730–27744 (2022)

2022
[13]

arXiv preprint arXiv:2312.06585 (2023) 12 J

Singh, A., Co-Reyes, J.D., Agarwal, R., Anand, A., Patil, P., Garcia, X., Liu, P.J., Harrison, J., Lee, J., Xu, K., et al.: Beyond human data: Scaling self-training for problem-solving with language models. arXiv preprint arXiv:2312.06585 (2023) 12 J. Huang et al

2023 arXiv
[14]

arXiv preprint arXiv:2312.11805 (2023)

Team, G., Anil, R., Borgeaud, S., Wu, Y., Alayrac, J.B., Yu, J., Soricut, R., Schalk- wyk, J., Dai,A.M.,Hauth, A., et al.:Gemini: a family ofhighlycapable multimodal models. arXiv preprint arXiv:2312.11805 (2023)

2023 arXiv
[15]

arXiv preprint arXiv:2404.12253 (2024)

Tian, Y., Peng, B., Song, L., Jin, L., Yu, D., Mi, H., Yu, D.: Toward self- improvement of llms via imagination, searching, and criticizing. arXiv preprint arXiv:2404.12253 (2024)

2024 arXiv
[16]

arXiv preprint arXiv:2302.13971 (2023)

Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.A., Lacroix, T., Rozière, B., Goyal, N., Hambro, E., Azhar, F., et al.: Llama: Open and efficient foundation language models. arXiv preprint arXiv:2302.13971 (2023)

2023 arXiv
[17]

arXiv preprint arXiv:2307.09288 (2023)

Touvron, H., Martin, L., Stone, K., Albert, P., Almahairi, A., Babaei, Y., Bash- lykov, N., Batra, S., Bhargava, P., Bhosale, S., et al.: Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288 (2023)

2023 arXiv
[18]

arXiv preprint arXiv:2402.11441 (2024)

Wang, F., Bao, R., Wang, S., Yu, W., Liu, Y., Cheng, W., Chen, H.: Infuserki: En- hancinglargelanguagemodelswithknowledgegraphsviainfuser-guidedknowledge integration. arXiv preprint arXiv:2402.11441 (2024)

2024 arXiv
[19]

arXiv preprint arXiv:2203.11171 (2022)

Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E., Narang, S., Chowdhery, A., Zhou, D.: Self-consistency improves chain of thought reasoning in language models. arXiv preprint arXiv:2203.11171 (2022)

2022 arXiv
[20]

Advances in neural information processing systems35, 24824–24837 (2022)

Wei, J., Wang, X., Schuurmans, D., Bosma, M., Xia, F., Chi, E., Le, Q.V., Zhou, D., et al.: Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems35, 24824–24837 (2022)

2022
[21]

arXiv preprint arXiv:2309.01219 (2023)

Zhang, Y., Li, Y., Cui, L., Cai, D., Liu, L., Fu, T., Huang, X., Zhao, E., Zhang, Y., Chen, Y., et al.: Siren’s song in the ai ocean: a survey on hallucination in large language models. arXiv preprint arXiv:2309.01219 (2023)

2023 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.

[1] [1]

arXiv preprint arXiv:2303.08774 (2023)

Achiam, J., Adler, S., Agarwal, S., Ahmad, L., Akkaya, I., Aleman, F.L., Almeida, D., Altenschmidt, J., Altman, S., Anadkat, S., et al.: Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

arXiv 2023

[2] [2]

arXiv preprint arXiv:2305.10403 (2023)

Anil, R., Dai, A.M., Firat, O., Johnson, M., Lepikhin, D., Passos, A., Shakeri, S., Taropa, E., Bailey, P., Chen, Z., et al.: Palm 2 technical report. arXiv preprint arXiv:2305.10403 (2023)

arXiv 2023

[3] [3]

arXiv preprint arXiv:2309.16609 (2023)

Bai, J., Bai, S., Chu, Y., Cui, Z., Dang, K., Deng, X., Fan, Y., Ge, W., Han, Y., Huang, F., et al.: Qwen technical report. arXiv preprint arXiv:2309.16609 (2023)

arXiv 2023

[4] [4]

ACM Transactions on Intelligent Systems and Technology15(3), 1–45 (2024)

Chang, Y., Wang, X., Wang, J., Wu, Y., Yang, L., Zhu, K., Chen, H., Yi, X., Wang, C., Wang, Y., et al.: A survey on evaluation of large language models. ACM Transactions on Intelligent Systems and Technology15(3), 1–45 (2024)

2024

[5] [5]

In: 2016 IEEE Conference on Computational In- telligence and Games (CIG)

De Waard, M., Roijers, D.M., Bakkes, S.C.: Monte carlo tree search with options for general video game playing. In: 2016 IEEE Conference on Computational In- telligence and Games (CIG). pp. 1–8. IEEE (2016)

work page 2016

[6] [6]

Into the Unknown: Self-Learning Large Language Models

Ferdinan, T., Kocoń, J., Kazienko, P.: Into the unknown: Self-learning large lan- guage models. arXiv preprint arXiv:2402.09147 (2024)

work page Pith review arXiv 2024

[7] [7]

Gekhman, Z., Yona, G., Aharoni, R., Eyal, M., Feder, A., Reichart, R., Herzig, J.: Does fine-tuning llms on new knowledge encourage hallucinations? arXiv preprint arXiv:2405.05904 (2024)

arXiv 2024

[8] [8]

arXiv preprint arXiv:2106.09685 (2021)

Hu, E.J., Shen, Y., Wallis, P., Allen-Zhu, Z., Li, Y., Wang, S., Wang, L., Chen, W.: Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685 (2021)

arXiv 2021