大型语言模型(LLMs)的普及已经完全改变了我们作为人类解决问题的方式。在前几年，用计算机解决任何任务(例如，重新格式化文档或对句子进行分类)都需要创建一个程序(即，根据某种编程语言精确编写的一组命令)。对于大语言模型来说，解决这样的问题只需要一个文本prompt。例如，我们可以通过类似于下面所示的prompt让LLM重新格式化任何文档。

正如上面的例子所示，大语言模型的通用文本输入到文本输出格式使我们很容易解决各种各样的问题。通过GPT-3的提出，我们第一次看到了这种潜力，表明足够大的语言模型可以使用few-shot学习以惊人的准确性解决许多任务。然而，随着大语言模型研究的进展，我们开始超越这些基本(但仍然非常有效!)的提示技术，如zero-shot/few-shot学习。

遵循指令的大语言模型(例如，InstructGPT和ChatGPT)引导我们探索语言模型是否可以解决真正困难的任务。也就是说，我们想要使用大语言模型来解决不仅仅是玩具问题。为了在实践中发挥作用，大语言模型需要能够遵循复杂的指令并执行多步推理，以正确回答人类提出的难题。不幸的是，使用基本提示技术通常无法解决此类问题。为了激发大语言模型解决复杂问题的行为，我们需要更复杂的东西。

扩大可能性的范围…

在之前的一篇文章中，我们了解了大语言模型更基本的提示方法，例如zero-shot/few-shot学习和指令提示。理解这些实用的提示技术对于掌握本文将介绍的更高级的提示过程非常重要。有关这些技术的更多细节，请查看链接这里的概述!

更好的提示→更好的结果.

这些技术可以用来完成很多大语言模型(假设它们被正确应用)。然而，由于种种原因，它们可能达不到要求。few-shot学习要求大多数大语言模型的有限上下文窗口被范例占用，如果不采取保护措施，大语言模型可能会被欺骗，提供有害的输出，并且大多数模型不擅长解决推理任务或遵循多步骤指令。考虑到这些限制，我们应该如何尝试用大语言模型解决困难的任务?

一种方法是创建更有能力的大语言模型，要么从零开始，要么通过更好的改进程序。然而，这需要很多的努力!如果我们能让现有模型更好地解决问题呢? 在这篇文章中，我们将探索更高级形式的prompt工程(例如，思维Chain提示，自动prompt工程，信息检索等)，使我们能够提高LLM的性能，并引出更复杂的问题解决行为。学习这些想法很重要，因为它们拓宽了大语言模型的可能性范围。例如，使用这些技巧，我们可以:

• 允许LLM访问外部知识库。
• 能够解决复杂的、基于推理的问题。
• 通过允许模型存储和访问对话中的先验信息，为LLM提供无限内存。

prompt工程正在不断发展

这篇综述将集中于提供prompt工程最新进展的高级视图。而不是深入探索个别方法，我们将重点放在获得不同的提示技术，可能是有用的一个广泛的观点。然而，需要注意的是，prompt工程是一个新兴且发展迅速的课题。几乎每天都有新的研究发布，许多前沿的想法只是在网上分享，而不是正式发表。因此，这个话题在未来几个月可能会发生重大变化，从而扩大大语言模型可以解决的问题。

理解LLMs

由于它的重点是提示，这个概述不会解释语言模型的历史或机制。为了更好地理解语言模型(这是深入理解提示的重要先决条件)，我编写了各种可用的概述。这些概述如下(按重要性排序):

• 语言建模基础(GPT和GPT-2)
• 尺度对语言模型的重要性(GPT-3)
• 现代和专业大语言模型
• PaLM， T5(v1和v2)， Llama(v1和v2)

高级提示技术

现在我们将讨论提示工程领域中三个有影响力的主题。首先，我们将了解如何使用思维链提示(包括几个值得注意的扩展和变体)来提高llm的推理能力。从这里开始，我们将讨论LLMs与外部数据库的集成，使相关的、准确的信息能够注入到每个提示中。最后，我们将学习如何使用自动提示工程方法从数据中发现更好的提示。

思维链提示和超越

我们在之前的一篇文章中介绍了思维链(CoT)提示背后的主要思想和它的一些流行变体。

什么是CoT提示?

CoT提示是一种简单的技术，用于提高法学硕士在常识或符号推理等推理任务上的表现。CoT提示通过在提示中插入几个正在解决的推理问题的示例来利用少量学习。每个例子都与一系列的思想(或理论)相匹配，通过文本解释如何一步一步地解决问题来增加问题的答案.

见下文。

由于他们的few-shot学习能力，大语言模型可以通过观察CoT prompt中的示例来学习生成基本原理以及他们的答案。先前的工作表明，以这种方式生成准确的基本原理可以提高推理性能，我们在CoT提示的实验中也看到了这种效果。也就是说，教LLM输出解释其最终答案的相关思维链可以大大提高算术、符号和常识性推理等任务的表现;见下文。

流行的CoT变体。

除了基本的CoT提示外，还探索了该技术的几种变体，例如:

• zero-shot CoT提示:替换所有示例理据，在提示符的末尾注入“Let ‘s think step by step”语句。
• 自一致性: 使用LLM生成多个思想链，并将这些多个输出的多数投票作为最终答案。
• 最小到最多提示[15]: 将推理问题分解为更小的步骤，每次解决一个，其中每个子问题的输出用作下一个子问题的输入。

这些技术(如下图所示)类似于CoT提示并产生类似的结果，但是它们各自都有独特的优点。例如，zero-shot CoT提示非常简单!我们只需要在我们的提示中插入一个语句，而不是手写或策划几个相关的思维链示例。另一方面，最少到最多提示比普通的CoT提示稍微复杂一些，但是这种技术也更能够解决需要许多步骤的推理问题。因此，我们可以使用最少到最多提示来解决CoT提示不足的最困难的任务。

在这些技巧中，自我一致是我个人的最爱。为什么?因为这是一个简单的技术，广泛适用，非常有效。事实上，这个想法甚至不是针对CoT提示的!在许多情况下，自一致性可以提高LLM应用程序的性能。我们不是用LLM生成单个输出，而是生成多个输出并取其平均值作为最终答案，从而提高了可靠性和准确性。

这个想法让我想起了深度学习中的模型集成，其中我们 *i)独立训练几个模型来解决一些任务，ii)*在推理时对每个模型的输出取平均值。虽然自洽只使用单个模型而不是集合，但类似的技术已经应用于更广泛的深度学习文献;例如，为了模拟一个集成，可以从包含不确定性模块(如dropout)的神经网络中生成多个输出并取平均值。

延伸式CoT提示.

CoT提示是否真的教会了大语言模型如何“推理”尚不清楚。尽管如此，CoT提示具有重要的实际意义，因为它可以用于解决复杂的、多步骤的大语言模型问题。因此，围绕CoT提示的各种有趣的想法最近已经被探索。探讨了CoT提示的多模态版本，其中使用图像和文本模态来执行不同的推理任务;见下文。

除了探索多种数据模式(即图像和文本)外，中的作者还通过将多步骤基本原理生成和答案推理作为解决基于推理的任务的两个不同步骤，略微调整了CoT设置;见下文。

通过清楚地隔离这些组件，我们可以更容易地分析CoT提示中的错误来源。因此，作者发现，*i)错误的答案往往是由生成的基本原理中的幻觉引起的，ii)*使用多模态数据可以生成更有效的基本原理。

更进一步，将CoT提示与主动学习的思想结合起来(即使用模型本身来识别应该包含在训练集中的数据)。LLMs首先使用CoT提示回答几个问题。从这里开始，输出“不确定性”(基于同一LLM生成的多个答案之间的不一致来测量)用于识别模型不太理解的问题。然后用正确的思维链对该组中的问题进行手工注释(由人类)，并将其用作解决未来问题的示例。

在实践中应用CoT提示时，我们可能遇到的最大问题之一是缺乏与我们试图解决的任务很好地结合在一起的少量示例。也许我们有几个高质量的思维链可以包含在我们的提示中，但如果我们试图解决的问题与这些示例中解决的问题略有不同，我们该怎么办?*虽然这个问题会导致性能下降。也就是说，我们可以使用主动学习来动态识别用于CoT提示的可用示例是否不足以解决某个问题。

知识的增加

虽然大语言模型在预训练期间学习了很多信息，但用额外的相关信息来增加他们的prompts通常是有帮助的。这种方法可以通过在LLM的prompt中提供准确的信息源来帮助解决幻觉(即生成不正确的事实)等问题，这些信息可以在生成输出时用作上下文。虽然有几种方法可以实现这一点，但我们将重点关注基于信息检索和生成知识的技术。

信息检索

LLM社区最近把重点放在矢量数据库技术(例如，Pinecone， Milvus， Weaviate等)，因为它在执行信息检索中的作用;见上图。在高层次上，信息检索的目标是使大语言模型能够通过以下方式访问大量文本信息库(超出最大上下文窗口):

1. 把文本分成小块。

2. 为每个文本块生成一个Embedding。

3. 将这些Embeddings存储在矢量数据库中。

4. 执行向量相似性搜索(基于这些Embeddings)来查找相关的文本块以包含在prompt符中。

最终的结果是，我们可以快速找到相关的文本信息，以提供额外的上下文在LLM的prompt。这种方法甚至可以与CoT提示相结合，引导检索过程获得新的有用信息。

生成的知识.

信息检索是强大的(即，它可以访问几乎无限量的信息!)，但是我们可能会想:*外部向量数据库是完全必要的吗?*有趣的是，最近的研究[1]表明答案可能是否定的!我们可以通过提示单独的LLM生成信息来提高LLM的性能，而不是存储和检索外部知识;见上图。特别是，我们可以使用Few-shot学习，通过提示LLM关于各种主题的知识生成示例，并以生成有关所需主题的有用上下文的请求结束;见下文。

在这里，我们可以在生成预测时将生成的信息作为额外的上下文。尽管不依赖于任何外部数据库，但这种方法可以显著提高LLM在几个常识性推理任务上的性能;见下文。

生成的知识对于假设理解世界上的常识性知识的任务(如常识推理)最有帮助。简而言之，大语言模型是一个很好的信息源，只要它们被谨慎地用于正确的任务。

“生成的知识提示强调了大型语言模型作为改进常识推理的外部知识的灵活来源”

自动提示

Prompt工程的目标是调整语言模型的输入，使模型提供正确结果的机会最大化。考虑到这一点，我们甚至可以将我们的prompt视为一组可以更新的可训练参数(例如，使用梯度下降或其他一些数据驱动的标准)来生成正确答案。基于数据自动更新prompt的想法非常普遍，但在最近的研究中已经成功地探索了几种这样的技术。

自动prompt工程师(APE)

提出了一种自动生成指令提示的简单方法。首先，LLM通过使用具有多个指令示例的few-shot prompt来提出一组潜在指令。探索了一些用于生成指令的prompt模板;见下文。

然后，我们通过评估使用每个指令的LLM的zero-shot性能(即正确结果的准确性或对数概率)来搜索这个指令“候选”池。换句话说，LLM在每个prompt下的表现被用作评估教学质量的指标。

进一步说，我们在中看到，指令可以通过重复这个过程来迭代地改进。特别是，我们可以 i)提出一组候选对象，ii)根据性能评估这些候选对象，iii)选择最佳候选对象， iv)通过提示LLM生成类似指令(即重新采样)来生成最佳候选对象的新变体。

这个过程(以及相关的prompt符)如下图所示。

gradient-base搜索.

除了搜索更好的文本prompts的技术之外，还有一系列有用的prompt工程工作，探索对prompt Embeddings的持续更新。首先，我们应该回顾一下语言模型中的prompt Embeddings是什么。给定一个文本prompt，我们通常对该prompt进行标记(即，将其分成单词或子单词)，然后查找每个结果token的Embedding。这个过程为我们提供了一个token Embeddings列表(即prompt Embedding!)，我们将其作为输入传递给语言模型;见下文。

一些作品探讨了直接修改promptEmbedding的prompt工程策略(即，每个token的Embeddings列表)。换句话说，这些作品并不直接修改prompt的单词，而是使用梯度下降等规则更新promptEmbeddings。这方面的主要工作概述如下:

• AutoPrompt将原始prompt输入与一组共享(跨所有输入数据)“触发tokens”相结合，这些令牌是通过基于梯度的搜索选择的，以提高性能。
• 前缀调优在输入层和隐藏层的promptEmbedding中添加几个“前缀”tokens，然后使用梯度下降作为参数高效的微调策略训练该前缀的参数(保持模型参数固定)。
• prompt调优类似于前缀调优，但前缀tokens只添加到输入层。这些tokens对语言模型解决的每个任务进行了微调，允许前缀tokens为给定任务调整模型。
• P-Tuning向模型的输入层添加了特定于任务的锚定tokens，但允许将这些tokens放置在任意位置(例如，prompt的中间)，使该方法比前缀调优更灵活。

我们应该用哪一个?

所有这些方法(如下所示)都探索向语言模型添加“软”tokens，这些语言模型在目标数据集上进行监督微调。值得注意的是，这些技术不能用于只能通过付费API访问的语言模型(例如，OpenAI API)。这是因为我们需要访问和修改prompt Embeddings的能力，而大多数api只显示模型的文本输入和输出。目前，如果我们正在使用自己的自托管LLM，我们只能使用基于梯度的自动提示技术。

