Llama 2是开源模型的最佳基准

在几乎所有的基准测试中，Llama2的7B和40B参数模型都超过了之前最先进的开源模型猎鹰。基于其他基准测试，它与GPT3.5相当，略低于GPT4，考虑到GPT4在技术上仍处于测试阶段，这令人难以置信。

你可以在这里试试Llama2。

Step 1: 获得Llama2的许可证

截至2023年7月19日，Meta已经在注册流程后面设置了Llama2。首先，你需要从Meta请求访问。然后，您可以从HuggingFace请求访问，以便我们可以通过HuggingFace下载docker容器中的模型。

Step 2: 容器化Llama 2

为了将Llama 2部署到Google Cloud，我们需要将其封装在一个带有REST端点的Docker容器中。我们比较了这一步的几个不同选择，包括LocalAI和Truss。我们最终选择了Truss，因为它的灵活性和广泛的GPU支持。

你也可以使用RAGStack，一个MIT许可的项目，来自动完成本教程中的其他步骤。它通过Terraform将Llama 2部署到GCP，还包括一个矢量数据库和API服务器，因此您可以上传Llama 2可以检索的文件。

容器化Llama2，开始创建一个Truss项目:

1

truss init llama2-7b

这将创建一个名为llama2-7b的目录，其中包含Truss需要的相关文件。我们需要配置项目，以便从Huggingface下载Llama2并使用它进行预测。将llama2-7b/model/model.py更新为以下代码:

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

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
from typing import Dict
from huggingface_hub import login
import os

MODEL_NAME = "meta-llama/Llama-2-7b-chat-hf"
DEFAULT_MAX_LENGTH = 128

class Model:
    def __init__(self, data_dir: str, config: Dict, **kwargs) -> None:
        self._data_dir = data_dir
        self._config = config
        self.device = "cuda" if torch.cuda.is_available() else "cpu"
        print("THE DEVICE INFERENCE IS RUNNING ON IS: ", self.device)
        self.tokenizer = None
        self.pipeline = None
        secrets = kwargs.get("secrets")
        self.huggingface_api_token = os.environ.get("TRUSS_SECRET_huggingface_api_token")
            

    def load(self):
				login(token=self.huggingface_api_token)
        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_auth_token=self.huggingface_api_token)
        model_8bit = AutoModelForCausalLM.from_pretrained(
            MODEL_NAME,
            device_map="auto",
            load_in_8bit=True,
            trust_remote_code=True)

        self.pipeline = pipeline(
            "text-generation",
            model=model_8bit,
            tokenizer=self.tokenizer,
            torch_dtype=torch.bfloat16,
            trust_remote_code=True,
            device_map="auto",
        )

    def predict(self, request: Dict) -> Dict:
        with torch.no_grad():
            try:
                prompt = request.pop("prompt")
                data = self.pipeline(
                    prompt,
                    eos_token_id=self.tokenizer.eos_token_id,
                    max_length=DEFAULT_MAX_LENGTH,
                    **request
                )[0]
                return {"data": data}

            except Exception as exc:
                return {"status": "error", "data": None, "message": str(exc)}

因为Huggingface上的LLama2访问是门接的，所以在检索模型时需要提供Huggingface APItoken。Truss有一个内置的秘密管理系统，这样我们就可以使用我们的API密钥，而不用在Docker容器中公开它。要添加我们的APItoken，请更新llama2-7b/config.yaml:

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

apply_library_patches: true
bundled_packages_dir: packages
data_dir: data
description: null
environment_variables: {}
examples_filename: examples.yaml
external_package_dirs: []
input_type: Any
live_reload: false
model_class_filename: model.py
model_class_name: Model
model_framework: custom
model_metadata: {}
model_module_dir: model
model_name: Falcon-7B
model_type: custom
python_version: py39
requirements:
- torch
- peft
- sentencepiece
- accelerate
- bitsandbytes
- einops
- scipy
- git+https://github.com/huggingface/transformers.git
resources:
  use_gpu: true
  cpu: "3"
  memory: 14Gi
secrets: {}
spec_version: '2.0'
system_packages: []

现在我们可以在刚刚创建的文件夹外运行以下代码来创建docker镜像:

1
2
3
4
5
6
7

import truss
from pathlib import Path
import requests

tr = truss.load("./llama2-7b")
command = tr.docker_build_setup(build_dir=Path("./llama2-7b"))
print(command)

下面的脚本会给你一个命令来构建docker镜像:

1

docker build llama2-7b -t llama2-7b:latest

一旦你构建了镜像，你就可以将它部署到Docker Hub以供GKE使用:

1
2

docker tag llama2-7b $DOCKER_USERNAME/llama2-7b
docker push $DOCKER_USERNAME/llama2-7b

Step 3: 使用Google Kubernetes Engine (GKE)部署Llama 2

现在我们有了Llama的docker映像，我们可以将它部署到GKE。我们需要打开Google Cloud仪表盘到Google Kubernetes Engine，并创建一个名为gpu-cluster的新标准Kubernetes集群。将zone设置为us-central1-c。

在 default-pool > Nodes 选项卡中, 设置

1. Machine Configuration ：将 General Purpose 改成 GPU
2. GPU type: Nvidia TF
3. Number of GPUs: 1
4. Enable GPU time sharing
5. Max shared clients per GPU: 8
6. Machine type: n1-standard-4
7. Boot disk size: 50 GB
8. Enable nodes on spot VMs

一旦创建了GKE集群，我们需要安装一些Nvidia驱动程序。在终端中运行

1
2
3

gcloud config set compute/zone us-central1-c
gcloud container clusters get-credentials gpu-cluster
kubectl apply -f <https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/master/nvidia-driver-installer/cos/daemonset-preloaded.yaml>

安装了驱动程序之后，就可以部署到GKE了。创建一个yaml文件kubernetes_deployment.yaml

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: llama2-7b
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      component: llama2-7b-layer
  template:
    metadata:
      labels:
        component: llama2-7b-layer
    spec:
      containers:
      - name: llama2-7b-container
        image: psychicapi/llama2-7b:latest
        ports:
          - containerPort: 8080
				env:
          - name: TRUSS_SECRET_huggingface_api_token
            value: "$YOUR_HUGGINGFACE_API_TOKEN"
        resources:
          limits:
            nvidia.com/gpu: 1
---
apiVersion: v1
kind: Service
metadata:
  name: llama2-7b-service
  namespace: default
spec:
  type: LoadBalancer
  selector:
    component: llama2-7b-layer
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080

确保用你的apitoken替换$ YOUR_HUGGINGFACE_API_TOKEN 。这部分是必要的，因为Llama的通道是受限的。

然后运行：

1

kubectl create -f kubernetes_deployment.yaml

部署完成后，您可以通过调用获得llama2-7b-service的外部IP

1

kubectl get svc

Step 4: 测试已部署的模型

复制这个cURL并在终端上运行它，将$EXTERNAL_IP替换为您在上一步中获得的IP。

1
2
3
4
5

curl --location 'http://$EXTERNAL_IP/v1/models/model:predict' \\
--header 'Content-Type: application/json' \\
--data '{
    "prompt": "Who was president of the united states of america in 1890?"
}'

如果您得到响应，则意味着您的服务按预期工作!..

请记住，我们启用了未经身份验证的调用，因此任何知道您服务的IP或URL的人都可以向您托管的Llama 2模型发出请求。您可能希望在GCP中设置身份验证，以只允许您自己的服务调用与模型交互的端点，否则您的GPU账单可能会很快堆积起来..。

接下来的步骤-连接你的数据

Llama 2的自托管版本很有用。使该模型从有用变为关键任务的是将其连接到外部和内部数据源(例如web或公司的内部知识库)的能力。

