--- title: "Self-Refine Prompting (PT)" source: "https://systems-analysis.info/int/Self-Refine_Prompting_(PT)" wiki: "systems-analysis.info/int" article: "Self-Refine_Prompting_(PT)" language: "pt" categories: - "Category:Large language models" - "Category:Machine learning" - "Category:Portuguese" - "Category:Prompt engineering" revision_id: 6621 wiki_created_at: 2026-09-07T00:07:50Z wiki_modified_at: 2026-09-07T00:07:50Z downloaded_at: 2026-09-07T23:14:52Z --- # Self-Refine Prompting (PT) **Self-Refine** (**auto-refinamento** ou **autocorreção**) é uma abordagem no campo da engenharia de prompts que permite que grandes modelos de linguagem (LLMs) melhorem iterativamente a resposta gerada com base em seu próprio feedback^{[\[1\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-madaan2023-1)}. A ideia foi proposta por um grupo de pesquisadores liderado por Aman Madaan em 2023 e se baseia na observação de que, assim como os humanos, os modelos de linguagem nem sempre geram o melhor resultado na primeira tentativa. Neste método, o mesmo LLM desempenha sequencialmente três papéis: 1. **Gerador (Generator)**: cria uma resposta inicial (rascunho) para a solicitação. 2. **Crítico (Feedback)**: avalia sua própria resposta e fornece feedback construtivo. 3. **Refinador (Refiner)**: utiliza esse feedback para criar uma versão aprimorada da resposta. Este ciclo iterativo "geração → feedback → aprimoramento" pode ser repetido várias vezes até que a qualidade desejada seja alcançada ou uma condição de parada seja satisfeita. É importante notar que o Self-Refine não requer treinamento adicional do modelo, ajuste fino ou dados externos — todo o processo é controlado exclusivamente por meio de prompts na etapa de inferência (*inference*)^{[\[1\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-madaan2023-1)}. ## Mecanismo de Implementação O método Self-Refine é implementado por meio de uma sequência de prompts especialmente elaborados que direcionam o comportamento do modelo. 1. **Geração Inicial**. O modelo recebe o prompt original e gera uma resposta de rascunho. 2. **Criação de Feedback**. O modelo recebe a instrução de analisar sua própria resposta anterior e identificar suas deficiências. Por exemplo, pode notar que a resposta não é detalhada o suficiente ou contém um erro lógico. O resultado é um feedback textual com observações e recomendações específicas. 3. **Aprimoramento Iterativo**. O modelo recebe como novo prompt a solicitação original, sua resposta inicial e o feedback gerado. Com base nisso, ele cria uma versão aprimorada da resposta. Este ciclo de duas etapas "crítica → refinamento" pode ser executado várias vezes. No contexto de cada nova iteração, são incluídas as versões anteriores da resposta e os comentários, o que ajuda o modelo a evitar a repetição de erros^{[\[2\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-selfrefine_info-2)}. Para controlar o comportamento do modelo, são frequentemente utilizadas técnicas de *few-shot prompting*, nas quais o prompt inclui exemplos do formato desejado para o feedback e as correções. ## Eficácia e Aplicações O método Self-Refine demonstrou sua eficácia em uma série de tarefas que exigem refinamento múltiplo, como: - Geração de respostas em diálogos. - Continuação criativa de histórias. - Resolução de problemas matemáticos com raciocínio passo a passo. - Otimização de código de software. No estudo original, as respostas obtidas com o Self-Refine foram, em média, **~20%** mais preferidas em avaliações humanas e métricas automáticas em comparação com a geração em uma única etapa^{[\[1\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-madaan2023-1)}. A melhoria foi alcançada mesmo nos modelos mais avançados, como o GPT-4, o que indica que até mesmo LLMs poderosos muitas vezes precisam apenas de um passo adicional de reflexão para corrigir seus próprios erros. Abordagens semelhantes, como o **RCI** (Recursive Criticism and Improvement), também demonstraram alta eficácia em tarefas interativas, como no controle de computadores e na resolução de problemas lógicos. A combinação do RCI com a técnica de "cadeia de pensamentos" (Chain-of-Thought) produziu um efeito sinérgico, melhorando notavelmente a capacidade do modelo de resolver problemas complexos por meio de uma etapa de autoverificação integrada^{[\[3\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-kim2023_rci-3)}. ## Limitações e Pesquisas Atuais Apesar dos sucessos promissores, as pesquisas mostram que o aprimoramento autoiterativo possui várias limitações. - **Viés próprio (self-bias)**: Os modelos têm dificuldade em julgar suas próprias respostas de forma imparcial. Os LLMs tendem a perceber favoravelmente o texto que geraram e a avaliá-lo de forma pouco crítica, o que pode levar à estagnação ou até mesmo à deterioração da qualidade após várias iterações^{[\[4\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-huang2023-4)}. - **Excesso de confiança**: Observou-se que, com o aumento do número de iterações de autocorreção, o modelo pode se tornar excessivamente confiante em suas respostas, mesmo que elas não se tornem mais precisas. Isso leva a um aumento no indicador *Expected Calibration Error (ECE)* — a discrepância entre a confiança do modelo e a precisão real^{[\[5\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-zhu2025_calibration-5)}. - **Custos computacionais**: O método requer múltiplas chamadas ao LLM para obter uma única resposta final, o que aumenta significativamente a latência e o custo em comparação com a geração em uma única passagem. As pesquisas atuais visam resolver esses problemas. Uma das direções é a implementação de mecanismos de calibração de confiança em cada etapa da iteração. Outra é o uso de fontes externas de informação ou ferramentas (por exemplo, execução de código, busca de dados) para uma autoavaliação mais objetiva^{[\[6\]](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_note-beyond_accuracy_study-6)}. ## Comparação com Outras Técnicas - **Chain-of-Thought (CoT)**: O CoT foca na geração de uma cadeia linear de raciocínio para chegar a uma resposta. O Self-Refine, por sua vez, foca no aprimoramento iterativo de uma resposta já gerada (que pode incluir o CoT). - **Tree of Thoughts (ToT)**: O ToT explora múltiplos caminhos de raciocínio paralelos em forma de árvore, enquanto o Self-Refine aprimora um único caminho iterativamente. O ToT é uma técnica de exploração do espaço de soluções, enquanto o Self-Refine é uma técnica de otimização de uma solução específica. ## Ligações externas - Site oficial do projeto Self-Refine - Artigo científico original "Self-Refine: Iterative Refinement with Self-Feedback" ## Literatura - Madaan, A. et al. (2023). *Self-Refine: Iterative Refinement with Self-Feedback*. arXiv:2303.17651. - Kim, G. et al. (2023). *Language Models Can Solve Computer Tasks*. arXiv:2303.17491. - Gou, Z. et al. (2023). *CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing*. arXiv:2305.11738. - Huang, J. et al. (2023). *Large Language Models Cannot Self-Correct Reasoning Yet*. arXiv:2310.01798. - Pan, L. et al. (2023). *Automatically Correcting Large Language Models: Surveying the Landscape of Diverse Self-Correction Strategies*. arXiv:2308.03188. - Jiang, C. et al. (2024). *Importance Weighting Can Help Large Language Models Self-Improve*. arXiv:2408.09849. - Liang, X. et al. (2024). *Internal Consistency and Self-Feedback in Large Language Models: A Survey*. arXiv:2407.14507. - Zhu, D. et al. (2025). *Beyond Accuracy: The Role of Calibration in Self-Improving Large Language Models*. arXiv:2504.02902. - Hao, Q. et al. (2025). *RL of Thoughts: Navigating LLM Reasoning with Inference-time Reinforcement Learning*. arXiv:2505.14140. - Cui, Y. et al. (2023). *Check Your Facts and Try Again: Improving Large Language Models by Reducing Hallucination*. arXiv:2302.12813. - Wei, Z. et al. (2024). *ReSearch: Iterative Self-Reflection for Better LLM Calibration*. arXiv:2405.13022. ## Notas 1. ↑ ^{[1.0](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-madaan2023_1-0)} ^{[1.1](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-madaan2023_1-1)} ^{[1.2](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-madaan2023_1-2)} Madaan, Aman; et al. «Self-Refine: Iterative Refinement with Self-Feedback». *arXiv*. [1] 2. [↑](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-selfrefine_info_2-0) «Self-Refine: Iterative Refinement with Self-Feedback». *Site oficial do projeto*. [2] 3. [↑](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-kim2023_rci_3-0) Kim, Geunwoo; et al. «Language Models can Solve Computer Tasks». *arXiv*. [3] 4. [↑](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-huang2023_4-0) Huang, Jie; et al. «Large Language Models Cannot Self-Correct Reasoning Yet». *arXiv*. [4] 5. [↑](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-zhu2025_calibration_5-0) Zhu, D., et al. (2025). «Beyond Accuracy: The Role of Calibration in Self-Improving Large Language Models». *arXiv*. [5] 6. [↑](https://systems-analysis.info/int/Self-Refine_Prompting_(PT)#cite_ref-beyond_accuracy_study_6-0) «Beyond Accuracy: The Role of Calibration in Self-Improving Large Language Models». *arXiv*. [6]