在这些方法中，prompt调优是最简单的方法，可以产生令人印象深刻的性能优势。通过prompt调优，我们只需*i)向输入添加一些前缀token Embeddings，ii)*在单个下游任务上执行这些Embeddings的参数高效微调。通过在每次更新中混合几个不同的任务并为每个任务提供唯一的学习前缀来执行多任务微调;见下文。

通常，对语言模型进行微调意味着我们必须为每个任务存储模型参数的单独副本。相比之下，prompt调优只是对一小部分前缀token Embeddings进行微调，并保持剩余的模型参数不变。尽管只对一小组参数进行了微调，但prompt调优非常接近于匹配端到端微调的性能，如下图所示。

启示

“我们还能指望推理能力在模型尺度上提高多少?还有哪些提示方法可以扩展语言模型可以解决的任务范围?” **

本文概述的主要目的是探索不同的提示技术，这些技术可能对解决大语言模型的难题有实际帮助。如果应用得当，像zero-shot/few-shot学习和指导提示这样的基本技术是有用和有效的。然而，可能需要一些更复杂的东西来使大语言模型能够解决基于推理的任务或遵循复杂的、多步骤的指令。尽管随着时间的推移，模型的质量可能会有所提高，并且更容易处理此类困难的情况，但本文概述中涵盖的技术可以用于扩展当前可用的大语言模型的范围。下面概述了这些技术的一些基本要点。

解决难题。对CoT提示的分析表明，大语言模型能够解决复杂的、多步骤的问题。然而，要做到这一点，需要为LLM或由LLMs将问题分解成更小的部分。我们可以通过鼓励模型在给出答案之前生成解决问题的基本原理来隐含地做到这一点，或者通过使用最小到最大的提示来明确地将问题分解成由LLM单独解决的小部分。无论哪种方式，我们通常看到鼓励LLM一步一步地解决问题而不是整体解决问题的好处。

学习prompt。如果我们听到“prompt工程”这个词，我们大多数人可能会想到调整prompt的单词或结构，看看什么最有效。然而，这并不是prompt工程的唯一方法!也就是说，我们可以采用一种自动提示方法，通过梯度下降从数据中学习最优prompts。为此，我们使prompt Embedding(即，prompt中每个token的Embeddings列表)可训练并执行微调。虽然这种方法很有趣也很有用，但有一些注意事项需要记住:

1. 学习到的prompt Embeddings不能映射回文本prompt，因为模型词汇表中每个token的Embeddings是离散的。
2. 只有当我们能够访问语言模型的Embedding层时，我们才能使用这些方法。这种访问不是通过付费api(例如，来自OpenAI)提供的。

简单但功能强大。尽管本概述侧重于先进的prompt工程技术，但仍有许多简单的技巧可以轻松应用于改进LLM应用程序。例如，自一致性可以通过生成多个答案并取其平均值来提高大语言模型的可靠性。通过在prompt符的末尾附加一条语句，zero-shot CoT提示可以很容易地提高LLM推理能力。最后，生成的知识可以通过简单地要求模型在生成最终答案之前列出有关主题的有用信息来提高LLM的性能。在许多情况下，将简单的技巧添加到我们的prompt工程工具包中可以产生很大的不同!

原文：Advanced Prompt Engineering

注：本文中，提示和prompt几乎是等效的。

这是一篇非常全面介绍Prompt的文章，包括prompt作用于大模型的一些内在机制，和prompt可以如何对大模型进行“微调”。讲清楚了我们常常听到的一些名词的具体意思，包括zero-shot、few-shot、微调、对齐、指令、角色扮演等等。文章主要目的是为了让大家可以通过prompt工程来提高对大模型的使用能力。

由于LLMs的文本到文本格式，它们能够用单个模型解决各种各样的任务。这种能力最初是通过GPT-2和GPT-3等模型的zero-shot和few-shot学习来证明的。然而，当经过微调以符合人类偏好和指令时，大语言模型变得更加引人注目，使流行的生成应用程序成为可能，例如编码助手，信息搜索对话助理，基于聊天的搜索引擎体验。

由于它们使应用成为可能，大语言模型在研究界和流行文化中都迅速成名。在此过程中，我们也见证了一个新的互补领域的发展:prompt工程。在高层次上，大语言模型的操作方式是 *1)将文本(即prompt)作为输入，2)*生成文本输出，从中我们可以提取有用的东西(例如，分类，摘要，翻译等)。这种方法的灵活性是有益的。然而，与此同时，我们必须确定如何正确地构造我们的输入prompt，使LLM最有可能产生期望的输出。

prompt工程是研究如何使用不同的提示策略来优化LLM绩效的一门实证科学。虽然存在各种各样的方法，但我们将在本文中概述提示的一般机制，以及一些基本的(但非常有效的)提示技术，如zero/few-shot学习和指令提示。一路上，我们将学习实用的技巧和思想启示，可以立即采用，成为一个更有效的prompt工程师和LLM从业者。

了解大语言模型

由于它的重点是提示，这个概述不会解释大语言模型的历史或机制。为了更好地理解语言模型(这是深入理解提示的重要先决条件)，我编写了各种可用的概述。这些概述如下(按重要性排序):

• 语言建模基础(GPT和GPT-2)
• 尺度对语言模型的重要性(GPT-3)
• 现代和专业大语言模型
• PaLM， T5(v1和v2)， Llama(v1和v2)

Prompting一览

考虑到目前大语言模型如此火热，我们可能会问自己:*大语言模型的基本优势是什么，使它们如此强大?*虽然这个问题没有一个单一的答案(例如，模型规模，大规模预训练数据，人类反馈等)，但大语言模型的一个主要优势是它们通用的文本到文本格式。这些模型是猜测下一个token预测方面的专家，通过微调和对这个能力的延展应用，可以解决许多不同的任务!

为了解决一个任务，我们所需要做的就是 *1)向包含相关信息的模型提供文本输入，2)*从模型返回的文本中提取输出。这种统一的方法可用于翻译、摘要、问答、分类等。然而，事情并没有那么简单。也就是说，提供给LLM的prompt(即输入文本)的措辞和结构会显著影响模型的准确性。换句话说，prompt工程是一件大事，可能会极大程度影响你对LLM的使用效果。

什么是prompt工程?

“prompt工程是一门相对较新的学科，用于开发和优化prompts，以有效地将LMs用于各种应用和研究主题。” — from [2]

考虑到正确地制作我们的提示内容对于在LLM中获得有用的结果非常重要，prompt工程在最近几个月获得了很多兴趣。然而，这是一门经验科学——发现最好的提示通常是基于启发式的，需要实验。我们可以通过跟踪发现更好的提示，并测试不同的想法，看看哪些有效。

prompt的组成部分

有多种选择如何创建prompt的方法。然而，大多数prompts都由相同的几个(可选的)组件组成:

• 输入数据（Input Data）: 这是LLM期望处理的实际数据(例如，正在翻译或分类的句子，正在总结的文档等)。
• 范例(Examplars): 向LLM展示正确行为的最好方法之一是在提示符中提供一些具体的输入输出（键值对）示例。
• 指令(Instruction): 我们可以通过文本描述指令做什么，而不是在提示符中显示正确行为的具体示例;见下图。
• 指标(Indicators): 以固定和可预测的结构为LLM提供输入是有帮助的，因此我们可能会使用指标来区分提示的不同部分;见下文。
• 上下文(Context): 除了上述组件之外，我们可能希望以某种方式为LLM提供额外的“上下文”或信息。

一般技巧

prompt工程的细节根据所使用的模型和我们试图解决的任务而有很大的不同。然而，对于prompt工程，有一些被普遍接受的原则是有帮助的:

• 从简单提示开始：从一个简单的prompt开始，然后慢慢修改prompt，同时跟踪经验结果。
• 直接：如果我们希望LLM符合特定的风格或格式，我们应该清楚而直接地说明这一点。准确地说出你想要什么可以让你的信息传达出去。
• 专用性：模糊性是每个prompt工程师的敌人。我们应该让prompt变得详细和具体，而不是过分地提供太长的输入（例如，prompt可以有多长有限制）。
• 范例是强大的：如果描述我们想要什么是困难的，它可能是有用的，为几个不同的输入提供正确的输出或行为的具体例子。

上下文窗口（tokens限制）

当我们考虑不同的提示技巧和方法时，我们需要记住，我们只能在prompt符中包含有限的信息。所有大语言模型都有一个预定义的上下文窗口，该窗口对一次可以处理的tokens(即文本序列中的单词或子单词)的总数设置了限制。不同模型的上下文窗口大小不同，但目前有一种强烈的趋势是增加上下文窗口的大小。例如，GPT-4具有32Ktokens的上下文窗口，Claude.ai甚至达到了10万tokens。

常用prompt技巧

虽然大语言模型最近由于像ChatGPT这样的流行模型而出现了爆炸式增长，但提示已经存在了一段时间。最初，像GPT这样的模型被微调以解决下游任务。随着GPT-2的提出，我们看到研究人员开始使用零射击学习来解决单个基础模型的多个下游任务。最后，GPT-3向我们表明，随着语言模型规模的增长，它们在几次学习方面变得非常出色。在本节中，我们将介绍这些想法，以更好地了解零和少镜头学习的工作原理，并提供一些更复杂的提示技术的详细信息。

Zero-Shot学习