我们可以通过一种称为RAG检索增强生成的技术来实现这一点。

• RAG代表检索增强生成(Retrieval Augmented Generation)，这种技术通过从其他系统检索信息并通过prompt将其插入LLM的上下文窗口来增强大型语言模型(LLM)的功能。这为大语言模型提供了训练数据之外的信息，这对于几乎每个企业级应用程序都是必要的。例子包括来自当前网页的数据，来自Confluence或Salesforce等SaaS应用程序的数据，以及来自销售合同和pdf等文档的数据。

  RAG往往比微调（fine-tuning）模型更有效，因为:

  • **更便宜: **微调（fine-tuning）模型是昂贵的，因为必须调整模型参数本身的权重。RAG仅仅是一系列向量相似度查询、SQL查询和API调用，花费很少。
  • 更快: 微调（fine-tuning）每次需要几个小时，有时几天取决于模型的大小。使用RAG，对知识库的更改会立即反映在模型响应中，因为它可以及时地直接从记录系统中检索。
  • 更可靠: RAG允许您跟踪元数据上检索的文件，包括每个文件来自哪里的信息，使其更容易检查幻觉。另一方面，微调是一个黑盒子。

  Llama2本身就像一个新员工 ，它有很好的一般知识和推理能力，但缺乏任何业务经验，不了解文本之外的各种背景信息，说的夸张一点就像是你不了解公司的基因、文化和现状，对很多事务的判断也许是正确的，但并不适用。

  Llama2组合RAG就像一个经验丰富的员工 ，它了解你的业务是如何运作的，可以提供具体情况下的帮助，从客户反馈分析到财务规划和预测。

大家可以使用开源的RAGstack库来设置RAG堆栈。

配置本地的gcloud客户端

我们需要首先从GCP控制台获得我们的项目ID，并登录到gcloud客户端。

然后在终端运行以下命令，将$PROJECT_ID替换为您的项目ID。

1
2

gcloud auth login
gcloud config set project $PROJECT_ID

现在我们有两种选择来部署每个服务——我们可以使用RAGstack，或者我们可以手动部署每个服务。

使用RAGstack进行部署

RAGstack是一个开源工具，它使用Terraform和Truss来自动部署LLM (Falcon或Llama 2)和向量数据库。它还包括一个API服务和轻量级UI，以便于接受用户查询和检索上下文。

RAGstack还允许我们在本地运行每个服务，所以我们可以在部署前测试应用程序!

在本地开发

要在本地运行RAGstack，运行:

1

./run-dev.sh

这将设置本地开发环境，并安装所有必要的python和nodejs依赖项。更改server 和ragstack-ui 下的文件将自动反映。

发布

要将RAGstack部署到GCP，运行:

1

./deploy-gcp.sh

如果你没有安装Terraform，你必须先按照[这些说明]安装它(https://developer.hashicorp.com/terraform/tutorials/aws-get-started/install-cli)。在Mac上，只有两个命令:

1
2

brew tap hashicorp/tap
brew install hashicorp/tap/terraform

但是，如果您仍然喜欢自己设置，请继续阅读!

手动部署

Step 1: 将Llama2号部署到GCP

• 要了解如何将Llama2模型部署到GCP，请查看本教程。
• 要在AWS或Azure上部署，请通过founders@psychic.dev与我们联系

Step 2: 部署向量数据库

向量数据库是最常用的存储检索上下文的方法，因为它们测量相似性的方式很适合用自然语言进行查询。

一些最流行的向量数据库是:

• Pinecone — 闭源
• Weaviate — 开源
• Qdrant — 开源
• Chroma — 开源

在本文中，我们使用Qdrant，因为它有一个方便的docker镜像，我们可以拉取和部署。

在终端中运行:

1

gcloud run deploy qdrant --image qdrant/qdrant:v1.3.0 --region $REGION --platform managed --set-env-vars QDRANT__SERVICE__HTTP_PORT=8080

将$REGION替换为要部署到的REGION。我们通常部署到us-west1，但您应该部署到离您或您的用户较近的数据中心。

Step 3: 上传文档到向量数据库

我们需要一些方法来收集用户的文档。最简单的方法是从命令行读取文件路径。RAGstack库有一个简单的UI来处理文件上传和解析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def read_document() -> str:
	while True:
    try:
      # Get the file path from the user
      file_path = input("Enter the file path: ")
      # Read the file
      with open(file_path, 'r') as file:
          data = file.read()      return Document(
				content=data,
				title="Doc Title",
				id=str(uuid.uuid4()),
				uri=file_path
			)    except Exception as e:
      print(f"An error occurred: {e}")    input("Press enter to continue...")

我们还需要一个函数将这些文档转换为Embeddings并将它们插入到Qdrant中。

源码

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

async def upsert(self, documents: List[Document]) -> bool:
  langchain_docs = [
    Document(
      page_content=doc.content, 
      metadata={"title": doc.title, "id": doc.id, "source": doc.uri}
    ) for doc in documents
  ]
  text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
  split_docs = text_splitter.split_documents(langchain_docs)
  points = []
  seen_docs = {}  for doc in split_docs:
    doc_id = None
    if doc.metadata["id"] not in seen_docs:
      doc_id = doc.metadata["id"]
      seen_docs[doc.metadata["id"]] = 1
      chunk_id = uuid.uuid5(uuid.NAMESPACE_DNS, f"{doc_id}_1")
    else:
      doc_id = doc.metadata["id"]
      seen_docs[doc.metadata["id"]] += 1
      chunk_id = uuid.uuid5(uuid.NAMESPACE_DNS, f"{doc_id}_{seen_docs[doc.metadata['id']]}")    vector = embeddings_model.encode([doc.page_content])[0]
    vector = vector.tolist()    points.append(PointStruct(
      id=str(chunk_id),
      payload={
        "metadata": {
          "title": doc.metadata["title"],
          "source": doc.metadata["source"],
          "chunk_id": chunk_id,
          "doc_id": doc_id,
        },
        
        "content": doc.page_content
      },
      vector=vector
    ))  self.client.upsert(
    collection_name=self.collection_name,
    points=points
  )
  return True

Step 4: 把点连起来

为了端到端运行我们的RAG模型，我们需要在python中设置一些额外的glue功能。

接受用户查询并将其转换为Embedding，然后根据Embedding在Qdrant中运行相似度搜索

源码

1
2
3
4
5
6
7
8
9
10

async def query(self, query: str) -> List[PsychicDocument]:
  query_vector = embeddings_model.encode([query])[0]
  query_vector = query_vector.tolist()
  # query_vector = embeddings.embed_query(query)
  results = self.client.search(
    collection_name=self.collection_name,
    query_vector=query_vector,
    limit=5
  )
  return results

使用模板和检索到的文档构造prompt，然后将prompt发送到托管的Llama 2模型

Source — 这是来自猎鹰7B模型的代码，但由于我们使用Truss来服务模型，因此与Llama2连接时代码将相同。

1
2
3
4
5
6
7
8
9

async def ask(self, documents: List[Document], question: str) -> str:
  context_str = ""  for doc in documents:
    context_str += f"{doc.title}: {doc.content}\\n\\n"  prompt = (
    "Context: \\n"
    "---------------------\\n"
    f"{context_str}"
    "\\n---------------------\\n"
    f"Given the above context and no other information, answer the question: {question}\\n"
  )  data = {"prompt": prompt}  res = requests.post(f"{base_url}:8080/v1/models/model:predict", json=data)  res_json = res.json()  return res_json['data']['generated_text']

将所有这些放在一起的最简单的方法是使用FastAPI或Flask设置一个API服务器，它处理托管Llama 2实例，托管Qdrant实例和用户输入之间的所有通信和协调。

下面是一个使用FastAPI的例子:

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

from fastapi import FastAPI, File, HTTPException, Depends, Body, UploadFile
from fastapi.security import HTTPBearer
from fastapi.middleware.cors import CORSMiddleware
from models.api import (
    AskQuestionRequest,
    AskQuestionResponse,
)app = FastAPI()
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)bearer_scheme = HTTPBearer()@app.post(
  "/ask-question",
  response_model=AskQuestionResponse,
)
async def ask_question(
  request: AskQuestionRequest = Body(...),
):
  try:
    question = request.question
		# vector_store and llm should be classes that provide an interface into your hosted Qdrant and Llama2 instances
    documents = await vector_store.query(question)
    answer = await llm.ask(documents, question)
    return AskQuestionResponse(answer=answer)
  except Exception as e:
    print(e)
    raise HTTPException(status_code=500, detail=str(e))

您可以在RAGstack库中看到这些部分是如何组合在一起的-应用程序的入口点是从 server/main.py 运行的FastAPI服务器。

禁用验证

In order to make testing our new RAG model easier, we can Allow unauthenticated invocations for each of our GCP services (hosted Llama 2 model, the hosted Qdrant image, any API server you have set up).

Make sure you set up authentication after your testing is complete or you might run into some surprises on your next billing cycle. GPUs ain’t cheap!

测试您的RAG模型

有趣的部分来了!我们现在有了一个Llama 7B服务、一个Qdrant实例和一个API服务，将所有这些部分连接在一起，所有这些都部署在GCP上。

使用这个简单的cURL查询您的新RAG模型。

1
2
3
4
5

curl --location '$API_SERVICE_URL/ask-question' \\
--header 'Content-Type: application/json' \\
--data '{
    "question": "Who was president of the united states of america in 1890?"
}'

Replace $API_SERVICE_URL with the URL to the service that is responsible for connecting the vector store and Llama 2.

得到答案后，就可以在自己的基础设施上有效地部署ChatGPT，并将其连接到自己的文档。您可以提出问题并获得答案，而无需向外部第三方进行单个API调用!

原文：How to connect Llama 2 to your own data, privately

很有可能，你已经遇到了来自各种第三方AI公司的声明，他们介绍了他们的工具能够将任何绘图或图像转换为功能齐全的网站。乍一看，这个功能似乎对那些可能对AI能力的进步表示钦佩的人很有吸引力。然而，随着我们深入探索llm驱动的应用程序领域，我们应该知道，利用现有的AI技术实现这些功能并不需要太多的努力。

将图纸转换为网站的应用不仅令人着迷，而且非常实用。它为设计师和开发人员开辟了令人兴奋的可能性，使他们能够快速将创意转化为功能网页。当然，要使整个网站具有草图上的所有功能，像这样的应用程序的一次性生成可能会很困难，因为您必须与语言模型进行来回对话以完善细节。然而，即使是一个简单的网站演示，反映你的画只是非常方便，在网上分享想法，制作小工具，并在舞台上现场演示。

跟着我来创建应用程序吧!

1. 设计概述

Drawing2Website的开发将由图像识别和LLM两个促成因素催化。图像认知有很多选择，在这个项目中，我使用微软Azure计算机视觉服务来完成这个任务。至于LLM，毫无疑问，我将继续调用带有GPT模型的Langchain方法来完成源代码生成任务。

使用Streamlit进行web框架设计，演示应用程序的性能与在线服务相比相当有竞争力。让我们来看看。

a) 用户体验

让我们来看看这个演示应用程序的UI，让您了解一下它的视觉效果。请注意，这就像我对大多数llm驱动的应用程序所做的那样，这些应用程序没有太复杂的用户体验。专注于关键功能的实现，用户体验总是直接设计，并将进一步的扩展留给开发人员。

登陆页面

一个简单的登陆页面显示了一个文本输入栏，您可以在其中粘贴绘图图片的URL。如果你没有，你必须绘制一个布局并将其上传到像ibb.co这样的图像存储服务，或者你可以直接使用我的。按“运行”键使发动机启动。

Website生成

当认知和生成任务完成后，将同时显示原始绘图图片和生成的网站UI，并显示包含HTML源代码的扩展栏。

b) 框图

让我们来研究一下这个应用程序的框图，以便更清楚地了解信息流和操作是如何执行的。别担心，这个图表很简单，很容易理解。

Block Diagram

首先将绘图图像上传到Azure Computer Vision服务中，获取基于文本的认知结果。我们的应用程序提取已识别的文本块及其坐标。然后将这些元素集成到Langchainprompt模板工具中，该工具使用GPT-3.5或GPT-4模型与LLMChain通信，以生成HTML/CSS源代码。最后，Streamlit Components小部件用于将源代码转换为iFrame内的功能HTML网站。

2. 代码走查

现在，让我们一步一步地探索将这个Drawing2Website带入生活的代码工作流。

a) Azure计算机视觉

Azure计算机视觉是一种基于云的认知服务，为开发人员提供了处理和分析视觉数据的高级算法。它是微软Azure认知服务的一部分，该服务允许开发人员将视觉、语音、语言、搜索和知识等AI功能轻松整合到他们的应用程序中。计算机视觉的主要特性包括图像分类、对象检测、光学字符识别、人脸检测、条形码扫描、图像调节等。

在这个项目中，我们将使用OCR(光学字符识别)服务进行文本识别，而不需要任何预训练。

首先，你必须在Azure帐户中订阅计算机视觉服务。假设您已经有了一个帐户，您应该访问服务的门户来创建订阅。单击Create按钮创建一个，并按照下一页中的流程完成订阅。请记住，对于可用带宽有限的演示应用程序，您可以选择F0作为免费价格层。

一旦你完成了你的订阅，就会有一个工作的服务在列表中，像我的“yeyulab-vision”，点击详细页面上的名称。除了可以在概述页面上找到的端点和密钥之外，您不应该再关注其他细节。把它们复制到安全的地方，稍后再开发。

端点和密钥

要在Python中实现视觉认知功能，首先，您应该pip安装这些包。

1
2

!pip install --upgrade azure-cognitiveservices-vision-computervision
!pip install pillow

导入我们稍后将使用的所有模块。

1
2
3
4
5
6
7
8

from azure.cognitiveservices.vision.computervision import ComputerVisionClient
from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
from azure.cognitiveservices.vision.computervision.models import VisualFeatureTypes
from msrest.authentication import CognitiveServicesCredentials

from array import array
import os
from PIL import Image

加载我们在创建订阅时复制的端点和密钥。然后在此基础上创建计算机视觉客户端。

1
2
3

subscription_key = "Your Key"
endpoint = "Your endpoint"
computervision_client = ComputerVisionClient(endpoint, CognitiveServicesCredentials(subscription_key))

现在我们要定义一个识别在线图像的方法。

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

def text_recognition(img_url):

    print("===== Read File - remote =====")
    read_response = computervision_client.read(img_url,  raw=True)
    read_operation_location = read_response.headers["Operation-Location"]
    operation_id = read_operation_location.split("/")[-1]

    # Call the "GET" API and wait for it to retrieve the results 
    while True:
        read_result = computervision_client.get_read_result(operation_id)
        if read_result.status not in ['notStarted', 'running']:
            break
        time.sleep(1)

    layout = []
    if read_result.status == OperationStatusCodes.succeeded:
        for text_result in read_result.analyze_result.read_results:
            for line in text_result.lines:
                layout.append({line.text:line.bounding_box})
    print(layout)
    print("End of Computer Vision.")
    return layout

这是从文本图像中识别每一行的标准过程，它们的协调称为bounding_box，它表示一个文本块的四个外部顶点。最后一步是返回结构中的布局字典:

1
2
3
4
5
6