Zero-shot学习背后的想法非常简单。我们只需将正在解决的任务描述和相关输入数据提供给LLM，然后让它生成结果;见下图。由于他们观察到大量的预训练数据，大语言模型通常能够以这种方式解决任务。也就是说，他们可以利用自己的知识库来解决(相对)大量的任务;请参阅下面的示例(使用[GPT-3.5]制作。

像GPT-2这样的模型广泛地探索了zero-shot学习，并且在某些情况下表现良好。然而，如果zero-shot学习不能解决我们的任务，我们该怎么办? 在许多情况下，我们可以通过提供更具体和具体的信息来大幅提高LLM的性能。特别是，我们可以开始向prompt符添加所需输出的示例，从而允许模型从prompt中看到的数据复制模式。

Few-Shot学习

除了任务描述之外，我们还可以使用高质量的输入输出示例来增强prompt。这种技术形成了few-shot学习的基础，它试图通过提供正确行为的明确示例来提高LLM的性能。如果使用得当并应用到正确的模型中，few-shot学习是非常有效的，正如GPT-3等大语言模型的突破性能力所证明的那样;见下文。

然而，学习如何适当地利用大语言模型的少量学习能力可能是复杂的。我们应该在prompt中包括哪些例子?是否有正确的方法来组织prompt?对prompt的更改是否会显著影响LLM?

大多数大语言模型对构建prompt符的方式很敏感，这使得prompt工程既困难又重要。虽然像GPT-4这样的最新模型似乎对prompt中的小扰动不太敏感，但研究界为我们提供了一些正确使用few-shot学习的提示，这些提示仍然有助于理解:

• 范例排序很重要，排列少量示例可以极大地改变LLM的性能。包含更多的少量示例并不能解决这个问题。
• 在少量样本中的标签分布很重要，并且应该与野外数据的实际分布匹配。令人惊讶的是，标签的正确性并不是那么重要。
• 大语言模型倾向于重复少数几个例子中的最后一个(即近因偏差)。
• prompt中包含的示例应该是多样的，并且随机排序。

最优数据采样.

选择不同的、随机排序的、与测试示例相关的示例是最好的。然而，除了这些基本的直觉之外，已经进行了大量的研究来确定如何为prompt选择最佳范例。例如，可以通过多样性选择，基于不确定性的选择，甚至基于与测试样例相似度的选择来选择few-shot的学习样本。

Few-shot学习 vs. fine-tuning.

在继续之前，我想说明一个值得注意的混淆点。few-shot学习不是微调。 Few-shot学习向prompt内的LLM提供示例，然后可以将其用作生成正确输出的相关上下文。这个过程被称为“情境学习”；见上图。模型的参数不需要通过few-shot学习进行修改。相比之下，微调在选定的数据集上显式地训练模型(即通过反向传播更新其权重)。

指令提示

Few-shot学习非常强大，但它有一个明显的缺点：范例会消耗大量tokens。考虑到LLM的上下文窗口是有限的，我们可能希望探索不消耗那么多tokens的提示方法。例如，我们能否用文本向LLM解释正确的行为? 简短的回答是肯定的!这种技术只包括一个书面指令作为prompt的一部分，被称为指令提示符，它在特定类型的LLM中表现最好。

指令调整和对齐.

最近语言模型的发展主要集中在提高指令跟随能力上。预先训练过的大语言模型并不擅长遵循开箱即用的指令。然而，教这些模型如何遵循指令可以使它们更好地完成用户想要的东西(即，提高人类一致性)。遵循大语言模型的指令支持各种有用的应用程序，从信息搜索对话代理(例如，ChatGPT)到编码助手(例如，Codex);见下文。

正如在之前的文章中广泛讨论一样，创建LLM的第一步是使用语言建模目标在大型未标记的文本语料库上预训练模型。在此过程中，模型获取信息并学习准确地执行下一个token预测。然而，模型的输出并不总是有趣的、引人注目的或有帮助的，并且模型通常会努力遵守复杂的指令。为了鼓励这种行为，我们需要超越基本的预训练。

创建遵循指令的大语言模型.

教授LLM如何遵循指导有几种不同的方法。例如，我们可以执行指令调优，或者在包含指令的对话示例上微调LLM。几个著名的模型采用了这种方法，如Llama及其变体、所有FLAN模型、OPT-IML等。或者，我们可以使用由有监督微调(SFT)和人类反馈强化学习(RLHF)组成的三步法；见下文。这种方法导致了令人难以置信的模型的创建，如ChatGPT， GPT-4， Sparrow等等。

制作有用的指令.

如果我们有一个LLM，已经训练遵循指令，我们可以完成很多通过提示模型有用的和信息丰富的指令。以下是使用指令提示的一些关键提示和想法:

• 就像我们其他的prompt一样，说明应该是具体和详细的。
• 我们应该避免告诉LLM不要在prompt中做某事。相反，我们应该专注于告诉LLM该怎么做。
• 使用带有指示符的输入结构，在prompt内清楚地识别指令是有帮助的;见下文。

角色扮演的提示方法.

另一个与指令提示密切相关的有趣提示技术是角色提示，它将“角色”或人物角色分配给模型。这个角色在prompt中通过如下文本片段分配:

• 你是一位著名的杰出数学家。
• 你是个医生。
• 你是个音乐专家。

有趣的是，最近的大语言模型能够在整个对话过程中很好地承担和保持这样的角色。

更进一步说，角色提示不仅仅是一个有趣的技巧。为LLM提供一个角色实际上可以提高性能(例如，角色提示GPT-3为“杰出的数学家”可以在基于算术的问题上提高性能)。但是，角色提示仅在某些情况下提高性能。

“当给AI分配角色时，我们会给它一些背景。这种背景有助于AI更好地理解问题。随着对问题的更好理解，人工智能通常会给出更好的答案.” — 来自 learnprompting.org

现实世界中的指令提示

用指令提示大语言模型是一个非常强大的工具，我们可以将其用于各种应用程序。要了解如何利用这种技术，我们可以看看最近发布的ChatGPT插件，其中包括一个开源的信息检索API。在这个API中，有两个特定的模块用于从文档中提取元数据和过滤个人身份信息(PII)。有趣的是，这些服务完全基于llm，并使用如下所示的prompts。

在这些prompts中，为LLM提供了关于如何执行其所需任务的具体和详细的说明。该指令的一些值得注意的方面是:

• 明确声明所需的输出格式(json或true/false)。
• 该指令使用结构化格式(即，项目符号分隔列表)来描述重要信息。
• LLM的任务(即识别PII或提取元数据)在prompt中明确说明。
• 有趣的是，这些prompts会告诉模型在很多情况下不要做什么，这通常是不被建议的。

考虑到其局限性，信任LLM准确执行PII检测等关键任务可能不是最好的主意。尽管如此，这种方法展示了指令提示的不可思议的潜力。不需要编写整个程序或服务，我们可以通过编写prompt来快速解决许多任务。

启示

“为聊天机器人角色编写一个非常棒的prompt符是一项惊人的高杠杆技能，也是用一点自然语言编程的早期例子” — Sam Altman

如果我们没有从这个概述中学到其他东西，我们应该知道构建正确的prompt(即prompt工程)是在实践中成功利用大语言模型的很大一部分。语言模型由于其文本到文本的结构，具有令人难以置信的通用性，可用于解决各种任务。然而，我们必须为这些模型提供详细和适当的上下文，以便它们能够很好地执行。尽管最佳提示技巧因模型和任务的不同而不同，但我们可以利用许多高水平的提示来最大化成功的机会。

从zero-shot到few-shot。考虑到他们广泛的预训练(以及现在的微调)数据集，大语言模型包含大量信息，能够解决各种开箱即用的任务。为此，我们只向模型提供任务描述和相关输入数据，然后期望模型生成正确的输出。然而，由于提供给模型的有限上下文，zero-shot学习只能表现得还不错。为了进一步提高zero-shot学习的性能，我们应该通过在prompt中插入示例来利用few-shot学习。

遵循指令的大语言模型。虽然它表现得很好，但few-shot学习通常会消耗大量的tokens，这是一个问题，因为大多数大语言模型的上下文窗口有限。为了解决这个问题，我们可以采用一种指令提示方法，提供LLM期望行为的精确文本描述，而不是用正确输出的具体示例捕获这种行为。指令提示功能强大，但它需要经过微调的特定形式的LLM(例如，通过指令调优或RLHF)才能正常工作。预训练的大语言模型并不擅长开箱即用。

技巧和窍门。prompt工程提供了各种可以采用的技巧和最佳实践。通常，这些技术会随着每个新模型的发布而波动(例如，与之前的模型相比，GPT-4在处理非结构化prompts方面要好得多[2])，但是一些原则在相当长的一段时间内仍然适用。首先，我们应该总是从一个简单的prompt开始，然后慢慢增加复杂性。在开发prompt时，我们应该力求具体和详细，同时避免过于冗长(由于上下文窗口有限)。

原文：Practical Prompt Engineering

通过直观的拖放界面简化LangChain流程开发

在之前的一篇博客文章《LangFlow–可视化的LangChain》中，我们探讨了LangFlow的功能以及如何利用其直观的无代码界面。

今天，我很高兴地分享另一个类似的工具，它提供了一个无代码的拖放开发体验:Flowise。

Flowise为开发人员提供了一个特殊的工具，旨在构建LLM应用程序，而无需深入研究编码。对于努力以敏捷方式快速构建原型并开发LLM应用程序的组织来说，这同样是有益的。让我们来看看Flowise AI的一些突出功能:

• 拖放式UI: Flowise使设计自己的自定义LLM流程变得简单。

• 开源: 作为一个开源项目，Flowise可以自由使用和修改。

• 用户友好: Flowise很容易上手，即使对那些没有编码经验的人也是如此。

• 通用: Flowise AI可用于创建各种LLM应用程序。

安装和设置

要安装和开始使用Flowise，请遵循以下步骤:

1. 下载和安装 NodeJS >= 18.15.0 (使用node -v 查一下你安装的版本，如果不够高，那么我建议你直接在这个页面解决问题：https://nodejs.org/en/download)
2. 使用以下命令安装Flowise:

1

% npm install -g flowise

译者：这里比较啰嗦的可能就是各种版本问题了，如nodejs、npm等等。

3. 启动Flowise

1

% npx flowise start

译者：系统会要求你再安装flowise@1.x.x，安装就好了，还是那句话，如果不是root，别忘了sudo。

4. 在浏览器上打开 http://localhost:3000

   译者：我部署在家里的ubuntu上，所以地址会不一样。

现在您应该看到网站启动了。

接下来，我们将使用Flowise构建两个应用程序，这两个应用程序都不需要编码。

我们开看看丰富的组件，丰富程度让我有点吃惊，包括notion也都有。

示例1:构建基本LLM链

遵循以下步骤:

1. 在空白画布上，单击”+ Add New”按钮以调出左侧的”Add Nodes”面板。

2. 从“Add Nodes”面板中选择以下组件，它们将出现在画布上。

• 从LLMs中将OpenAI拖到面板
• 从Chains分类中拖出LLM chain
• 从Promps分类中拖出Prompt Template

现在，画布应该是这样的:

3. 连接组件

• 将OpenAI的输出（output）链接到LLM Chain的语言模型（input）
• 将Prompt Template的输出（output）链接到LLM Chain的Prompt（input）

4. 输入必要的信息

• 在OpenAI的字段中输入OpenAI密钥
• 将以下prompt模板写入“Prompt Template”的Template字段中:

What is a good name for a company that makes {product }?

• 给LLM Chain一个名字.
• 单击右上角的“保存”图标进行保存.
• 点击右上角的聊天图标，就可以开始发送“产品名称”了。在这里，我们得到了预期的答案.

示例2:构建PDF阅读器Bot

在之前的一篇博文中，我演示了如何使用LangFlow创建PDF Reader Bot。现在，让我们使用Flowise创建相同的机器人。

1. 将以下组件添加到空白画布中:

• 从“Text Splitters”中选择“Recursive Character Text Splitter”（递归字符文本分割器）
• 从“Document Loaders”中选择“PDF file”
• 从“Embeddings”中选择“OpenAI Embeddings”
• 从“Vector Stores”中选择“In-memory Vector Store”（内存向量存储）
• 从“LLMs”中选择“OpenAI”
• 从“Chains”中选择“Conversational Retrieval QA Chain”（对话检索QA Chain）

现在我们在画布中拥有了所有必需的组件。

2. 连接组件

• 链接“Recursive Character Text Splitter” 的输出和 “PDF file” 的输入
• 链接“PDF file” 的输出和 “In-memory Vector Store”的输入
• 链接“OpenAI Embeddings” 的输出和“In-memory Vector Store” 的输入
• 链接“In-memory Vector Store” 的输出和 “Conversational Retrieval QA Chain”的输入
• 链接“OpenAI” 的输出和 “Conversational Retrieval QA Chain” 的输入

3. 输入必要的信息

• 点击“PDF File”中的“Upload File”，上传标题为“Introduction to AWS Security”的示例PDF文件。
• 在“OpenAI”和“OpenAIEmbeddings”字段中输入您的OpenAI密钥
• 单击“save”按钮，然后单击聊天按钮开始发送请求。

响应应该如预期的那样，并且机器人现在可以回答与此pdf文档相关的任何问题。

总之，这篇博客介绍了Flowise，一个用户友好的、无代码的平台，它简化了构建LangChain工作流的过程。Flowise是一个开源工具，允许开发人员和组织创建LLM应用程序，而无需编写代码。该博客引导读者完成Flowise的安装和设置过程，并就如何构建两种类型的应用程序提供分步说明:基本的LLM链和PDF阅读器Bot。Flowise的关键特性，包括拖放式UI、用户友好性和多功能性，都得到了强调。

对了，Flowise的Github Repository。

后续再研究一下和ChatGLM、百川、通义等如何对接。

原文：Flowise: An Agile Way of LLM Application Development With No-Code Solution

表格无处不在。每次你登录一个网站，注册一个新闻订阅，或者回复一个论坛消息——你都在使用一个表单（form）。

表单对于设计的成功至关重要，无论是视觉上的还是商业上的。

从用户界面(UI)设计的角度来看，表单是允许用户向服务器发送信息的元素。我们可以想象一个表单看起来(和行为)就像你加入健身房时填写的一张纸。

由于表单是网站功能的基本组成部分之一，因此对UX/UI设计师来说，正确使用表单是至关重要的。构建有效的表单可以帮助您创建更令人愉快、可用和包容的用户界面设计——最终对您的用户体验和项目目标都有好处。

让我们来看看创建有影响力的表单UI设计到底需要什么。

表单设计基础

在你开始计划你的表单UI设计将会是什么样子之前，考虑一下你需要收集什么信息以及它需要如何组织(这被称为信息架构)。

对于某些表单，这样做非常简单——也许您只需要一个文本标签和一个电子邮件地址输入字段。提前规划表单的内容可以减少在项目后期将额外的表单元素挤进已经完成的界面设计中的风险。

以下是在初始计划阶段需要考虑的几点:

1. 尽量减少字段的数量

一般来说，表单中的字段越多，用户完成表单的可能性就越小。在任何补全很重要的情况下(几乎总是如此)，尽量减少使用的字段数量。

明显需要删除的字段是那些标记为“可选”的字段:如果它们是可选的，那么您是否真的需要这些信息?

2. 清楚地标记可选字段

如果您决定使用可选字段，请确保用户能够清楚地看到哪些字段是可选的。虽然用星号标记可选字段已成为界面设计人员的常见设计模式，但最终用户可能无法很好地理解星号的含义。相反，简单地用文本**(optional)**标记一些字段通常在视觉上不那么危险。

如何确定您的表单字段的层次结构

下面是一些注意事项，可以帮助您找到对输入字段排序的最佳方式。

3. 把关键约束放在首位

当你开始组织表单上的字段时，你必须根据三个关键约束来确定层次结构:

• **技术需求:**系统可能需要一个特定的数据块之前，它可以收集另一块信息，特别是如果你的表单使用条件逻辑来决定哪些字段显示给用户在任何给定的时间。
• 用户需求:当信息被逻辑分组时，当问题从“最简单”到“最难”时，人们通常能最好地理解表单。从最简单的问题开始可以帮助用户获得早期的“胜利”，这将使他们致力于完成表单问题。
• **业务需求:**对业务来说，最大限度地减少流程放弃可能很重要，这可能意味着创建一个“里程碑提交”，其中关键信息由表单中的特定点(里程碑)完成。

4. 逻辑分组字段

在选择表单字段的顺序时，要尽可能在逻辑上和主题上对它们进行分组。例如，如果您正在收集多个联系信息(电子邮件、电话、地址)，请将它们放在一起，而不是让它们出现在表单的不同位置。因此，帐户创建表单可能有三个部分:“个人信息”、“付款详细信息”、“营销偏好”。

在微观层面上，我们习惯于以特定的顺序看到某些类型的信息:例如，用户名和密码，或者街道地址和城市。在这里遵守约定可以减少用户的认知负担。

5. 可视化地分组字段

一旦定义了这些信息的逻辑组，请确保也以视觉方式反映这些分组。这可以简单地通过在组之间添加空格来实现，但您也可以考虑添加节标题或标签。

如何设计一个用户友好的表单布局

您的设计目标应该是帮助用户理解并轻松完成表单的所有组件，从输入字段到选择正确的单选按钮。这里有一些UI设计的最佳实践来指导基本的表单布局。

6. 将表单小心地放置在更宽的布局中

当用户与表单互动时，它是注意力的中心。表单在网页或应用屏幕中的位置应该反映出这个重要性。例如，即使是一个简单的注册表单也应该在整体设计中具有视觉突出性和中心性;不要把它压到角落或页脚作为事后的想法。

7. 使用单栏布局

尽管单栏布局在视觉上可能不那么优雅，但事实证明，它可以显著提高用户的理解能力，减少用户错误，提高总体转化率。这样做的原因可能是，在单列布局中，用户“错过”输入字段的机会更少;眼睛只需要进行简单的垂直运动，而不是z形运动。

当用户错过一个字段时，这将对用户完成表单所需的时间和他们所经历的挫败感产生显著的负面影响。这也破坏了他们通过表单取得进展的感觉，因为他们被迫返回并填写之前的字段。当这种情况发生时，用户更有可能完全放弃表单。

8. 将标签放在表单元素的上方，而不是左边

即使在单列布局中，也经常看到表单标签放置在输入区域的左侧。然而，这意味着用户的眼睛仍然需要沿着z形的路径，而不是简单的垂直方向，这可能会增加复杂、疲劳和缓慢的感觉。

9. 垂直排列列表、复选框和单选按钮

这为用户的眼睛强化了一个垂直的旅程，并支持一种一致的进步感。同样，它使用户不太可能错过列表中的选项。

10. 对标签和字段进行可视化分组

除了在节级别使用可视分组外，还要确保表单字段、与其相关的标签和任何辅助文本也在视觉上分组，并与周围的元素充分分离。

11. 对于较长的表单，使用分步或多屏幕格式

如果在一个屏幕上有大量的文本输入，这不仅会增加视觉超载的可能性，还会增加保存错误的风险。

一个简单的解决方案是将长表单拆分为多个屏幕或页面，并让用户了解在这个过程中他们可以期望看到多少个页面。

12. 不要将数字分割成多个输入字段

电话号码和信用卡号码应该只需要一个输入字段。多个输入字段可能会导致用户在打字时看着键盘时产生挫败感和错误。

13. 在移动设备上，使用本地操作系统的日期选择器和其他特殊输入功能

谷歌的Android和苹果的iOS都有内置的数据输入界面，比如日期选择器。尽可能使用这些本地元素，而不是自己编程。用户将更熟悉本机选项，并且它很可能表现得更好。

表单设计的UX复制注意事项

好的用户体验文案在表单设计中的作用被低估了。强大的文案可以导致更多的表单提交，并根据表单的功能增加业务收入。

当你为你的表格写副本时，这里有一些事情要记住。

14. 清晰简洁地标记字段

使用正确的语气，清晰简洁地传达标签和说明，不仅可以显著增加用户对形式的信任，还可以增加用户对整体品牌的信任。

在为每个表单字段编写标签时，要以最少的单词数和最大的清晰度为目标。如果您预计用户会有任何歧义或不确定，请包含一些简短的辅助文本，提供关于如何填写字段的明确说明。

在设计表单时，为每个字段的标记方式提供多个选项也会有所帮助。这使您能够测试不同的标签选项，或者至少在可用的替代方案之间做出明智的选择。

15. 在用户担心的地方解决问题

当你在你的网站上呈现一个表单让你的用户填写时，无论是一个简单的订阅还是注册表单，你都是在要求用户相信你，相信他们提交的所有信息。

询问某些信息可能会导致用户怀疑为什么要收集这些信息。例如，如果你要别人的电话号码，可以考虑加上帮助文本，解释你为什么需要它。(如果你真的不需要，那就不要要求!)

16. 在按钮上使用描述性的、基于动作的词语

按钮应该描述单击该按钮将启动的操作。有时候，特别是在技术性更强的应用程序中，“提交”和“取消”是可以的，但通常它们太枯燥，感觉太笼统。相反，可以考虑使用单词或短语，如“注册”、“发送信息”、“创建帐户”。

17. 考虑使用第一人称按钮

这取决于你的品牌风格指南，以及你想要的整体基调。然而，有研究表明，包含第一人称声音(“I”、“me”、“my”)的按钮往往具有更高的转化率。因此，你可以考虑“创建我的帐户”，而不是“创建帐户”。经验法则是，任何按钮文本都可以以“I want to”开头，这样既符合语法意义，又符合上下文的情感意义。

18. 不要使用占位符文本作为标签

占位符文本是在选择文本输入字段之前显示在该字段内的文本。使用占位符文本作为标签存在许多问题，包括:

• 占位符文本往往是灰色的，因此不太具有包容性和可访问性。

• 屏幕阅读器通常不会读取占位符文本，使您的表单对视障用户无法使用。

• 一旦你选择字段并开始输入，占位符文本就会消失，这意味着用户可能会忘记他们应该做什么。

• 占位符文本应该有助于数据输入格式，它不能，如果它被用作标签。

相反，使用“同时”标签和占位符文本来为用户提供最好和最有帮助的指导。

19. 不要在标签或占位符文本中使用全大写

大写文本通常比较难读，读起来也比较慢，所以不要将它用于表单主体(包括标签、占位符文本和辅助文本)。一般来说，如果少量使用大写文本，例如在节标题、按钮和图标中，大写文本是可以的。

20. 不要隐藏帮助文本

辅助文本是除了标签之外的指令或额外指导—例如，“密码应该是8个或更多字符”。如果您正在使用它，请显示它，而不是将它隐藏在问号图标或工具提示后面。

21. 明确所需的输入格式

在输入验证码、电话号码或信用卡详细信息等数据时，用户可能不确定是否可以或应该包含括号、空格和破折号等文本。在辅助文本中明确所需的输入，例如“输入您的卡号，不要有空格”。这样做可以减少认知负荷，让用户不再做决定。

22. 短比长好，只要不遗漏重要内容

我们已经提到了这一点，但值得重申的是:更少的表单字段比更多的表单字段更好。然而，如果你的表单太短，以至于没有收集到你需要的信息，那就适得其反了。阿尔伯特·爱因斯坦(Albert Einstein)偶尔说过一句自相矛盾的格言:“一切都应该尽可能地简单，但不要更简单。”

23. 在适当的地方使用确认信息

即使当用户主动单击“提交”按钮时，您也可能需要考虑显示一个确认对话框。同样，这可能适用于某些情况，例如动作非常重要，或者用户可能需要提醒检查他们输入的内容(例如发送工作申请)。

24. 使用成功状态

一旦用户提交了表单，重要的是要显示提交成功的确认信息。在最好的情况下，不这样做意味着用户没有完成感。在最坏的情况下，这可能意味着用户再次提交表单，可能会下重复订单。

25. 使用高x-height的无衬线字体

虽然精心选择的衬线字体可以很好地处理表单，但通常无衬线字体是更安全的选择。许多现代的无衬线字体——比如Roboto、San Francisco或Proxima nova——都是专门为屏幕使用而设计的。这些字体的一个重要特征是它们具有较大的x高度，这意味着小写字母相对较大。

可用性和验证

表单UI设计和复制完成后，是时候检查一些功能更强的设计组件和必须与开发团队沟通的交互了。

26. 优先使用内联验证提交验证

最好在用户的数据输入发生时进行验证，而不是在他们尝试提交表单或移动到下一个屏幕时进行所有验证。这部分是因为在用户已经在考虑信息时解决错误是有意义的，部分是因为在用户提交表单时显示错误会破坏用户的进度，使他们更有可能放弃而不是修复错误。

在适当的情况下，系统还应该提供帮助用户识别错误的确切性质的信息，例如，“这看起来不像足够的数字”或“您的意思是……?”

27. 除非绝对必要，否则不要使用验证码

验证码是那些小框，你必须在其中输入显示在颗粒状图像中的数字。它们已经被证明会严重影响流的完成，所以在转换很重要的地方，不应该使用验证码。

28. 使用内联验证来确认用户进度

使用内联验证来确认用户正在取得进展。这可能意味着一旦填写正确，字段旁边就会出现一个“勾号”图标。

29. 确保错误消息帮助用户修复错误

不要认为错误消息是不言自明的:信用卡号码旁边的“无效数据”可能无法帮助用户识别错误。相反，你可以这样说:“it looks like you missed a number”。

30. 在验证通过之前，禁用“Next”或“Submit”按钮

这为用户提供了一个清晰的视觉指示器，表明他们的数据条目已准备好提交。

测试表单的有效性

表单在你的设计原型中“有效”并不意味着它在网站或应用程序中执行后就会按照计划执行。最后的表单设计技巧都是关于测试的重要性，以及你想要检查的一些特定元素。

31. 测试所有表单输入字段和变量

在将表单发布到网站或应用程序之前，彻底测试表单非常重要。你需要测试的领域包括:

• 输入字段日期:检查以确保表单中的数据到达正确的位置。
• 输入错误:如果表单填写不正确，错误信息是否显示为设计?
• **条件逻辑:**如果你的输入字段依赖于条件逻辑，确保测试所有的路径和变量

32. 测试并优化所有主流浏览器的表单

表单在很大程度上依赖于浏览器如何编程来处理HTML表单元素，这意味着不同的设备和平台可能会产生意想不到的问题。从最常见的浏览器开始，但不要忽视边缘情况:根据StatCounter的数据，截至2018年10月，超过6%的人仍在使用ie浏览器。

此外，移动设备上的数据输入体验与桌面设备截然不同，所以要留出足够的时间和资源来测试和优化这两种设备格式。

33. 测试表单的移动友好性

确保表单字段在移动设备的小屏幕上易于使用和提交总是一个好主意。不同的设备呈现出不同的视觉和可用性限制。一个表单在桌面上的单一屏幕上运行良好，但对于移动设备的单一屏幕来说可能太多了。

在这种情况下，在手机上切换到多屏幕模式是有意义的，而不是坚持狭窄或冗长的单屏幕布局。

34. 利用真实用户

如果您有时间和资源，那么使用新表单进行发布前的用户测试也是很有价值的。这样做可以让你为参与者设定特定的任务，观察他们对填写表格的反应，并在他们完成后收集他们的关键反馈。

35. 发布后对表单进行A/B测试

测试不需要因为你发布了你的设计而结束。您可以继续试验—例如使用不同的输入字段、标签、布局和复制—甚至在表单运行之后也是如此。你可以使用A/B测试方法来比较不同设计的相对性能，无论是在转换、流程放弃、完成时间还是其他重要指标方面。

36. 测试表单的速度

成形速度在测试过程中经常被忽略。考虑以下指标:

• 系统最初加载和显示表单所需的时间
• 用户完成表单所需的时间
• 实际完成时间与用户期望的关系
• 系统处理表单并显示完成状态或消息所需的时间

此外，请记住，缺乏视觉交互设计可能会使表单处理看起来太快。在多屏幕表单中，表单会立即移动到下一个屏幕，这可能会导致用户没有意识到屏幕已经改变。在这种情况下，请考虑使用视觉过渡来帮助用户理解表单已移动到下一个屏幕。

总结

有效的表单UI设计并不局限于视觉美学。是的，有一些组件和设计模式属于UI设计领域。但在其核心，每个表单还必须包括周到的用户体验复制，交互设计，以及对用户将如何与表单交互的整体理解。

使用本文中列出的基本原则将帮助您向用户交付愉快的体验，然后您可以根据需要对其进行测试和修改。

原文：Form UI Design: 36 Tips & Best Practices

独立咨询业务被低估了，来看看可以如何开始。

上周，一些读者给我发了电子邮件，想听听我为什么要创办咨询公司，以及如何开始创业。

所以，如果你曾经考虑过创办一家咨询公司，这篇文章就是为你准备的。

许多人将创业等同于建立风险投资规模的初创公司。

但创业只是众多创业方式中的一种。事实上，创业可能是你所能做出的最困难的选择。

初创公司通常不会在很长一段时间内盈利，因为他们优先考虑的是增长。对于那些要养家糊口或没有很多积蓄的人来说，这是不可持续的。

此外，许多创始人没有意识到，初创公司必须以什么样的速度成长，才能证明风险投资是合理的。

在安德鲁·陈的书《冷启动问题》中，他说风险投资规模的公司必须达到特定的里程碑，以便能够进行IPO:

• 第一年-建立产品市场契合度
• 第二年-年度经常性收入(ARR)达到200万美元
• 第三年- ARR增加两倍至600万美元
• 第四年-增加两倍至1800万美元
• 第五年-翻倍至3,600万美元
• 第六年-翻倍至7200万美元
• 第七年-翻倍至1.44亿美元

想象一下，试图在两年内让一家企业的ARR达到200万美元。这是一个疯狂的增长速度，对99%的企业家来说是不合理的，包括我自己。

相反，更多的企业家应该考虑创办咨询公司

它更容易实现，也能帮助你避免所有初次创业者常犯的错误。

首先，咨询能保证你解决一个真正的问题

客户付钱给你告诉你他们的问题是对问题存在的确认。它让你首先考虑客户的问题，而不是在寻找问题的过程中构建解决方案。

第二，咨询比开发产品要快

作为顾问，你就是产品。这样你就可以避免6个月后才意识到自己没有办法为产品创造流量的典型错误。咨询让你从第一天开始就专注于推销自己。

最后，咨询是日后构建产品的垫脚石

这是一种赚钱的方式，当你为未来的客户构思什么时，你可以做客户研究。难怪许多公司实际上是以咨询公司起家的。

例如，Palantir通过帮助不同的机构统一他们的数据库，从政府咨询开始。随着时间的推移，他们注意到所有客户之间的共性，并将他们的产品产品化为3个主要的SaaS产品。

想象一下，如果他们在没有咨询的情况下就试图构建SaaS产品，他们不太可能理解如何构建正确的产品。咨询还帮助他们建立了一个客户名单，以便以后销售他们未来的产品。

开始咨询的剧本

顾问只不过是他们所在领域的专家。因此，创办咨询公司是一种品牌建设活动，可以将自己定位为权威人士。幸运的是，这比你想象的要简单，因为有一个你可以遵循的剧本。

它是这样的:

1. 制作时事通讯
2. 在你的邮件列表中加入潜在客户
3. 就你想咨询的话题写10篇文章。
4. 利用这些文章来推销咨询服务
5. 从你的工作经验或(理想情况下)过去的约定中学习，作为未来文章的内容。
6. 清洗并重复步骤3-5。

内容吸引客户，创造更多的内容来写，吸引更多的客户。这是一个无限循环。

这之所以有效，是因为互联网上的90-9-1规则。这说明:

• 90%的互联网用户是潜伏者
• 9%的人会点赞和评论
• 1%的人负责内容的创建。

因此，通过写文章，你自动成为在互联网上谈论你的话题的前1%的人。

从定义上说，这让你成为一个领导者。

创造内容会自动让你进入互联网的前1%。

事实上，我注意到这几乎就是Dan Shipper用来将自己定位为生成AI权威的剧本。

Dan是Every公司的CEO。我是从他的Lenny ‘s newsletter上关于如何构建Chat-GPT bot的热门客座帖子中了解到他的。

当我调查他的历史时，我意识到他基本上是按照这个剧本来的。

自去年12月以来，他的通讯中几乎所有的内容都转向了谈论人工智能:他如何在日常生活中使用Chat-GPT，它将如何影响作家，以及他如何构建机器人的教程。

这让他成为了一个很好的顾问，因为人们在评论中询问他们是否可以雇佣他为他们建造机器人。

他的内容实际上推动了潜在的咨询业务，为其他人构建聊天机器人。

另一件有趣的事是，我注意到他是最大的风险投资公司之一红杉资本(Sequoia)的人工智能创业公司探星员。

我怀疑他之所以与红杉合作，是因为他们知道他的文章可以作为吸引人工智能创业公司的磁铁。他吸引的那些初创公司也是他可以为其人工智能战略提供咨询的初创公司。

我注意到Dan成为红杉球探的同时，他的内容也转向了人工智能。

所以为了帮助你开始，写一些文章来讨论:

1. 人们对你的领域有哪些不了解?

2. 人们常犯的错误是什么?他们如何避免这些错误?

3. 你所在领域的未来会是什么样子?

然后，当你的图书馆建立起来的时候，考虑把它们收集起来，然后自行出版一本关于这个主题的书。

建立多种收入来源

写一本关于你所在领域的书应该是每一个咨询师的目标

没有什么比写一本关于某个主题的书更能建立权威了。它甚至不需要很长。

在亚马逊上出版了20多本书的Greg Lim (https://twitter.com/greglim81)经常在他的“兼职亚马逊作家班”(https://gumroad.com/a/336418515) (aff.)上建议学生写2万字左右的短篇小说。这相当于20篇文章，在一年的时间里是可以完成的。

然后你就可以用那本书作为你咨询的引线。

事实上，我认识一位名叫丹•戈尔迪的财富顾问，他开了一家财富管理公司，后来出版了一本名为《投资答案》的书，详细介绍了他的财富管理哲学。

他说，这本书出版后，他的生意迅速发展。想象一下，如果你在你的领域这样做，它也会真正改变你的咨询业务的轨迹。

丹·戈尔迪的书帮助他销售了金融咨询服务。

此外，这本书是一个设置多个收入来源。咨询费用昂贵，但很难规模化。然而，一本书是高度可扩展的，但相对便宜。

因此，书籍可以作为一种补充收入，帮助你抓住那些对价格最敏感的客户，他们可能负担不起你的服务，但仍然需要你的建议。

有了一本书，你就在价格-需求曲线上获得了多个点:一个是底部的书，一个是顶部的咨询。

这也是一个创建多个收入流的设置，以平衡咨询收入的可变性。

书籍很好地补充了咨询，因为它们处于定价范围的两端。

为什么你必须挖掘你现有的网络

第二种最好的开始咨询的方式是询问你现有的朋友，如果他们知道谁可能需要你的服务。人脉是你拥有的最大资产，在尝试其他选择之前，你应该好好挖掘人脉。

为什么这应该是你的第一个方法?这也是传销教新员工首先把产品卖给家人和朋友的原因。就连他们也知道直接联系的力量。

利用你现有的人际关系应该是你的第一选择，而不是最后选择。

在你当前的人际网络中，可以利用的一些人包括:

过往的客户

每隔一段时间，与过去的客户打个招呼，了解一下他们的情况是值得的，因为他们可能会给你带来即将到来的交易。这就是房地产经纪人给他们以前的客户寄圣诞卡时所做的事情。

他们之所以这样做，是因为大量发送这些卡片会让他们的老客户想起他们，这每年都会带来额外的交易。

不要拒绝招聘人员

如果有招聘人员联系你，即使你不是在找工作，也不要拒绝他们!招聘人员是身边人脉最广的人，他们可能知道哪些公司正在寻求咨询方面的帮助。

如果招聘人员联系你，你可以使用下面的脚本。

“谢谢你的帮助。你觉得我能不能更像个顾问，而不是全职工作?“

”我目前还没有找到全职工作，但我愿意接受其他安排。”

MyLance的创始人布拉德利·雅各布斯曾经发过12封这样的邮件，得到了11封“不”。但第12个人说他们愿意接受，他说“愿意”，突然把他推到了每月2.5万美元的兼职创业咨询工作上。

所以，对每一个来找你的招聘人员都做出回应，你可能也会得到一份不错的咨询工作。

现实生活中的社区

不要忘记你所在的现有社区:教堂、体育联盟和你的朋友都是可以密切关注与你相关的交易并将其发送给你的人。

此外，你遇到的每个人都是未来潜在的推荐人。所以一定要找机会让他们给你推荐。

我的做法是，如果有人问我的工作是什么，我会说我帮助初创公司打造MVP，我经营着一家“不差的开发机构”。如果他们知道有人在找开发商店，就把他们送到我这里。

我发现，当话题转向工作时，提出这个问题是一个自然的过渡，可以把这个要求塞进去。

如果不谈工作，有时我会在谈话结束时提出最后一个要求。人们通常都非常愿意帮忙。

克服寻求帮助的恐惧

作为一名顾问，你必须不要脸地把自己放在那里，提出这些要求。我为此挣扎，因为我的父母告诉我，除非我绝对需要帮助，否则永远不要寻求帮助。

但在咨询行业，你的人际网络应该是你的第一选择，而不是最后选择

事实上，这太重要了，我现在要无耻地说:

如果你知道有人在找人开发一个商城/AI问答程序/本地化大模型/APP/文化旅游类的业务，需要一个业务架构或者产品设计，请介绍他们给我 -感谢您的推荐!

瞧，就连我也得这么做。希望你们也不会被它困扰。所以如果我能克服它，做出这些请求，那么你也可以。

最终的想法

在咨询工作中，我最喜欢的部分是结识来自世界各地的新朋友，听听他们在做什么。

咨询也会让你知道你的知识和经验是多么有价值。许多人担心他们没有足够的经验来咨询，但经验是相对的。对于一个在你的领域没有经验的客户来说，你的建议会对他们的业务产生重大影响。

所以走出去，把自己定位为专家，完成那些咨询交易。我相信你!

原文：Stop Building Startups. Start Consulting Instead.

原文：The LangChain Alternative You Absolutely Need To Master

使用LangChain一段时间后，我们需要重新定义，看看它的问题和其他替代品:

LangChain的问题

对于开发利用大型语言模型的应用程序来说，LangChain是一个非常强大的工具。它的功能包括链接prompts、利用健壮的代理以及将大语言模型连接到您的数据。

然而，在我使用LangChain的经验中，我经常发现直接使用OpenAI API更简单。有时，使用LangChain的过程似乎不必要地复杂和令人费解，这使得与OpenAI API的直接交互成为一个更有吸引力的选择。

显然，在使用了LangChain之后，我并不是唯一一个有这种想法的人，因为我在HackerNews上发现了一篇深入研究该工具问题的文章。

LangChain的支持者认为，它可以演变成用于基础模型的Streamlit。Streamlit是一个用于机器学习和数据科学任务的开源应用程序框架。同样，LangChain可以让工程师快速制作概念验证(POC)或投资者演示的演示。此外，如果开发人员想要深入研究，他们可以选择在自己的堆栈上构建，从而增强LangChain的实用性。

然而，尽管有这些好处，人们还是提出了一些担忧。一些用户批评LangChain的不透明性，当需要深入理解一个方法时，这就成为一个重大问题。此外，单行程序的使用虽然在工作时很有帮助，但在不起作用时可能会成为一个相当大的障碍。

LangChain是围绕OpenAI栈构建的，在一些人认为应该是确定性的任务中采用随机过程。这方面的一个例子是LangChain使用语言模型为检索QA提供源，而不是最接近的匹配Embedding。这种方法有时会引入不必要的复杂性。

类似地，当开发人员超越原型时，LangChain似乎失去了有效性。它变得越来越抽象和固执己见，缺乏足够的文档来加剧这些挑战。因此，对一些人来说，LangChain可能会变成一种负担，而不是一种帮助。

尽管存在这些批评，但一些人认为，这些问题中的许多都可以迅速得到解决或解决。对文档和工具的调试功能的增强可以缓解其中的一些问题。此外，虽然LangChain的Python包装器可能不适合所有项目，但它提供了许多开发人员所欣赏的便利程度。

我决定尝试帖子中提出的更简单的替代方案，名为simpleaichat，并发现它非常吸引人。

在接下来的章节中，我将阐述为什么我觉得这个更直接的选择如此吸引人。

GitHub - minimaxir/simpleaichat

评估simpleaichat

快速浏览一下它的文档就会发现simpleaichat是非常用户友好的。为了评估它的能力，我决定创建一个AI代理，可以在国际象棋中与Stockfish引擎竞争。我之所以选择这个项目，是因为我以前曾尝试过使用LangChain来实现它，结果证明它过于复杂。通过使用simplaichat重新创建这个项目，我希望能够快速评估它的用户友好性和效率。

创建一个AI国际象棋代理，使用simplaichat与Stockfish引擎对弈，这个概念确实很吸引人。我决定开始这个项目，之前我尝试过用LangChain来构建它，这是一个更具挑战性的努力。用simplaichat实现它似乎是一个合乎逻辑的步骤，可以更深入地理解它的用户友好性。

为了启动这个项目，让Stockfish引擎充当我的AI象棋代理的对手是至关重要的。我决定使用GPT-4作为人工智能的大脑，因为它具有先进的语言学习模型(LLM)功能。

与之前的尝试相比，使用SimpleAIChat实现这一目标的过程被证明是轻而易举的。该工具框架和所需代码的透明度和简单性与我使用过的其他模型形成鲜明对比。

下面是我实现的代码片段:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

import chess
import chess.engine
from mytoken import apikey
import json
from simpleaichat import AIChat
from pydantic import BaseModel, Field

BASE_PROMPT = """
Imagine you are a renowned chess master with decades of experience.
A critical moment arises in a high-stakes tournament game. It's your turn to
move, and you have multiple promising options on the board. How do you approach
this situation? What factors do you consider when deciding which move to play?
Share your expert analysis, evaluating the strengths and weaknesses of each
candidate move and explaining the reasoning behind your final choice. Your
insights and strategic guidance will be highly valued by aspiring chess
players worldwide. Show us the brilliance of a true chess master! Make sure
to anticipate how your adversary may react and plan at least five steps ahead
of your opponent. Take into account the opening principles, positional
considerations, coordination of pieces, threat assessment, and endgame
strategies. Provide a comprehensive analysis that encompasses all stages of
the game and showcases your expertise. Inspire chess enthusiasts around the
globe with your strategic prowess and demonstrate how you would triumph in
this critical moment."
"""

AI_agent = AIChat(
    console=False,
    api_key=apikey,
    model="gpt-4-0613",
    params={"temperature": 0.0}
)


class get_move(BaseModel):
    """UCI move information"""
    move: str = Field(description="UCI move recommended")
    Strategy: str = Field(description="Explanation of the UCI move recommended")

# Initialize a chess board and the chess engine
engine = chess.engine.SimpleEngine.popen_uci("/opt/homebrew/Cellar/stockfish/16/bin/stockfish")


def play_game():
    white_moves = []  # Variable to store the list of White's moves
    black_moves = []  # Variable to store the list of Black's moves
    board = chess.Board()

    def get_gpt4_move(board):
        feedback = ""
        while True:
            prompt = f"Current board: {board} White's move history: {white_moves}\nBlack's move history: {black_moves}\n\nChoose the next move for black in UCI format. The available legal moves are {list(board.legal_moves)}. {feedback}"

            response = AI_agent(f"{BASE_PROMPT} {prompt}", output_schema=get_move)

            next_move = response["move"]

            try:
                move = chess.Move.from_uci(next_move)
                if move in board.legal_moves:
                    return move
                else:
                    feedback = f"AI agent's generated move {move} is not valid currently."
                    print(feedback)
            except:
                feedback = "Failed to parse AI agent's generated move. Retrying..."
                print(feedback)

    while not board.is_game_over():
        if board.turn:  # True for white's turn, False for black's turn
            result = engine.play(board, chess.engine.Limit(time=2.0))
            board.push(result.move)
            white_moves.append(result.move.uci())  # Store UCI move in the list
        else:
            move = get_gpt4_move(board)
            board.push(move)
            black_moves.append(move.uci())  # Store UCI move in the list
        print(board)
        print("\n\n")

    # Check the result of the game
    if board.is_checkmate():
        if board.turn:
            return "AI Agent wins by checkmate"
        else:
            return "Stockfish wins by checkmate"
    elif board.is_stalemate() or board.is_insufficient_material() or board.is_seventyfive_moves() or board.is_fivefold_repetition() or board.is_variant_draw():
        return "The game is a draw"
    else:
        return "The game is not over"

    engine.quit()


# Run the game 10 times and store results
results = {"AI agent wins by checkmate": 0, "Stockfish wins by checkmate": 0, "The game is a draw": 0, "The game is not over": 0}

for i in range(5):
    result = play_game()
    results[result] += 1

print(results)

这段代码促进了人工智能代理和Stockfish引擎之间的国际象棋游戏。它收集并显示双方的移动，允许AI评估和选择移动，并评估游戏状态以确定胜利者。

多次运行此代码将提供有趣的结果，这些结果将在最后存储和输出。

总之，这个练习证明了simpleaichat确实是一个更容易访问和直接的工具来开发基于人工智能的应用程序。通过减少通常与AI开发相关的障碍和复杂性，它可以使项目开发更加流畅和愉快。

原文：Free AI Tool to Turn Midjourney Images into Videos in Discord!

告别复杂的视频编辑工具和耗时的制作过程。Pika Labs推出创新的文本和图像到视频平台，只需键入即可激发您的创造力。

这个平台使您能够将Midjourney的图像转换为引人入胜的视频!最好的部分是什么?它在测试阶段是免费的!

释放您的创造潜力，见证您的图像转化为惊人的视频!

Pika Labs是什么?

Pika Labs是一个创新的视频创作工具，允许您将文本和图像转换为迷人的视频。所有这些都可以在Discord中完成!

以前，只有邀请才能访问，但现在公众都可以访问!

今天，让我带领你通过使用皮卡实验室视频创作的迷人过程，在那里你的想法通过输入你想要的文本来实现!

Video Generation — 如何开始?

1. 加入Pika Beta，点这里
2. 一旦你进入了Pika Labs Discord服务器，转到其中一个“#generate”频道。

3. 使用“/create”命令添加一个图像和你的prompt说明。

4. 点击“return”，视频就会生成。就是这么简单!

与Gen-2不同，在Gen-2中，文本将提供对视频创作的更大控制，PikaLabs将文本更好地与图像完美结合。

.. Tip: 不断测试你的prompt

正如你从上图所看到的，它看起来有点奇怪，因为熊先生看起来是静止的，所以我把我的prompt改为“Bear casting magic”（熊施法），让它有更多的运动。这就是结果!

这里还有一些视频。

创造性的用法

除了简单地将图像转换为视频之外，还有一些创造性的使用特定的prompts来提升您的图像。

令人兴奋的视频

Pika Labs非常适合在食物摄影中添加运动，可以唤起情感，增加能量，突出纹理，并在图像中创造故事。

动作刺激食欲，使食物诱人，展示丰富，并吸引观众。尝试将以下关键字添加到prompts中:

• Powder and Spices Exploding（粉末和香料爆炸）
• Pulling of cheese（拉奶酪）
• Sauce dripping（酱汁滴）
• Smoke and Flame（烟与火焰）
• Water Splashing（溅水）

惊人的景观

它也非常适合结合运动来增强你的风景和景观。试着这样做:

• Aurora（极光）
• Lava Flowing（熔岩流动）
• Shooting Stars（流星）
• River flowing（河水流动）
• Tree moving（树木摇动）
• Waterfalls flowing（流动的瀑布）

添加天气元素是另一个提升大气层的好方法:

• Raining（雨）
• Thunder and lighting（雷电）
• Foggy（雾蒙蒙）
• Sun shining in（阳光照进来）

表现背景图

增强令人惊叹的背景流动或滴水的运动，完美的互动展览和演示!

• Paint Dripping（油漆滴下）

• Ink Spreading（泼墨）

• Liquid Flowing（液体流动）

• Watercolor Splashing（水彩泼洒）

让奇怪的图像更奇怪

它也可以很好地处理奇怪的图像!

参数

你也可以创建一个视频简单的文本prompt符和参数一起微调你的视频，这里有一些是目前可用的:

• -gs xx: 指导刻度，数值越高越与文本相关(建议范围为8-24)
• -neg “xxx”: 否定prompt(指定您不希望在视频中出现的内容)
• -ar xx:xx : 长宽比 (e.g., 16:9, 9:16, 1:1, 4:5)
• -seed xxx: 增加世代一致性的种子数
• -motion xx: 所需运动强度(仅支持0/1/2)

.. 注意，Pika Labs的参数只需要一个破折号“-”。

最终的想法

有时候，你需要更精确地使用文本prompt，添加太多的动作可能会导致像这样的糟糕视频。

和往常一样，需要反复试验才能知道什么样的prompts最能产生你想象的结果。从其他用户那里获得灵感也是一种有价值的学习和提高的方式!

上面提到的所有关键字都可以用来结合你的prompts与Midjourney制作图像。

原文：Leveraging Llama 2 Features in Real-world Applications: Building Scalable Chatbots with FastAPI, Celery, Redis, and Docker

深入探索:开源与闭源大语言模型，剖析Llama2的独特功能，掌握prompt工程的艺术，并设计与FastAPI，Celery，Redis和Docker健壮的解决方案。

概览

出乎意料的是，Meta在几天前开源了他们的大型语言模型(LLM) Llama 2，这一决定可能会重塑当前人工智能发展的格局。它为OpenAI和谷歌等领域的主要公司提供了另一种选择，这些公司决定严格控制自己的人工智能模型，限制可访问性，限制更广泛的创新。希望Meta的决定能够激发开源社区的集体反应，从而抵消限制访问该领域进展的趋势。Llama2的新授权甚至更进一步，允许商业使用，允许开发人员和企业在现有和新产品中利用该模型。

Llama2系列由预训练和微调的大语言模型组成，包括Llama2和Llama2- chat，可扩展到70B参数。这些模型已被证明在各种基准测试中比开源模型表现得更好 [1] 。他们还坚持反对一些闭源模型，为开源人工智能的发展提供了急需的推动力[2]。

如果你关注HuggingFace的Open LLM排行榜，你会发现Meta的Llama 2占据了第三的位置。在Llama 2发布之后，Stability AI发布了FreeWilly1和FreeWilly2[3]。FreeWilly1是Llama的一个微调版本，而FreeWilly2是Llama 2的一个微调版本。Stability AI分享说，他们在orca风格的数据集上对这两个模型进行了微调。Orca数据集是一个大型的、结构化的增强数据集，旨在对大语言模型进行微调，其中每个条目由一个问题和GPT-4或GPT-3.5的相应响应组成。为什么我们不使用FreeWilly2模式?不幸的是，虽然Llama2允许商业用途，但FreeWilly2只能用于研究目的，受非商业知识共享许可(CC BY-NC-4.0)的约束。

在本文中，我们还将通过使用FastAPI、Celery、Redis和Docker以及Meta的Llama 2来构建一个强大且可扩展的聊天应用程序。我们的目标是创建一个高效、实时的应用程序，它可以处理多个并发用户请求，并将LLM的响应处理转移到任务队列中。它允许应用程序保持响应性，我们可以使用Redis有效地管理任务。最后，我们将介绍Docker的部署和扩展。应用程序应该演示这些技术如何协同工作以提供大规模的良好聊天体验，展示像Llama 2这样的开源语言模型在商业环境中的潜力。所以让我们潜入并开始构建吧!

开源vs闭源

我们目睹了公司和研究小组几乎每周发布新模型，或开源或闭源。因此，谁将赢得人工智能军备竞赛?为了给出一个有根据的猜测，我们需要了解这些模型训练过程的几个方面。

研究人员在广泛的自监督数据上使用自回归transformers作为起点。让我们先来分析一下什么是自回归transformers和自监督数据。自回归transformers是transformers模型的一种变体，广泛用于涉及顺序数据的任务，特别是在自然语言处理(NLP)中。这些模型以自回归的方式生成序列，即:它们一次生成序列的一部分，并使用它们之前的输出作为后续步骤的输入。这使得它们特别擅长语言翻译、文本生成等任务，在这些任务中，前一个数据点的上下文会影响下一个数据点的预测。自监督学习是一种由输入数据本身提供训练标签的学习方法。它通过学习预测其他数据的某些部分，消除了明确的手动标记的需要，并允许探索大量未标记的数据。

下一步，研究人员通常会使用强化学习与人类反馈(RLHF)等技术来训练模型，使其与人类偏好保持一致。在RLHF中，人工智能系统从基于其做出的决策的反馈中学习。它包括创建一个奖励模型，AI系统使用该模型来学习哪些行为会导致积极和消极的结果。其目的是使人工智能系统的行为与人类的价值观和偏好保持一致。

那么，开源社区面临的主要挑战是什么呢?

这两个步骤都需要强大的计算能力。其次，公司在校准步骤中使用他们的专有数据来微调他们的模型，大大提高了他们的可用性和安全性。

Llama2系列模型

Llama2是Llama1的高级版本，基于一种新的公共可用数据组合进行训练。关键的改进包括预训练语料库大小增加了40%，模型的上下文长度增加了一倍，并采用分组查询关注来提高大型模型的推理可扩展性。分组查询注意是对transformers模型中标准注意机制的改进，用于降低计算成本。分组查询注意不是为每对输入和输出位置计算注意分数，这可能是资源密集型的，而是将查询分成组并一起处理它们。该方法保留了标准注意力的大部分有效性，同时通过降低计算复杂度来处理更长的序列或更大的模型。

训练语料库由来自公开来源的新混合数据组成(没有使用Meta产品或服务的数据)。此外，还努力消除已知含有大量个人信息的网站上的数据。训练数据包含2万亿个tokens，研究团队决定对最真实的来源进行上采样，以提高知识的准确性。

Llama2的改型采用7B、13B和70B参数现在可用。Llama2- chat是Llama2的对话优化、微调版本，也提供7B、13B和70B参数。

Llama 2的Prompt工程

Prompt工程帮助我们引导大语言模型以某种方式行事，其中包括Llama 2。在Llama 2的上下文中，prompt指的是给出给模型的初始指令或查询，然后模型使用这些指令或查询来生成响应。然而，在Llama 2中，prompts可以非常详细，并且可以包含设置模型的上下文或“个性”的系统消息。

Llama2使用独特的prompt格式启动对话。它看起来是这样的:

该模板与模型的训练过程一致，因此对输出的质量影响很大。在这个模板中，system_prompt表示模型的指令或上下文。

这里有一个例子:

system_prompt 提供了模型的一般说明，它将指导它的所有响应。用户的消息遵循系统prompt并从模型中寻求特定的响应。

在多回合对话中，用户和机器人之间的所有交互都附加到前面的prompt符中，并包含在[INST]标签中。它看起来是这样的:

每个新的用户消息和模型响应都被添加到现有会话中，从而保留上下文。

需要注意的是，与许多AI模型一样，Llama2是无状态的，不会“记住”之前的对话。因此，有必要在每次prompt模型时提供整个上下文。这就是为什么Meta致力于增加Llama2的上下文窗口的原因。

最后，prompt工程与其说是一门科学，不如说是一门艺术。掌握它的最好方法是通过不断的测试和完善。创造性地使用prompts，尝试不同的格式和说明。此外，不同的大语言模型受益于不同类型的prompts。

解决方案架构设计:FastAPI、Celery、Redis和Docker

在本系列中，我们一直使用FastAPI来构建我们的ML应用程序。它是一个用于构建api的高性能web框架。在这种情况下，它的异步功能使其能够并发地处理多个请求，这对于实时聊天应用程序是至关重要的。

除了FastAPI，我们还使用Celery作为分布式任务队列，以帮助管理从LLM生成响应的计算密集型任务。通过将此进程卸载到任务队列，应用程序在处理其他用户请求的同时保持对新用户请求的响应，从而确保用户不会等待。由于我们使用的是分布式任务队列，因此需要一个消息代理来帮助异步任务处理。我们选择Redis来完成这项工作。它将FastAPI中的任务排在队列中，等待Celery进行处理，从而实现高效、解耦的通信。此外，Redis的内存数据结构存储速度很快，允许实时分析、会话缓存和维护用户会话数据。

遵循最佳实践，我们使用Docker将应用程序及其依赖封装到独立的容器中，这样我们就可以轻松地将其部署到各种环境中。

用Llama2、FastAPI、Redis和Celery构建一个聊天API

本指南解释了如何使用Llama2与FastAPI, Redis和Celery建立一个应用程序。我们将介绍这些概念以及它们是如何协同工作的。在我们的架构中，FastAPI用于创建一个接受传入请求的web服务器，Celery用于管理异步任务，Redis作为Celery的代理和后端，存储任务及其结果。

APPLICATION

FastAPI应用程序(app.py)由用于生成文本和获取任务结果的端点组成。/generate/端点接受带有prompt符作为输入的POST请求，并返回任务ID。它使用Celery任务generate_text_task异步启动任务。/task/{task_id}端点通过任务ID获取任务的状态/结果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

from fastapi import FastAPI
from pydantic import BaseModel
from celery.result import AsyncResult
from typing import Any
from celery_worker import generate_text_task
from dotenv import load_dotenv

load_dotenv()

app = FastAPI()


class Item(BaseModel):
    prompt: str


@app.post("/generate/")
async def generate_text(item: Item) -> Any:
    task = generate_text_task.delay(item.prompt)
    return {"task_id": task.id}


@app.get("/task/{task_id}")
async def get_task(task_id: str) -> Any:
    result = AsyncResult(task_id)
    if result.ready():
        res = result.get()
        return {"result": res[0],
                "time": res[1],
                "memory": res[2]}
    else:
        return {"status": "Task not completed yet"}

Workers

Celery工作器(celery_worker.py)文件创建一个Celery实例并定义generate_text_task函数。该函数接受prompt并使用Llama 2模型生成文本。这个函数用@celery.task decorator注册为一个Celery任务。

setup_model函数是一个worker初始化函数。它在工作进程启动时设置模型加载器。这个函数被注册为使用@signals.worker_process_init.connect decorator在工作进程初始化事件中调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

from celery import Celery, signals
from utils import generate_output
from model_loader import ModelLoader


def make_celery(app_name=__name__):
    backend = broker = 'redis://llama2_redis_1:6379/0'
    return Celery(app_name, backend=backend, broker=broker)


celery = make_celery()

model_loader = None
model_path = "meta-llama/Llama-2-7b-chat-hf"


@signals.worker_process_init.connect
def setup_model(signal, sender, **kwargs):
    global model_loader
    model_loader = ModelLoader(model_path)


@celery.task
def generate_text_task(prompt):
    time, memory, outputs = generate_output(
        prompt, model_loader.model, model_loader.tokenizer
    )
    return model_loader.tokenizer.decode(outputs[0]), time, memory

Model

model_loader.py中的ModelLoader类负责从给定的模型路径加载Llama 2模型。它使用HuggingFace的transformer库来加载模型及其标记器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

import os
from transformers import AutoModelForCausalLM, AutoConfig, AutoTokenizer
from dotenv import load_dotenv

load_dotenv()


class ModelLoader:
    def __init__(self, model_path: str):
        self.model_path = model_path
        self.config = AutoConfig.from_pretrained(
            self.model_path,
            trust_remote_code=True,
            use_auth_token=os.getenv("HUGGINGFACE_TOKEN"),
        )
        self.model = self._load_model()
        self.tokenizer = AutoTokenizer.from_pretrained(
            self.model_path, use_auth_token=os.getenv("HUGGINGFACE_TOKEN")
        )

    def _load_model(self):
        model = AutoModelForCausalLM.from_pretrained(
            self.model_path,
            config=self.config,
            trust_remote_code=True,
            load_in_4bit=True,
            device_map="auto",
            use_auth_token=os.getenv("HUGGINGFACE_TOKEN"),
        )
        return model

Broker

要设置Redis，我们有两个选择:我们可以使用docker容器，或者我们可以使用Python包redis_server。如果您决定使用docker容器(首选解决方案)，您可以运行下面的命令。-p 6379:6379选项告诉Docker将从主机端口6379传入的流量转发到容器端口6379。这样，Redis实际上可以从docker容器外部访问。

1

docker run --name redis-db -p 6379:6379 -d redis

第二种选择是从Python接口执行。redis_server.py脚本处理Redis服务器的安装和启动。回想一下，Redis同时充当Celery的消息代理和结果后端。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import subprocess
import redis_server


def install_redis_server(redis_version):
    try:
        subprocess.check_call(["pip", "install", f"redis-server=={redis_version}"])
        print(f"Redis server version {redis_version} installed successfully.")
    except subprocess.CalledProcessError:
        print("Failed to install Redis server.")
        exit(1)


def start_redis_server():
    try:
        redis_server_path = redis_server.REDIS_SERVER_PATH
        subprocess.Popen([redis_server_path])
        print("Redis server started successfully.")
    except Exception as e:
        print("Failed to start Redis server:", str(e))
        exit(1)


def main():
    redis_version = "6.0.9"
    install_redis_server(redis_version)
    start_redis_server()


if __name__ == "__main__":
    main()

运行application

主执行脚本(run.py)是与FastAPI应用程序通信的客户端脚本。它向/generate/端点发送一个prompt，获取任务ID，并定期轮询/task/{task_id}端点，直到任务完成。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import http.client
import json
import time

API_HOST = "localhost"
API_PORT = 8000


def generate_text(prompt):
    conn = http.client.HTTPConnection(API_HOST, API_PORT)
    headers = {"Content-type": "application/json"}
    data = {"prompt": prompt}
    json_data = json.dumps(data)
    conn.request("POST", "/generate/", json_data, headers)
    response = conn.getresponse()
    result = json.loads(response.read().decode())
    conn.close()
    return result["task_id"]


def get_task_status(task_id):
    conn = http.client.HTTPConnection(API_HOST, API_PORT)
    conn.request("GET", f"/task/{task_id}")
    response = conn.getresponse()
    status = response.read().decode()
    conn.close()
    return status


def main():
    prompt = input("Enter the prompt: ")

    task_id = generate_text(prompt)
    while True:
        status = get_task_status(task_id)
        if "Task not completed yet" not in status:
            print(status)
            break
        time.sleep(2)


if __name__ == "__main__":
    main()

utils模块(utils.py)提供了一个实用程序函数generate_output，用于使用Llama 2模型和标记器从prompt生成文本。该函数使用@time_decorator和@memory_decorator进行装饰，以测量执行时间和内存使用情况。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

import time
import torch
import functools
from transformers import AutoModelForCausalLM, AutoTokenizer


def time_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        exec_time = end_time - start_time
        return (result, exec_time)
    return wrapper


def memory_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()
        result, exec_time = func(*args, **kwargs)
        peak_mem = torch.cuda.max_memory_allocated()
        peak_mem_consumption = peak_mem / 1e9
        return peak_mem_consumption, exec_time, result
    return wrapper


@memory_decorator
@time_decorator
def generate_output(prompt: str, model: AutoModelForCausalLM, tokenizer: AutoTokenizer) -> torch.Tensor:
    input_ids = tokenizer(prompt, return_tensors="pt").input_ids
    input_ids = input_ids.to("cuda")
    outputs = model.generate(input_ids, max_length=500)
    return outputs

本质上，当通过/generate/端点接收到prompt时，它会作为异步任务转发给Celery工作器。worker使用Llama 2模型生成文本，并将结果存储在Redis中。您可以在任何时候使用/task/{task_id}端点获取任务状态/结果。

发布

部署应用程序需要执行几个步骤。首先，让我们为我们的应用创建一个Dockerfile:

1
2
3
4
5
6
7
8
9

FROM python:3.9-slim-buster

WORKDIR /app
ADD . /app

RUN pip install --no-cache-dir -r requirements.txt
EXPOSE 80

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "80"]

接下来，让我们定义所需的requirements.txt，以便我们在Docker容器中安装所有的依赖项:

1
2
3
4
5
6
7
8
9
10
11

fastapi==0.99.1
uvicorn==0.22.0
pydantic==1.10.10
celery==5.3.1
redis==4.6.0
python-dotenv==1.0.0
transformers==4.30.2
torch==2.0.1
accelerate==0.21.0
bitsandbytes==0.41.0
scipy==1.11.1

为了使用Docker Compose来设置FastAPI应用程序、Celery和Redis服务器，你可以创建一个Docker - Compose.yml文件如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

version: '3'
services:
  web:
    build: .
    command: ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "80"]
    volumes:
      - .:/app
    ports:
      - 8000:80
    depends_on:
      - redis
  worker:
    build: .
    command: celery -A celery_worker worker --loglevel=info
    volumes:
      - .:/app
    depends_on:
      - redis
  redis:
    image: "redis:alpine"
    ports:
      - 6379:6379

在Docker Compose配置中，web服务代表使用当前目录下的Dockerfile构建的FastAPI应用程序。它将主机的端口8000映射到容器的端口80。worker服务是Celery，它与FastAPI应用程序共享构建上下文。redis服务使用官方的redis Docker镜像。depends_on 字段确保Redis在web和worker服务之前启动。所有这些服务都可以使用docker-compose up 命令启动。

结果

我们测试了Llama2，聊天版本使用4位量化的7b参数。

我们使用了以下输入:

Prompt: <>\nYou are J. Robert Oppenheimer, a brilliant physicist whose pioneering work during the 20th century significantly contributed to the development of the atomic bomb. Dive into the profound world of nuclear physics, challenge the boundaries of scientific understanding, and unlock the mysteries of atomic energy with your exceptional intellect. Embark on a momentous journey where your passion for science knows no limits, and let your dedication to harnessing the power of the atom shape the course of history and leave an indelible mark on the world.\n<>\n[INST]\nUser: How did your research lead to the creation of the atomic bomb?\n[/INST]

Llama2生成的最终对话如下:

Ah, a most excellent question, my dear fellow! adjusts spectacles\nThe creation of the atomic bomb, you see, was the culmination of a most intense and complex scientific journey. It was a quest that spanned decades, involved some of the brightest minds in physics, and pushed the boundaries of human understanding to their very limits.\nYou see, my dear, the quest for the atomic bomb began in the early 1930s, when a group of us at the University of California, Berkeley, realized that the nucleus of an atom could be split, releasing an enormous amount of energy in the process. This was a most remarkable discovery, as it revealed the incredible potential of the atom as a source of power.\nBut, alas, the path to the atomic bomb was not without its challenges. Oh, the obstacles we faced! winks The skeptics, the naysayers, the doubters. They were legion, I tell you! chuckles But, we persevered, my dear. We worked tirelessly, pouring over the data, testing and retesting our theories. And, eventually, our hard work paid off.\nIn 1945, our team successfully detonated the first atomic bomb at the Trinity Site in New Mexico. It was a moment of pure elation, a culmination of years of hard work and dedication. And, as the world watched in awe, we realized the incredible potential of the atomic bomb.\nBut, my dear, the creation of the atomic bomb was…

文本在4.77秒内生成，峰值VRAM使用量约为13.4 GB。需要始终牢记的一件事是，由于我们使用的是Transformer模型，因此内存需求随着生成的输出序列的大小而增加。在本例中，我们将max_length定义为500个tokens。

这些结果表明，Llama2模型可以在合理的时间范围内产生复杂而微妙的响应。请记住，我们使用的是最小的模型(7b)和更重要的量化(4位)。

结论

正如我们在本文中所展示的，Meta的Llama 2模型为开源社区提供了新的可能性。我们介绍了Llama2的一些关键特征和特点，包括它的训练过程、架构和prompt工程设计。

此外，我们还提供了一个关于使用FastAPI, Redis和Celery构建Llama2聊天应用程序的深入指南。它应该允许任何人开始构建可扩展的实时应用程序，为数千名用户提供Llama 2(或任何其他商业许可的LLM)服务。

在我们的结果中，我们展示了该模型在为复杂的prompts生成详细且上下文丰富的响应方面的性能。

原文：You don’t need Prompt Engineering! Try this instead!

像我们中的许多人一样，我认为要想在AI上取得好结果，你需要一个非常强大的语言模型和prompt工程方面的特殊训练。

我把从Hugging Face收到的低质量回复归咎于我缺乏提示技巧，花了几个小时进行prompt微调(真的很耗时)，而不是创建新的python应用程序(无论如何都很耗时)。

我必须承认:只要尝试一种全新的方法，prompt工程就毫无用处。这就是我们要在这篇文章中一起验证的。

我们需要什么?

通常我们认为，要获得好的结果，模型是最重要的: 这当然是正确的!但是我们真正需要的是什么呢?

我是说它是模型权重吗?数十亿个参数的数量?

我开始探索在仅CPU上运行推理模型的所有可能性，以便我们能够与它们进行交互。我想看看更多的参数是否立即等于更好的模型。几个月前，我读到了LaMini-LM，这真是一件幸事，因为它们很小，可以仅仅在CPU上运行。

在这一点上，重要的是开始思考目标是什么。必须根据我们希望它执行的任务来选择模型。例如，在私有文档集上的问答是一个非常具体的任务，不需要像我们期望的OpenAI GPT等通才模型那样在NLP任务上具有相同的性能。

让我们以这些模型为例:它们建立在一个特定的数据集上

根据论文，如果你用一个小的语言模型来训练，就可以获得惊人的表现。所提出的模型达到了与Alpaca相当的性能，而尺寸却小了近十分之一，这表明了训练高效而有效的语言模型的潜力。

从哪里开始?

那么为什么我们不从指令数据集开始看看这些模型是如何训练的呢?幸运的是，在LaMini模型的Hugging Face模型卡上，我们有所有的细节，甚至数据集本身!

模型卡片页 https://huggingface.co/MBZUAI/LaMini-Flan-T5-77M

该项目的官方GitHub页面描述了他们如何收集和使用数据集:

我们通过执行句子/离线蒸馏从大型语言模型中提取知识(Kim和Rush, 2016)。基于几种现有的prompts资源，我们使用gpt-3.5 turbo生成了总共258万对指令和响应，包括自我指导(Wang等人，2022)、P3 (Sanh等人，2022)、Flan (Longpre等人，2023)和Alpaca (Taori等人，2023)。关于生成指令数据集的更多信息，请参考我们的论文。

lamini指令数据集是用于指令微调模型的数据库。如果我们仔细观察它们，我们可以看到一些惊人的事情:

https://huggingface.co/datasets/MBZUAI/LaMini-instruction/viewer/default/train?row=0

数据集包含指令和响应的列表(260万行)，以及源(alpaca、self_instruct_without_topic，等等…)。现在，这意味着模型已经经过训练，可以执行指令中要求的任务。

这对我们来说是个好消息!!这里是终极prompt工程破解!

事实上，如果我想让模型执行一条指令，我只需要检查训练数据集，看看模型是如何训练的。

让我们一起测试一下

我将在两个不同的端口上运行248M Flan模型和77M Flan模型。你可以这样做:

1.创建stapp77.py的副本，并将副本重命名为stapp77.py

2.在stapp77.py中将检查点更改为 “./model77M/“我建议下载https://huggingface.co/MBZUAI/LaMini-Flan-T5-77M的模型权重

1
2

### INITIALIZING LAMINI MODEL
checkpoint = "./model77M/"

3.打开2个不同的终端窗口，并在其中激活venv。

4.然后运行如下命令启动248M型号的聊天机器人:

1

python3.10 -m streamlit run stapp.py --server.port 8501

5.运行如下命令启动77M型号的聊天机器人:

1

python3.10 -m streamlit run stapp77.py --server.port 8502

截图来自作者——这里有一个将会发生的例子…

我们要做的是测试训练说明，然后根据我们的需要尝试改变它们。真正的提示将基于数据集prompts。

注意调整模型参数(max_length, temperature和repetition_penalty)可能会改变响应

根据其中一个训练指令生成2个模型

从这个例子中我们已经可以观察到，77M模型给出的答案比248M模型更长。如果您测试其他指令，您将看到这是一致的。

然而，对于一些特定的任务，248M型号将更加顺从，提供我们所要求的。

例如:

248M型号根据说明给出了更准确的回复

这里我们要求写一个关于主题的1句总结:更大的模型在现场为我们提供了一个句子的描述。

诀窍在哪里?

最困难的部分是遍历数据集并找到您将在日常任务中使用的典型指令。我邀请你直接在hugging Face Hub网站上查看它们:这是一个700 Mb的数据集，直接从网络上浏览更容易。

在你确定了他们之后，试着根据你的兴趣改变话题。这里有一个例子

原来的指示:重写这首诗，使它更生动有趣……

如果你是一个作家，它可以这样使用:重写这篇文章，让它更有趣…

结论(目前)

有很多与prompt工程相关的免费和付费资源。这个话题真的很受欢迎，它被认为是NLP和图像生成任务的未来工作。

但是，您不认为亲自了解训练说明是最大限度地利用模型的更好方法吗?

考虑一下来自微型LaMini-Flan-T5-77M:的答案，你不觉得300Mb的型号有多大帮助吗?

如果你有兴趣学习如何创建自己的API推理来为你的本地网络提供一个模型，并有多个应用程序与之合作，请继续关注，因为我将向你展示从a到Z如何在你的PC上运行一个Hugging Face模型。

好的背景图片会为你的设计奠定坚实的基础,如果使用得当，背景图片可以在设计中达到多种目的，包括:

• 设定基调。例如，一个黑暗和喜怒无常的背景图像可以创造一种神秘或悬疑的感觉，而一个明亮和通风的背景图像可以创造一种和平或宁静的感觉。
• 创造深度感。例如，混合纹理的背景图像可以创造深度的错觉，或者具有重叠元素的背景图像，如山前的树可以创造空间感。
• 突出显示内容。例如，浅色的背景图像可以使文本突出，或者带有特定图案的背景图像可以将注意力吸引到页面上的特定元素上。
• 增加兴趣。例如，具有独特纹理的背景图像可以使设计更具视觉吸引力，或者具有特定配色方案的背景图像可以创造一种和谐感。
• 创造品牌感。例如，带有公司标志或品牌颜色的背景图像可以帮助创建一致的品牌标识。

通常，大多数品牌通过创建标准化背景或模板库来简化其图形资产创建过程。限制背景设计的轮转，让你完成的品牌形象在社交媒体上变得熟悉，而不会变得无聊。

设计师将创建一个包含5-15个选项的文件夹，内容创建者可以使用它作为基础，为他们的内容创建关键图像。设计团队通常会锁定这些基本图像，因为它们对品牌一致性非常重要。

另外，它们过去很难做好。由于担心尴尬的混乱，设计师过去常常严格控制这些基本级别的图像，允许内容创建者在它们上面叠加他们的图标或文本，以创建社交媒体和文章的图形。

内容创造者通常并不介意这些类型的护栏，因为这也有助于加速资产创造。通过一组标准的设计方法，作者可以快速而持续地制作这些重要的图像——让他们重新开始创建更多的内容。

不管怎样，这是昨天的故事。

今天，我们可以使用强大的生成AI图形工具，如Midjourney和Dall-e等。现在，那些曾经重复使用标准背景的创作者可以使用这些工具来创建自定义的高质量图像。

但你如何通过这些工具实现品牌一致性呢?在这篇文章中，我将带你了解创建这些图像的逻辑，以使你的LOGO免受设计团队的责难。

重要的事情先做:确立你的目标

Midjourney prompt:

mixed media illustration, background image, dark background, networking concept, internet concept, mostly blank space, low contrast — ar 1200:630

与任何项目一样，最好先列一个清单，列出你所知道的和必须做的事情。从一个目标开始总是有助于提高你的结果的保真度。

• 设计目的。你想通过这个设计达到什么目的?你的设计涉及到什么样的情感?你是想营造一种平静、兴奋的感觉，还是别的什么?背景图像应该有助于支持设计的总体目标。
• 目标受众。你在为谁设计?这个角色会对什么做出反应?背景图像应该吸引目标受众的兴趣和情感。
• 设计的整体风格。设计的整体外观和感觉如何?这是什么尺寸的?你有可以依赖的风格指南吗?背景图片应该与整体风格相辅相成，而不是相互冲突。

如何构建你的Midjourney prompt

Midjourney prompt:

social media background image, announcement, #243043 background color, talking head mosaic, shouting, side profile, #E34B44, dark background, lots of blank space, use of negative space, ultra minimalistic — ar 1200:630

现在你已经收集了一堆单词来描述你的图像，是时候把它放在一个prompt中了!

在制作prompt时，重要的是要记住，Midjourney只考虑prompt的前60个单词，它给予第一个单词比最后一个单词更多的权重。因此，最好使用逗号分隔的完整短语，而不是完整的句子。我还建议从你想要创建的内容类型开始，在前2-5个单词，因为这将有助于提高你的结果的一致性。

另外，用描述性短语写作，因为句子的大部分内容都会被忽略。

1

[content type], [description - subject + adjectives], [style], [composition]

1. 确定内容类型。明确说明您正在寻找背景图像或背景。
2. 其次是风格。由于风格处理对背景图像非常重要，请将此短语移至prompt符的第二位。包括特定艺术家的名字或技术，以唤起他们的艺术风格，如双色渐变或图案背景。
3. 描述你的内容。尽可能具体，特别是当它有可能被误认为是其他东西的时候。一定要使用详细的形容词。
4. 包括品牌颜色。通过使用十六进制代码(如#e34b44)包括特定颜色来指导您的图像创建。
5. 明确排除文本或其他对象。在每个prompt的末尾，指定图像中不应该出现的内容，例如--no letters words people animals.。

运用色彩心理学

Midjourney prompt:

blurred background image, patterns in nature, green colors, use of negative space — ar 1200:630

不同的颜色可以唤起不同的情感，所以选择能够为你的设计创造理想效果的颜色是很重要的。通常，你的调色板会受到公司风格指南的限制，但同样经常，你的设计师应该包括一系列可以满足你的观众或客户群情感需求的颜色。

以下是设计师如何使用颜色来唤起不同情感的一些例子:

• 红色:红色常与兴奋、激情和危险联系在一起。
• **橙色:**橙色与能量、创造力和热情联系在一起。
• **黄色:**黄色让人联想到快乐、乐观和创造力。
• **绿色:**绿色与自然、和平、宁静联系在一起。
• **蓝色:**蓝色与冷静、宁静和信任联系在一起。
• **紫色:**紫色与奢华、皇室和智慧联系在一起。
• **粉红色:**粉红色与爱情、浪漫和女性气质有关。
• **黑色:**黑色与权力、成熟和神秘联系在一起。
• **白色:**白色代表纯洁、干净和简单。

Midjourney prompt:

realistic photo background image, palm trees with a dusty pink overlay, lots of blank space, use of negative space, minimalistic, very low contrast — ar 1200:630

您可以通过包含十六进制代码或适当的颜色名称来在prompts中指定颜色。在我的观察中，这两种选择都有效，尽管我注意到使用自然语言名称的颜色更加一致。要使整个照片饱和，请指定一种颜色叠加颜色。

尝试使用纹理

Midjourney prompt:

background image, watercolor smudges, light and airy, #1b2b50, #369afe, low contrast — no animals people words letters — ar 1200:630

纹理也可以用来增加背景图像的兴趣和深度。纹理可以在自然界、人造物体甚至抽象图案中找到。

然而，纹理很容易压倒你的设计。尽量减少颜色和保持构图简单将有助于保持你的设计重点。你的纹理应该非常小，像背景一样，而不是像前景那样占据注意力。

我喜欢使用纹理来创造纸张或高质量库存的错觉。这种技术为网页内容增加了一种优雅、有形的效果，提供了一种触觉和个性化的触摸。

下面是一些如何在背景图像中使用纹理的例子:

• **自然纹理:**自然纹理可以在木头、石头、水和树叶中找到。
• **人造纹理:**人造纹理可以在砖、混凝土、金属和织物中找到。
• **抽象纹理:**抽象纹理是由重复的图案或形状创建的。

梯度实验

Midjourney prompt:

dark stage backdrop, blue gradient, colorwash, hipster smiling and sharing a peace sign, isolated, simplistic, duotone, lunarpunk, #1b2b50, #369afe, ultra low contrast — ar 1200:630

渐变背景现在非常流行。有充分的理由，因为它们非常多才多艺。渐变可以看起来非常复古或非常现代，只是取决于你的颜色选择。

渐变通常是一种比纯色或块色更复杂的方法。无论你是应用径向梯度还是线性梯度，你都会在你的设计上看到不同的效果。方向会直接影响听众的焦点。

• 线性渐变： 这种梯度从一种颜色到另一种在一个方向，水平，垂直，有时对角线。
• 辐射渐变：从中心点向外或从外向内径向切换颜色的渐变。
• 角度线渐变：在这个渐变中，颜色围绕一个角度线切换。
• 形状渐变：这个梯度的中心有一个形状，如菱形。
• 多色渐变：混合光谱颜色的渐变。
• 双色渐变：只混合两种颜色的梯度。
• 三色渐变：渐变混合三种颜色。

当提示时，一定要在prompt前面添加渐变，或者在文本中添加权重，这样AI就知道这是这个设计的关键。我通常在第二阶段添加渐变。

试试瓷砖方式的重复

创建重复背景的另一种方法是构建tiles。这让你可以精确地控制背景的大小和分散注意力的程度。您可以根据需要将瓷砖设置成大小，这可以帮助创建或多或少微妙的效果。

在Midjourney中创造重复模式是相当容易的，你只需要在prompt符的末尾添加--tile即可。

升级到插图

Midjourney prompt:

cartoon illustration poster background, vermillion cinnabar background color, a simple happy monster, strong use of negative space, lots of blank space, rule of thirds, bold colors, minimalist, #e34b44 — no words letters — ar 1200:630

我以前说过，插图是最难创作的东西之一，忠实于你自己的想象力。我用了一整篇文章来为他们创造Midjourney的prompts。

那篇文章仍然涵盖了很多内容，但在背景图像中创建它们有一些具体的区别:

1.使用三分法。“三分法则”是一种构图准则，它将图像分成九个相等的部分，主体沿着线条或交叉点放置，以获得更平衡和视觉上吸引人的构图。

2.指定负空间。对于背景图像，你需要有空间来写你的文字，它不应该与你的插图竞争。指定“左侧空白”或“使用负空格”将有助于为文本清除一个位置。您还可以在坚实的背景上分层插图，以获得对负空间的细粒度控制。

3.用种子来制造稠度。这并不完美，但是使用--seed和—-sameseed命令可以帮助你保持品牌的一致性。

4.寻找艺术家来接近一种风格。可能是显而易见的，但它确实会对插图产生很大的影响。

5.如果你正在创建一个角色，创建一个角色研究并在每个prompt符中使用它。创建一个你的角色在动作姿势的合成图像，穿着相同的衣服。你可以分多个步骤来做，到达角色的外观，然后从中获得角色研究。这将有助于更好地指导所有未来的结果。种子也有帮助。

https://s.mj.run/MycV54zgKNc 全彩色人物插图，女孩在冒险，动作姿势，跑，跳，生气，笑，向前和向后，复古考古，棕色皮衣，手鹿治虫- ar 16:9.

继续寻找灵感

Midjourney prompt: baby blue background, yellow phone, old school rotary phone, right side blank, color pop, minimalism — ar 1200:630

灵感无处不在!但如果你迷路了，有时候像这样的帖子会给你真正的帮助。这里有几个方法可以让你继续寻找创造力。

1. 使用 /describe函数。回到谷歌上的旧图片搜索，你可以用一张图片来获得Midjourney志愿者的描述符，这可能会给你带来灵感。
2. 查看Discord上的Midjourney展示。有几个，虽然用户并不总是包含他们的prompt符，但你可以打开屏幕并使用/ description功能。