[{'News Contact About': [11.0, 32.0, 979.0, 7.0, 982.0, 97.0, 13.0, 123.0]}, 
{'Welcome to Yeyu's site': [216.0, 483.0, 2210.0, 373.0, 2222.0, 558.0, 227.0, 675.0]}, 
{'INPUT': [262.0, 847.0, 658.0, 824.0, 664.0, 938.0, 264.0, 958.0]}, 
{'Button': [1713.0, 1021.0, 2084.0, 1011.0, 2089.0, 1127.0, 1713.0, 1140.0]}, 
{'It's So FunTo Have You Here!': [217.0, 1463.0, 2348.0, 1420.0, 2350.0, 1585.0, 222.0, 1651.0]}, 
{'Copyright@2023. Yeyulab': [586.0, 2146.0, 2123.0, 2069.0, 2129.0, 2224.0, 591.0, 2297.0]}]

b) Langchain LLMChain

在本项目中，我们只使用基于Langchain的LLMChain来处理prompt模板，该模板将使用文本认知结果的输出来构建，以prompt语言模型。

通常我们首先应该做的是安装langchain。

1

!pip install langchain openai

导入模块并设置OpenAI API Key。

1
2
3
4
5
6

from langchain.prompts import PromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.chains import LLMChain
import os

os.environ["OPENAI_API_KEY"] = "Your API Key"

然后定义一个方法’ html_gen(layout) ‘，从输入的图像认知文本生成HTML源代码。

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

def html_gen(layout):
    prompt = PromptTemplate(
        template="""This is a layout of a handwriting website design, including text and their coordinates of four outer vertices. 
        Make an HTML modern sans-serif website that reflects these elements and decide which 
        CSS can be used to match their relative positions, try to use proper layout tags to match
         their font size and relative placement based on their coordinates. 
         Use <ul> and <li> if the elements look like as menu list. 
         Smartly use function tags like <button> <input> if their names look like that.
         Your design should be prior to the coordinates, 
         then you should also use some imagination for the layout and CSS from common web design principle.
         Remember, don't use absolute coordinates in your HTML source code. 
         Generate only source code file, no description: {layout}.\n""",
        input_variables=["layout"]
    )
    llm = ChatOpenAI(model="gpt-4-0613",temperature=0)
    chain = LLMChain(prompt=prompt, llm=llm)
    output = chain.run(layout=layout)
    print(output)

    return output

最关键的部分是prompt模板，其中包含许多关于每个元素的文本位置的说明，并强调样式。

c) Streamlit

作为最后一步，我们应该使用Streamlit和它的小部件将所有这些功能包装成一个流畅的用户交互。

让我们先安装Streamlit。

1

!pip install streamlit

导入Streamlit包和组件类。

1
2

import streamlit as st
import streamlit.components.v1 as components

定义两个session_state (HTML和image)来缓存生成的HTML源代码文本和图像URL文本。

1
2
3
4

if "html" not in st.session_state:
    st.session_state.html = ""
if "image" not in st.session_state:
    st.session_state.image = ''

现在我们创建一个回调函数来触发图像认知和HTML生成。

1
2
3
4
5
6
7
8

def image_run():
    html_code = ""
    layout = text_recognition(st.session_state.img)
    if layout != []:
        html_code = html_gen(layout)

    st.session_state.html = html_code
    st.session_state.image = st.session_state.img

最后创建所有必要的UI小部件，包括标题、列、用于图像URL的文本输入、用于提交的按钮、用于图像显示的图像、用于源代码容器的扩展器以及用于处理HTML框架的组件API。

1
2
3
4
5
6
7
8
9
10
11
12

st.title("Yeyu's Drawing to web")
col1, col2 = st.columns([0.5, 0.5], gap='medium')
with col1:
    st.text_input("Image URL:", value="", key='img')
    st.button("Run", on_click=image_run)
    if st.session_state.image != '':
        st.image(st.session_state.image)
with col2:
    with st.expander("See source code"):
        st.code(st.session_state.html)
    with st.container():
        components.html(st.session_state.html, height=600, scrolling=True)

将以上所有代码打包到一个文件” drawing2web.py “中，然后在终端上运行命令:

1

!python -m streamlit run drawing2web.py

如果运行成功，将打印外部用户可以访问的带有默认端口的URL:

1
2
3

You can now view your Streamlit app in your browser.
Network URL: http://xxx.xxx.xxx.xxx:8501
External URL: http://xxx.xxx.xxx.xxx:8501

您的Drawing2Website生成器现在已经准备好并能够执行其任务。

原文:Create an AI Application That Transforming Your Drawing into a Website

本文讨论的是互联网出现之后，不断衍生的各种商业模式。好像任何一家目前已知的互联网和软件公司都在这31种商业模式里面。

今天我们先介绍1-10种，如果你是企业家、独立开发者，也许对你会有帮助。

首先，让我们来看看不同类型的创业公司。

1. 免费增值(Freemium)商业模式(免费增值=免费+增值付费)

免费增值商业模式允许用户“免费”使用软件、游戏或服务的基本功能，然后对基本包的“升级”收费。

案例

Google Drive、iCloud和 Slack

这里的想法是为用户提供一个基本的，功能齐全的免费版本的产品或服务。

Google Drive和Dropbox将为您提供15GB和2GB的免费空间，但如果您购买一些额外的空间，则需要支付额外费用。

具体形式

• 基于容量的免费增值：在一定的使用量或用户（团队协作人数等）数量之前免费，超过一定数量的用户必须付费才能继续使用该服务。例如:Dropbox, Evernote

• 基于功能的免费模式：即免费版本拥有有限的功能，并且需要付费计划才能解锁所有功能。例如:Buffer, Skype, Notion, SEMRush

• 基于时间的免费增值模式：提供产品或服务的免费版本，但只在有限的时间内提供，即标准的“免费试用”。例子:Audible(7天)，Shopify(14天)

利弊

优点

• 低用户获取率:免费提供基本服务很容易吸引用户。

• 营销效果:人们可能会传播免费服务的信息(口碑)

• 网络效应:使用一项服务的人越多，它对其他用户的吸引力就越大

缺点

• 付费用户不足:免费增值模式吸引了大量免费用户，但你无法将他们转化为足够多的付费用户。

付费转化率

不同免费增值定价策略的转化率?

试用转化率=试用到付费用户的数量/试用用户的数量。

例如，如果你的产品有500个试用用户，90个试用用户转化为付费客户。在这种情况下，你的试用转化率将是:

90/500 × 100 = 18%

转化率很大程度上取决于产品的复杂性和目标受众(B2C vs. B2B)。

B2C行业平均：57%

B2C行业平均：14-25%

例如，Netflix的视频转化率为93%，而亚马逊Prime的视频转化率为73%。

2. 订阅(Subscription)业务商业模式

订阅业务模式是基于销售产品或服务，以获得每月或每年的经常性订阅收入的理念，这里有很自然有MRR（月度经常性收入）和ARR（年度经常性收入）的概念了，这是投资人非常喜欢的数据，因为经常性收入相对来说运气成分较少，收集你的新用户增长率和老用户流失率，可以相对容易地测算一家公司的未来三年基本发展势头。

案例

Tinder, Netflix, Shopify

只有当用户有兴趣按月付费或愿意使用某些付费功能时，这才是免费增值商业模式的下一步。

具体形式

• 伞式订阅：你可以把所有的服务捆绑在一个订阅伞下，发挥整合优势。亚马逊Prime ：在Prime保护伞下，您将获得一天交货，亚马逊Prime视频和Prime音乐。
• 特别订阅通行证：当订阅给你从人群中脱颖而出的优势，也就是我们常说的人民币玩家的方式。例子:Tinder和Dash Pass，Tinder——推荐你的个人资料给更多的女孩，Dash Pass——更快的交付与低费用。
• 订阅箱：当你订阅每月送货上门的产品时。例子：Warby Parker每三个月发给你发一次隐形眼镜。MeUndies每个月送出两件非常性感又舒服的内衣。
• 生态系统订阅——使用订阅可以降低生意的进入门槛，并将你锁定在生态系统中时。例如:Shopify。

利弊

使用订阅业务模型有几个好处：

• 可预测的现金流： 在第一次购买后，他们需要继续购买产品，从而产生可预测的现金流和经常性利润。
• 良好的追加销售和交叉销售机会：如果dollar shave Club出售一系列优质刀片，那么他们也可以出售其他产品，如剃须膏、须后水等。
• 更高的利润：基础产品通常亏本销售，而附加产品则通常以更高的利润销售。

订阅业务模式的缺点：

• 流失率：你必须不断为你的客户增加价值，否则他们会流失，严重影响你未来的现金流。例如:网飞公司每个月都会推出一部新剧集，以证明每月的订阅费用是合理的

• 高昂的用户获取成本：只有一小部分人每个月都愿意为你付费。所以你需要花很多钱去获取他们。

3. 市场平台商业模式

市场平台是一个平台(电子商务网站或移动应用程序)，产品或服务由第三方卖家出售给客户。

案例

Amazon, Fiverr等

市场平台商业模式

• Airbnb 是一个让业主将自己的空间出租给旅行者的市场。
• 亚马逊有第三方卖家或小企业主在他们的平台上销售他们的产品。
• Fiverr是一个威客平台，有自由职业者，他们为其他个人或公司提供图形设计和软件开发等特定服务。

具体形式

市场确保了产品的供需平衡，促进了交易，并为用户创造了一个值得信赖和安全的环境。

具体来说，主要有以下三种模式：

• 轻型市场：他们只管理平台，不沉迷于后台或质量检查等运营工作。例如:51同城、Craigslist

• 管理市场：他们做一些运营工作，比如质量检查，以确保客户从他们的服务中获得最好的体验。例子:淘宝、天猫、Airbnb和Etsy

• 高度管理的市场：控制端到端运营和供应链，专注于速度、成本和体验例如:亚马逊、京东、优步

Marketplace商业模式的关键支柱是什么?

• 市场经济学：帮助我们理解增长，供需平衡以及价格均衡。一旦你的业务达到一定规模，你就可以通过动态定价、折扣等技术来维持需求和供应，比如滴滴在上班高峰期的打车定价会上升，或者要求加价。

• 市场科学：匹配，推荐引擎和市场流动性。涉及搜索、匹配和推荐的算法和数据科学模型，以确保用户找到他们需要的东西并进行交易。

• 市场转换优化：转换漏斗优化和增长循环。比如著名的增长飞轮，如亚马逊，更多选择和低廉的价格吸引了更多的顾客从亚马逊购买产品，这也推动了更多的卖家加入市场并开始销售他们的产品。

• 市场信任与安全：去中介化和阻止不良行为者进入。这一点很重要，包括淘宝（客服、小二仲裁）+支付宝（担保交易）的方式，是中国电商一下子崛起的基础。

为什么市场商业模式如此强大?

• 轻资产：Airbnb不像酒店那样拥有那么多建筑。
• 边际成本几乎为零：Airbnb的收益来自外部资源(比如房东)，而不是雇人。
• 他们受益于网络效应：在Airbnb中，在平台上注册的房东越多，注册的房客就越多，反之亦然。

4. 资源整合业务模型

在聚合器业务模型中，服务以客户的品牌名称交付给客户。

案例

Uber, Airbnb等

聚合器在市场和聚合器的商业模式之间有细微的区别。

市场：像Amazon和Fiverr这样的市场连接供应商和客户，比如Nike在里面还是叫Nike，并从这些供应商那里获得10% - 20%的收入分成。

聚合：像Uber和Airbnb这样的聚合器加入这些供应商，并以他们自己的品牌名称提供产品，比如哪怕车子和驾驶员都不是真正Uber的员工和资产，但是他们服务的时候，一定是说：”您好，我是Uber…“。

5. 按需付费商业模式

这是一种“定价策略”，用户根据消费多少付费。它被云计算公司广泛使用。

案例

Google云平台(GCP)、亚马逊云服务 (AWS)、阿里云（Aliyun）

Pay-as-you-go pricing in AWS

例如，亚马逊网络服务(AWS)是亚马逊的子公司，提供200多种云服务，每种服务都有自己的即用即付定价系统。

“简而言之，按需付费。”

什么时候应该使用按需付费定价?

这种按需付费的商业模式是在很难将客户划分为几个定价层的情况下使用的，就像你在Canva等软件产品中看到的那样。

利弊

现收现付定价模式的好处?

• 较低的前期成本吸引用户：没有像订阅计划那样的固定金额承诺，只需为您将使用的内容付费。示例:如果客户一个月付费发送5000封邮件，而下个月没有发送邮件，则无需支付任何费用。
• 你可以对高消费收取更高的费用：与每个人支付相同金额的固定费率系统不同，即用即付是实时可扩展的。所以如果你有更高的使用率，那就收取更高的费用。你不需要在合同和月费率上再做一次修改。
• 采用现收现付模式，营收增长更快：采用基于使用的定价模式的公司的年营收增长率为29.9%，而SaaS的平均增长率为21.7%。

现收现付定价模式的缺点?

这种现收现付的商业模式被AWS、DigitalOcean、谷歌云平台和Mailchimp等公司广泛使用。

• 留住客户的挑战：订阅计划通常是按年销售的，给客户提供一些折扣。但付费用户可能很快就会流失，因为他们没有做出承诺。
• 收入是不可预测的和不稳定的-订阅给你一个可预测的现金流不像现收现付

6. 付费服务(FFS)的商业模式

FFS的商业模式是根据每次成功付款向客户收取固定和可变费用。

案例

Stripe, Paypal, and PayU

Stripe对每笔成功执行的支付交易收取2.9% + 30美分的费用。

这些公司提供一个支付网关来接受客户的付款，然后将钱结算到一个企业账号上。

FaaS

其实这个行业非常大，甚至可以把它认为是和SaaS平行的一个行业，叫FaaS，金额即服务。它会有以下分类：

1.支付处理商业模式

• 汇款支付：有一些初创公司通过发行信用卡参与了汇款业务的第一部分。例如:Brex, RAMP等

• 收单结算支付：提供支付网关的初创公司代表我们接受付款并在月底结算。例如:Stripe、Paypal等

2.垂直领域的支出管理业务模式

• AP/AR(应收账款和应付账款)软件：这些软件即服务处理发票，审批工作流程，付款和与会计系统的对账。例如:Tipalti
• 费用软件：这些软件即服务(SaaS)可以帮助你进行实时费用管理，控制支出限制和报销等。

3.薪酬和福利业务模式

工资单是公司产生的最大费用，因此他们需要一款可以做入职、时间跟踪、退休、保险等工作的产品

• **企业资源计划(ERP)**：帮助组织管理日常业务活动，如会计、采购、项目管理等。例如:SAP、Netsuite等
• 人力资源信息系统(HRIS)：是员工主数据的集中存储库。例子：Workday；
• 人力资源管理系统(HRMS)：是一个自动化许多业务功能的软件程序，包括工资和福利。例子：Darwinbox。

4.股权与融资

财务：Betterment自动化投资和管理现金回报。

股权：Carta可以帮助你轻松管理你的市值表，使它容易结构和发行股票。

信用：BlueVine帮助您获得廉价贷款快速使用您的会计信息从Quickbooks，支付数据从Stripe，销售数据从Shopify等。

5.会计和财务报告

企业使用的会计软件，如Xero、QuickBooks、NetSuite等，可以帮助你更快地结帐。

财务报告：实时性、可见性，数据仓库和BI工具，能够像PowerBI, Excel和Tableau那样根据需要提取数据和切片。

7. 教育科技商业模式

在教育科技的商业模式中，你要么通过出售内容，要么通过向最终用户提供教学服务来赚钱。

教育科技的商业模式类型

• 免费订阅：当课程内容是免费的，但你需要支付课程证书，如Coursera

• 免费试用订阅 ：提供免费试用，然后按月或按年订阅，例如SkillShare

• 市场平台：自我服务模式，你可以选择从开放市场中学习什么。

• 广告收入商业模式：核心产品是免费的，公司通过向他们拥有的庞大用户群展示广告来赚钱。

8. 锁定型商业模式

“锁定”的目的是制造一个障碍，限制顾客从你的品牌或产品转向竞争对手的产品。

它结合了增加转换成本或努力转移(软锁定)或卓越的品牌体验或激励

案例

Apple, SAP等

苹果卖给你一部iPhone，然后用其他硬件(手表、Airpod)和平台服务(如苹果商店、苹果音乐、云计算等)把你锁定在他们的生态系统中。

9. API许可业务模式

应用程序编程接口，或简称API，是一种允许第三方应用程序与您的服务通信的工具。

优步和爱彼迎在其移动应用程序中使用谷歌地图api，以方便导航。

案例

Twilio (SMS), Sendgrid(Email), Google Map APIs(Map) 等

以下是不同类型的api业务模型

1. 免费:最简单的api驱动的商业模式，允许应用程序开发人员免费访问api。例如，Facebook和谷歌翻译。

2. 开发者付费:这种模式的运作形式是应用开发者必须为所提供的服务付费，如Ex AWS, Twilio, Github, Stripe等

3. **开发者获得报酬:**这些是使用他们的内容来分发api的付费开发者或内容发行商。前Adsense，亚马逊联盟等。

10. 开源商业模式

开放源代码软件是带有源代码的软件，任何人都可以检查、修改和改进供个人使用。

案例

Andriod, Java, Firefox等

2018年，谷歌向Mozilla支付了4.3570.2亿美元，将谷歌作为其默认搜索引擎。

以下是开源软件赚钱的六种方式：

1. 付费支持 -项目维护者有很多关于代码库的知识，他可以为个性化收费。

2. 软件即服务(MongoDB Atlas) -提供免费但付费的完整数据库解决方案监控工具。

3. 开放核心模型 -为开源项目提供更好的GUI选择(R studio)。

4. GitHub赞助商- 100%的赞助去开发人员

5. **付费功能请求- **获得为现有产品构建开源扩展的付费

如果说到开源的商业模式，一般会有以下几种：

1. 开放核心：这是一种商业策略，公司免费提供有限功能的产品的“核心”版本，并提供附加的商业版本作为专有软件。比如linux内核是开放的，但是suse、redhat等商业版本是赚钱的，这些企业也是内核的积极开发者。

免费版本作为一个增长渠道，建立了一个用户基础，可以增加源代码，而公司开发的企业版本将推动收入。

2. 系统集成或服务模型：当客户为技术支持、咨询服务或附加组件付费时。

例子:Red Hat, Video JS的创始人

虽然红帽公司的咨询收入是它的三倍，但他们的利润率为31%，而订阅业务的利润率为93%。

因此，服务业务的收入是不可预测的，需要大量的员工，而利润率却很低。

3. 云业务（全托管）：它使没有成熟的内部DevOps团队的小公司能够使用公司自己的基础设施，而不必担心管理基础设施的运营开销。

MongoDB的云业务占比约为65%，Elastic占比约为40%。

4. 应用市场：核心产品是开源的，他们从市场/插件/插件中赚取收入。

   • Android通过play store收费来赚钱。

   • WordPress从市场费用中赚钱。

   • 通过将谷歌作为默认搜索引擎，Mozilla每年创造了5亿美元的收入。

ChatGPT改变了我们处理工作的方式，为生产力和效率开辟了新的可能性。

有了这个了不起的AI工具，我们不再局限于专注于一种技能;相反，我们现在可以在几个小时内处理各种任务。ChatGPT的帮助使我们能够在几分钟内完成许多普通任务，展示了其令人难以置信的节省时间的能力。

然而，重要的是要认识到，虽然ChatGPT功能强大且用途广泛，但仍有某些任务可能不适合它。

这就是我们今天要探讨的，还有另外五款重要的AI工具可以极大提升我们的工作。

1. Diagram

Figma最近收购了Diagram，这引起了我的注意。

让我告诉你关于Diagram -它真的令人印象深刻!他们推出了一系列AI工具，如Magician、Genius、Automator和UI-AI。

首先，Magician工具像魔术一样工作!您可以使用AI的力量进行设计，为您需要的任何东西生成SVG图标，并毫不费力地为您的设计创建迷人的视觉效果。

下一个是Genius，指的是纯粹的才华。它可以帮助您将您的想法转化为令人惊叹的设计，甚至在您工作时自动建议元素，使您的设计过程变得轻而易举。

然后我们有Automator，这是一个改变游戏规则的工具。只需点击一下，您就可以在Figma中自动执行重复的设计任务，节省您宝贵的时间和精力。

最好的部分是，还有更多令人兴奋的功能即将推出!

因此，请密切关注Diagram在未来为我们准备的内容。Figma和Diagram结合在一起，设计师的可能性是无限的!

2. Albus AI

现在，让我向你介绍这个神奇的工具，Albus AI，终极知识探索者，它将彻底改变你对信息的思考方式!

想象一下: 一个会让你大吃一惊的活动板，以你从未想象过的方式向你展示主题!

事情是这样的: 有了Ablus AI，你可以产生源源不断的想法，你的创造力将永无止境。

想学习新技能? 没问题! Ablus AI将是你可靠的向导，带领你在旅途中成为你所关注的大师。

这还不是全部!

当你发现新的角度和观点时，准备好迎接一次拓展思维的经历，这将点燃你前所未有的好奇心。

3. PageUps

这些天来，Twitter是我的主要关注点，为了提高工作效率，我一直在研究可以使我的工作流程自动化并加快工作速度的工具。

就在那时，我遇到了Pageup，让我告诉你，它改变了游戏规则! 它旨在帮助您安排，组织和分析您的推文和线程。

有了PageUps，你可以为你的推文添加书签，方便访问，过滤和排序选项使按类别和类型管理推文变得轻而易举。另外，你甚至可以批量起草和安排你的推文和线程，节省你大量的时间。

不仅如此，拖放调度工具还可以非常方便地计划和调度您想要的内容。

最好的部分是，它提供了详细的性能分析，因此您可以跟踪您的tweet和线程的运行情况。

很酷,对吧?

4. Runway

我必须分享这个神奇的AI工具，我已经发现，不能停止使用!

它提供了30多种不同的AI工具，一个比一个更令人印象深刻。

让我告诉你我最喜欢的，Gen-2:文本到视频。有了这个工具，您可以毫不费力地使用文本prompts创建视频。这就像有您的视频向导在您的指尖!

然后是第1代:视频到视频，同样令人兴奋。您可以使用文本或图像转换视频的样式。只需上传视频，添加一些文本，然后观看视频的颜色和整体外观的变化。

而这仅仅是个开始!这个工具提供了更多的功能。

它可以帮助您创建自定义肖像，为您的设计增添个人风格。另外，你可以用文字生成原始图像，将你的视觉效果提升到一个全新的创造力水平。

更不用说，你可以使用这个AI工具来扩展任何图像的边缘，创造出独特而引人注目的效果。

哦，这是锦上添花!该工具还可以将一系列图像转换为动画视频，以一种迷人的方式使您的静止镜头栩栩如生。

5. Wonder Studio

这个列表中最突出的工具之一是Wonder Studio——一个令人难以置信的人工智能宝石!

有了Wonder Studio，你可以做一些令人印象深刻的事情。它通过动画、照明和将它们组合成真人场景，自动将CG角色带入生活。这有多酷?

让我给你解释一下。这个工具工作起来很神奇。

首先，它从单镜头镜头中检测演员的表演。然后，它无缝地将性能转移到您选择的CG角色，自动处理所有动画，灯光和构图。

这里是最好的部分:Wonder Studio自动化了高达80%到90%的“客观”视觉特效工作，为你照顾技术方面的东西。

因此，作为一名艺术家，你必须专注于有趣和创造性的“主观”工作，将你的愿景带入生活。然后，您可以将您的杰作导出到您已经使用的软件中。

这个工具改变了游戏规则，简化了视觉特效过程，让艺术家充分释放他们的创造力。

所以，如果你想在你的项目中添加一些令人敬畏的视觉效果，Wonder Studio是必须尝试的!

Llama 2是由AI研究公司Meta开发并发布的下一代大型语言模型(LLM)。它在2万亿个公共数据tokens上进行了预训练，旨在使开发人员和组织能够构建生成式人工智能工具和体验。Llama 2在许多外部基准上优于其他开源语言模型，包括推理、编码、熟练程度和知识测试。

Llama2可免费用于研究和商业用途，并可从Meta的网站下载。然而，如果你想在Mac M1设备上运行Llama2，并用你自己的数据训练它，你需要遵循一些额外的步骤。本文将指导您完成在Mac M1上设置Llama2的过程，并针对您的特定用例进行微调。

内容大纲

• 步骤1:安装所需的依赖项
• 步骤2:下载Llama2模型权重和代码
• 步骤3:微调Llama2与您自己的数据
• 步骤4:生成文本与微调Llama2模型

步骤 1:安装所需的环境依赖

要在Mac M1上运行Llama2，你需要安装一些依赖项，比如Python、PyTorch、TensorFlow和HuggingFace Transformers。您可以使用Homebrew或Anaconda来安装这些软件包（如果Python以后会成为你的主要开发语言，那么建议用Anaconda）。例如，要使用Homebrew安装Python 3.9，您可以在终端运行以下命令:

1

brew install python@3.9

安装Mac M1的PyTorch，你可以按照下面的链接:https://pytorch.org/get-started/locally/#macos-version

安装Mac M1的TensorFlow，你可以按照下面的链接:https://developer.apple.com/metal/tensorflow-plugin/.

安装Hugging Face Transformers，你可以在终端运行以下命令:

1

pip install transformers

步骤2:下载Llama2模型权重和代码

要下载Llama2模型权重和代码，您需要在Meta的网站上填写表格并同意他们的隐私政策。提交表单后，您将收到一封电子邮件，其中包含下载模型文件的链接。你可以选择不同的Llama2型号，从7B到70B参数范围。微调的变体，称为lama-2-chat，针对对话用例进行了优化。

在本教程中，我们将使用Llama-2-chat-7B模型作为示例。您可以从这个链接下载模型权重和代码:https://ai.meta.com/llama/llama-2-chat-7B.zip。下载zip文件后，您可以将其解压缩到首选目录中。你应该看到一个名为llama-2-chat-7B的文件夹，其中包含以下文件:

• config.json: 模型的配置文件。
• pytorch_model.bin: PyTorch模型权重文件。
• tokenizer.json: 模型的标记器文件。
• vocab.txt: 模型的词汇表文件。
• run_generation.py: 用模型生成文本的Python脚本。

步骤3: 用自己的数据微调Llama2

要用您自己的数据对Llama2进行微调，您需要准备一个包含您的训练数据的文本文件。文件中的每一行都应该包含一个对话回合或一个模型指令。例如，如果您想为客户服务聊天机器人微调Llama2，您的训练集文件可能看起来像这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

USER: Hi, I have a problem with my order.
LLAMA: Hello, thank you for contacting us. What is your order number?

USER: It's #123456789.
LLAMA: I see. What is the issue with your order?

USER: I received a damaged item.
LLAMA: I'm sorry to hear that. Could you please send us a photo of the item and your receipt?

USER: Sure, here they are.
LLAMA: Thank you. We apologize for the inconvenience. We will process your refund as soon as possible.

USER: Thank you for your help.
LLAMA: You're welcome. Is there anything else I can assist you with today?

USER: No, that's all. Have a nice day.
LLAMA: Thank you for choosing us. Have a nice day too.

您可以将训练文件作为train.txt保存在与模型文件相同的目录中。然后，您可以在终端中运行以下命令，使用您的训练数据对Llama 2进行微调:

1

python run_generation.py --model_type gpt2 --model_name_or_path ./llama-2-chat-7B --train_data_file ./train.txt --output_dir ./llama-2-chat-7B-finetuned --do_train --per_device_train_batch_size 1 --gradient_accumulation_steps 4 --learning_rate 5e-5 --num_train_epochs 3 --save_steps 1000 --save_total_limit 1

该命令将使用以下参数微调Llama 2:

• model_type:模型类型，对于Llama 2，为gpt2。
• model_name_or_path:模型目录的路径，在此例中为。/ lama-2-chat- 7b。
• train_data_file:训练数据文件的路径，在此例中为。/train.txt。
• output_dir:输出目录的路径，将保存微调模型，在本例中为。/ lama-2-chat- 7b - fintuned。
• do_train:一个标志，表示我们想要训练模型。
• per_device_train_batch_size:每台设备用于训练的批处理大小，在本例中为1。
• gradient_accumulation_steps:在执行向后/更新传递之前累积梯度的步数，在本例中为4。
• learning_rate:训练的学习率，在本例中为5e-5。
• num_train_epochs:训练模型的epoch数，在本例中为3。save_steps:每个检查点保存之间的步数，在本例中为1000。
• save_total_limit:要保留的最大检查点数，在本例中为1。

您可以根据需要和可用资源调整这些参数。请注意，微调Llama 2可能需要很长时间，并且需要大量内存和计算能力，特别是对于较大的模型。您可以通过查看打印在终端上的日志来监控培训过程的进度。

步骤4: 生成文本与微调Llama2模型

在用自己的数据对Llama 2进行微调后，在终端运行以下命令，可以使用微调后的模型生成文本:

1

python run_generation.py --model_type gpt2 --model_name_or_path ./llama-2-chat-7B-finetuned --length 100 --prompt "USER: Hi, I want to cancel my subscription."

该命令将生成具有以下参数的文本:

• model_type: 模型的类型，对于Llama2来说是gpt2。
• model_name_or_path:微调模型目录的路径，在本例中为./llama-2-chat- 7b - fintuned。
• length: 生成文本的最大长度，在本例中为100个tokens。
• prompt: 模型的文本输入是“USER:嗨，我想取消订阅。在这种情况下。

您可以根据自己的需要和偏好更改这些参数。您还可以通过使用 - no_cuda标志并在终端中输入文本输入来与模型进行交互。例如:

1
2
3
4
5
6
7
8
9
10

python run_generation.py --model_type gpt2 --model_name_or_path ./llama-2-chat-7B-finetuned --length 100 --no_cuda

USER: Hi, I want to cancel my subscription.
LLAMA: Hello, thank you for contacting us. May I ask why you want to cancel your subscription?

USER: I don't use your service anymore.
LLAMA: I see. Well, we are sorry to lose you as a customer. To cancel your subscription, you will need to log in to your account and go to the settings page. There you will find an option to cancel your subscription. Do you need any help with that?

USER: No, thank you. I can do it myself.
LLAMA: OK then. Thank you for choosing us and we hope you have a great day.

最后

Llama2是一个强大而通用的大型语言模型，可用于各种生成和会话AI应用程序。通过使用您自己的数据对其进行微调，您可以针对您的特定用例对其进行定制，并改进其性能和相关性。我希望你发现这篇文章有帮助和信息。

原文：How to Run Llama 2 on Mac M1 and Train with Your Own Data

Stability AI最近发布了其第一个官方版本Stable DiffusionXL (SDXL) v1.0，如果你不熟悉Stable Diffusion，这里有一个简短的概述:

Stable Diffusion是由创业公司Stability AI开发的文本到图像的AI模型。它接受prompt并根据该描述生成图像。Stable Diffusion与其他流行的AI图像模型(如OpenAI的Dall-E2或Midjourney)的区别在于它是开源的。这意味着任何人都可以使用它或为其开发做出贡献。

在本文中，我将向您展示如何使用Automatic1111的web设置和运行SDXL 1.0模型的分步指南。

系统需求

我在一台Windows电脑上运行，这是我目前的设置

• 操作系统: Windows 11 64-bit
• 显卡: Nvidia RTX3060 Ti
• 虚拟内存: 8 GB
• 总内存: 16 GB

对于苹果M1芯片用户来说，它也可以工作，但性能可能会迟钝。

如何安装Automatic1111

Step #1: 从GitHub获取项目

你可以在本机上创建一个文件夹，然后复制GitHub项目的代码，如果你安装了git，直接可以用使用git clone命令。

在本地机器上查看，这些是您应该看到的文件。

Step #2: 下载Checkpoint file和权重

SDXL的权重（weight）文件可在HuggingFace上获得。下载这两个文件并将它们放在Stable-diffusion-web\models\Stable Diffusion目录下。

• Checkpoint file (6.94 GB)
• Refiner file (6.08 GB)

这就是你的Stable Diffusion文件夹的样子:

Step #3: 运行Automatic1111

打开终端，执行webui-user.bat文件。这将调用webui.bat 文件，该文件将完成所有的环境设置和安装依赖项。

注意:此步骤需要几分钟才能完成

完成后，将在您的终端上显示确认消息。通过浏览器http://127.0.0.1:7860访问Stable Diffusionweb界面。

如果你遇到一个错误，比如ModuleNotFoundError: No module named ‘basicsr.version’。就像我做的那样，做下面的事情:

• cd到~\stable-diffusion-web\repositories\CodeFormer
• 执行命令pip install basicsr - target=./ - upgrade

接下来，单击刷新按钮来加载模型并选择基本模型。

太棒了!现在您已经准备好生成图像了。

Step #4: 生成示例图

让我们试着用这个prompt生成一个图像:

An astronaut riding a horse in space

这没什么了不起的。现在让我们用细化器加载基本模型，添加负面prompts，并为其提供更高的分辨率。

Prompt: Image of Beautiful model, baby face, modern pink shirt, brown cotton skirt, belt, jewelry, arms at sides, 8k, UHD, stunning, energy, molecular, textures, iridescent and luminescent scales, breathtaking beauty, pure perfection, divine presence, unforgettable, impressive, breathtaking beauty, Volumetric light, auras, rays, vivid colors reflects

Negative prompt: ugly, deformed, noisy, blurry, distorted, and grainy, ugly, deformed, noisy, blurry, distorted, and grainy

SDXL v1.0也生成NSFW图像吗?

SDXL v1.0旨在过滤掉NSFW内容。要生成NSFW图像，您需要一个基于SDXL的自定义模型。

有关自定义和开源AI模型，请参见CivitAI网站。

简简单单就这样了。

原文：How To Setup SDXL 1.0 with Automatic1111 and Run on Your Local PC

MidJourney 和 Stable Diffusion 是两种最流行的AI图像生成器。这两家公司最近都发布了最新、最强大的版本——Midjourney 5.2和SDXL 1.0。

• Midjourney5.2与前作相比，改进了美学和更清晰的效果。
• SDXL1.0特别适合鲜艳和准确的色彩，与以前的版本相比，具有更好的对比度，照明和阴影。

那么，这两个哪个更好呢?

我将使用相同的prompt来比较这些图像生成工具的功能，涵盖从肖像到风景、时尚等各种类别。

让我们开始吧。

1.肖像

Prompt: Photo of a brooding serious bearded old

这两个AI工具都很好地处理了这个prompt。它本质上归结为个人偏好，即一个人更喜欢哪种图像。

就我个人而言，我觉得左边的图片更具视觉吸引力。逼真的胡须和蓬乱的头发使他看起来更加粗犷和令人信服。

Midjourney：1

SDXL：0

2.表情

Prompt: A portrait of a woman experiencing surprise and joy upon receiving a gift

尽管StableAI团队声称SDXL可以比其他开源模型更好地生成手，但上述结果表明它在这方面仍然面临挑战。

另一方面，Midjourney能够以令人印象深刻的精确度渲染手和四肢。

Midjourney：2

SDXL：0

3.生物

Prompt: A majestic dragon soaring over misty mountains

左边的龙在鳞片上有更精细的细节，姿势也比右边的更酷。它还有一种凶猛的表情，这让它看起来更吓人。我很喜欢Midjourney渲染生物时的效果。

Midjourney：3

SDXL：0

4.城市景观

Prompt: A bustling night scene in Tokyo with bright neon signs and busy pedestrians

在这个例子中，我对结果的不同感到惊讶。SDXL追求更现实的输出，而Midjourney则类似于数字插图。

Midjourney：3

SDXL：1

5.蒸汽朋克

Prompt: A steampunk-themed elephant walking through an old industrial city

如果你喜欢数字插图的柔和色调，你可能会被右边的图像所吸引。然而，不可否认的是，左图中的细节水平和大象对士兵的强烈注视更吸引人。

Midjourney：3.5

SDXL：1.5

6.动漫

Prompt: A scene from a shōnen anime, showing an epic battle between two young warriors in a destroyed city

就设计和整体美学而言，Midjourney更胜一筹。然而，这张照片并不完全符合prompt，因为这两个角色并没有参与战斗。另一方面，SDXL更准确地捕捉到了这一方面。

Midjourney：3.5

SDXL：2.5

7.抽象艺术

Prompt: An abstract illustration representing the complexity of human emotions using geometric shapes and a vibrant color palette

两个看起来都不错——值得挂在墙上。左边的图像更加抽象和梦幻。形状更加流畅和有机，颜色生动。

右边的图像更加几何化和结构化。造型更加棱角分明，色彩更加柔和。这在很大程度上取决于个人偏好，但我喜欢左边的图像。

Midjourney：4

SDXL：3

8.食物

Prompt: An appetizing spread of a traditional Italian dinner, including a Margherita pizza, spaghetti carbonara, bruschetta, and a bottle of Chianti

这些图片不会让你胃口大开吗?这两个模型在渲染食物方面都做得很好，唯一不足的是右图的桌面摆放稍微欠缺真实，当然也有可能是大户人家的桌子就是这么大这么豪横。

Midjourney：4.5

SDXL：3.5

9.3D渲染

Prompt: A 3D isometric render of a futuristic, eco-friendly city skyline, with skyscrapers covered in greenery and flying cars

Midjourney显然是这个prompt的赢家，因为SDXL似乎并没有完全理解我在追求什么。

Midjourney：5.5

SDXL：3.5

就我的评判来说，Midjourney在整体上要比SDXL要更好。

当然，你无法去除个人的主观色彩，所以你怎么看这个比较?

原文：SDXL 1.0 vs MidJourney 5.2 — Same Prompt, Different Results

大型语言模型(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