untitled

The curly brackets {} in Python have different meanings depending on the context. Here are some common uses of {} in Python:

Dictionary literals:

A dictionary is a data structure that stores key-value pairs. You can create a dictionary by using curly brackets and separating the keys and values by colons. For example, person = {"name": "Alice", "age": 25} creates a dictionary with two keys: “name” and “age”, and their corresponding values: “Alice” and 25.

Set literals:

A set is a data structure that stores unique and unordered elements. You can create a set by using curly brackets and separating the elements by commas. For example, colors = {"red", "green", "blue"} creates a set with three elements: “red”, “green”, and “blue”.

String formatting:

You can use curly brackets as placeholders for variables or expressions in a string. You can then use the format() method to replace the placeholders with the desired values. For example, print("Hello, {}!".format("world")) prints “Hello, world!” to the console. You can also use numbers or keywords inside the curly brackets to specify the order or name of the arguments. For example, print("The area of a circle with radius {r} is {a:.2f}".format(r=5, a=3.14*5**2)) prints “The area of a circle with radius 5 is 78.50” to the console.

Nginx反向代理服务器配置

Nginx 可以作为非常强大的反向代理服务器,下面是一个简单的 Nginx 反向代理的配置示例以及对应的详细解释:

nginx
Copy code
http {
    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
    }

    server {
        listen 80;
        server_name www.example.com;

        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}

配置解释

http 块:

这是 Nginx 配置中的顶级块,用于包含 HTTP 服务器的配置。
upstream backend 块:
这个块定义了一个名为 backend 的服务器组,可以包含一个或多个服务器。
server backend1.example.com; 和 server backend2.example.com; 行指定了组成这个服务器组的后端服务器的地址。这些服务器可以是其他 Nginx 服务器,也可以是任何能够处理 HTTP 请求的服务器。

server 块:

这个块定义了一个虚拟服务器,用于处理进入的 HTTP 请求。
listen 80; 行告诉 Nginx 在端口 80 上监听请求,这是 HTTP 的默认端口。
server_name www.example.com; 行定义了服务器的域名。

location / 块:

location 块用于定义当请求匹配特定模式时应如何处理这些请求。在这个例子中,/ 指的是匹配所有请求。
proxy_pass http://backend; 行指定将请求转发到名为 backend 的上游服务器组。这意味着所有到达此 Nginx 服务器的 HTTP 请求都会被转发到 backend1.example.com 或 backend2.example.com。

proxy_set_header 指令:

这些指令用于修改或添加传递给后端服务器的 HTTP 请求头。
Host $host; 将请求头中的 Host 设置为客户端请求中的 Host 值。
X-Real-IP $remote_addr; 添加了一个自定义请求头,包含客户端的 IP 地址。
X-Forwarded-For $proxy_add_x_forwarded_for; 添加了一个请求头,包含原始请求的 IP 地址链。这对于在后端服务器上记录正确的客户端 IP 地址很重要。
X-Forwarded-Proto $scheme; 添加了一个请求头,标明了客户端是使用 HTTP 还是 HTTPS 协议。

通过上述配置,Nginx 会将所有到达 www.example.com 的请求转发到两个后端服务器之一,并保持客户端的原始 IP 地址和其它相关信息,使得后端服务器能够获取到正确的客户端信息。

从国内访问chatgpt

方案一

下面是在 Linux 服务器上配置 OpenVPN 客户端、设置路由以及保证应用通过 VPN 隧道访问 ChatGPT API 的一般步骤和命令。请注意,在进行以下操作之前,请确保您拥有阿里云服务器的 root 权限或 sudo 权限,以及加拿大 OpenVPN 服务器的必要配置文件。

步骤 1: 安装 OpenVPN 客户端
在您的阿里云服务器上安装 OpenVPN 客户端:

sudo apt-get update  # 如果是基于 Debian 的系统
sudo apt-get install openvpn

或者

sudo yum update  # 如果是基于 RHEL 的系统
sudo yum install openvpn

步骤 2: 配置 OpenVPN 客户端
将从加拿大 OpenVPN 服务器获取的配置文件(通常是 .ovpn 文件)传输到阿里云服务器。
启动 OpenVPN 客户端,连接到服务器:

sudo openvpn --config /path/to/your/vpnconfig.ovpn

确保将 /path/to/your/vpnconfig.ovpn 替换为您的实际配置文件路径。这条命令将启动 OpenVPN 并尝试连接到您的加拿大 VPN 服务器。

步骤 3: 路由设置
修改 OpenVPN 配置文件以添加路由。打开 .ovpn 文件,添加类似以下行来指定路由:

route ChatGPT_API_IP 255.255.255.255 vpn_gateway

将 ChatGPT_API_IP 替换为 ChatGPT API 的实际 IP 地址,vpn_gateway 通常会自动设置为通过 VPN 连接的默认网关。

或者,您也可以在 OpenVPN 连接后通过命令行手动添加路由:

sudo ip route add ChatGPT_API_IP/32 via VPN_GATEWAY_IP dev tun0

将 ChatGPT_API_IP 替换为 ChatGPT API 的 IP 地址,VPN_GATEWAY_IP 替换为您 VPN 的网关 IP,tun0 是 OpenVPN 使用的默认网络接口,如果您的配置不同,请相应调整。

步骤 4: 验证连接
一旦 OpenVPN 客户端启动并且路由设置完成,您可以使用 ping 命令或类似的网络工具来测试 VPN 连接和路由是否正确:

ping ChatGPT_API_IP

也可以查看路由表确保新路由已经设置:

ip route show

步骤 5: 应用配置
确保您的应用在发起到 ChatGPT API 的请求时,不需要任何特别的配置,因为操作系统的路由表已经指示了通过 VPN 隧道转发到 ChatGPT API 的流量。

步骤 6: 持久化 VPN 连接
为了确保 VPN 连接在服务器重启后自动启动,您可以将 OpenVPN 连接命令添加到系统的启动脚本中,如 rc.local 或使用系统的服务管理器(如 systemd)创建一个服务。

这里的步骤和命令提供了一般的指南,具体的命令可能会根据您的 Linux 发行版和 OpenVPN 配置有所不同。此外,确保您具有连接到 OpenVPN 服务器所需的所有凭据和权限。

方案二

要设置加拿大服务器作为反向代理服务器并转发请求到 ChatGPT API,你可以使用 Nginx 或 Apache。下面以 Nginx 为例,提供详细的配置步骤和命令。

Nginx 反向代理配置
步骤 1: 安装 Nginx

在加拿大的服务器上安装 Nginx:

sudo apt update  # 对于 Debian/Ubuntu 系统
sudo apt install nginx

或者对于 RHEL/CentOS 系统

sudo yum update
sudo yum install nginx

步骤 2: 配置 Nginx 作为反向代理

创建一个新的 Nginx 配置文件或编辑现有的站点配置文件:

sudo nano /etc/nginx/sites-available/chatgpt-proxy

在配置文件中添加以下内容:

server {
    listen 80;
    server_name your-canadian-server.com;  # 替换为你加拿大服务器的域名或IP

    location / {
        proxy_pass https://api.openai.com/v1/;  # ChatGPT API 的 URL
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

启用配置并测试:

sudo ln -s /etc/nginx/sites-available/chatgpt-proxy /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

步骤 3: 配置 SSL/TLS

使用 Let’s Encrypt 提供的 certbot 工具来自动获取和安装 SSL 证书:

sudo apt install certbot python3-certbot-nginx  # 对于 Debian/Ubuntu 系统

或者

sudo yum install certbot python3-certbot-nginx  # 对于 RHEL/CentOS 系统

sudo certbot --nginx -d your-canadian-server.com  # 用实际域名替换
Certbot 会自动处理证书的获取和安装,并修改 Nginx 配置以启用 HTTPS。

步骤 4: (可选) 设置 API 认证

如果需要,你可以在 Nginx 配置中添加基本认证:

location / {
    # ...其他配置保持不变...

    auth_basic "Restricted Content";
    auth_basic_user_file /etc/nginx/.htpasswd;  # 路径到密码文件
}

创建密码文件并设置用户和密码:

sudo apt-get install apache2-utils  # 安装 htpasswd 工具
sudo htpasswd -c /etc/nginx/.htpasswd username  # 用实际用户名替换

步骤 5: 修改阿里云应用配置

在阿里云服务器上的应用中,你需要将所有指向 ChatGPT API 的请求修改为通过你的加拿大服务器反向代理的 URL。

例如,如果你的加拿大服务器域名是 your-canadian-server.com,应用中的 API 请求 URL 应更改为:

https://your-canadian-server.com/v1/...  # 具体路径根据实际请求调整

注意事项
确保在配置 Nginx 或应用时替换所有的占位符(如 your-canadian-server.com 和 username)为实际的值。
使用 SSL/TLS 时,确保你的域名已正确解析到加拿大服务器的 IP 地址,并且端口 80 和 443 在服务器上是开放的。
测试配置更改后的应用以确保它可以通过加拿大服务器正确访问 ChatGPT API

方案三

要通过 SSH 隧道来转发请求到 ChatGPT API,你需要在阿里云服务器上执行以下步骤:

步骤 1: 建立 SSH 隧道
在阿里云服务器上,使用 SSH 命令建立一个隧道。这个隧道将本地端口转发到加拿大服务器上的端口,然后由加拿大服务器转发到 ChatGPT API。

执行以下命令以建立隧道:

ssh -L [本地端口]:api.openai.com:443 [用户]@[加拿大服务器IP] -N -f

[本地端口]:这是阿里云服务器上的本地端口号,选择一个未被使用的端口,例如 8080。
api.openai.com:443:这是 ChatGPT API 的域名和端口。
[用户]:这是你在加拿大服务器上的用户名。
[加拿大服务器IP]:这是加拿大服务器的公网 IP 地址。
-N 告诉 SSH 客户端不执行远程命令,只进行端口转发。
-f 告诉 SSH 客户端在后台运行。
例如:

ssh -L 8080:api.openai.com:443 myuser@198.51.100.0 -N -f

这条命令将在后台创建一个 SSH 隧道,把阿里云服务器上的 8080 端口的流量转发到 api.openai.com 的 443 端口上。
步骤 2: 测试端口转发
测试本地端口转发是否工作正常:

curl -v https://localhost:8080/v1/engines -H "Authorization: Bearer YOUR_OPENAI_API_KEY"

这个命令应该返回 ChatGPT API 的响应。确保将 YOUR_OPENAI_API_KEY 替换为你的实际 OpenAI API 密钥。

步骤 3: 修改应用配置
修改你在阿里云服务器上的应用配置,把所有指向 ChatGPT API 的请求改为通过本地端口:

https://localhost:8080/v1/...

这样,当你的应用尝试连接到 ChatGPT API 时,实际上它将通过 SSH 隧道发送请求。

注意事项
请确保你的阿里云服务器上的防火墙配置允许本地端口(例如 8080)的流量。
你可能需要在加拿大服务器上配置 SSH 以允许端口转发。
在生产环境中使用 SSH 隧道时,可能需要考虑使用更稳健的方法来保持隧道的持续运行,如使用 autossh。
由于使用了 -f 参数,SSH 命令会在后台运行。如果需要终止隧道,你可以找到对应的 SSH 进程并杀掉它,或者关闭监听本地端口的 SSH 隧道。

simple llm app

我最近在用sensenova的api做测试,每次都在代码里上传,太麻烦了,打算做个小app。

第一步是系统设计。

用chatgpt里的software architecture visualiser工具

第一次生成效果

第二次重新调整了输入,经历几次语法错误后,生成如下

使用商汤sensenova一周体会

总体评价,开发手册比较全面,但是部分关键概念对小白不是非常友好,很多地方和chatgpt比起来是有不少差距的,但是,我看了看价格,所有的缺点就变成优点了。:)

  1. 有python的官方sensenova库,pip直接安装就好
    1.但使用官方库,目前在构建知识库的时候,只支持knowledge 1这种参数,也就是json格式。如果想使用knowledge 2,也就是直接上传pdf、word等格式的文件,就要采用直接调用api的方式,也就是要使用python request库才可以。虽然区别不大,但也是小坑。

  2. 对于文件,要区分你是打算fine tune还是知识库,两种目的的文件格式是完全不同的,如下

    1. fine tune的格式如下

    1. 知识库的格式如下
      第一种方式,官方库和api都支持

    第二种方式,只支持api

  3. 我在项目上遇到了一个问题:需要从上传的知识库(先上传文件,然后转化成知识库,应该是向量化了),对某一个应急事件进行分类判断。但是chatgpt和sensenova给出了同样错误的答案。

    1. 目前打算不使用pdf,而是换json的方式来实现精准匹配。

商汤的llm示例代码分析

这是商汤sensennova大语言模型的示例代码(对话生成_无对话历史)

stream = True # 流式输出或非流式输出
model_id = "nova-ptc-xl-v1" # 填写真实的模型ID

resp = sensenova.ChatCompletion.create(
    messages=[{"role": "user", "content": "人生天地间,下一句是啥"}],
    model=model_id,
    stream=stream,
    max_new_tokens=1024,
    n=1,
    repetition_penalty=1.05,
    temperature=0.9,
    top_p=0.7,
    know_ids=[],
    user="sensenova-python-test-user",
    knowledge_config={
        "control_level": "normal",
        "knowledge_base_result": True,
        "knowledge_base_configs":[]
    },
    plugins={
        "associated_knowledge": {
            "content": "需要注入给模型的知识",
            "mode": "concatenate"
        },
        "web_search": {
            "search_enable": True,
            "result_enable": True
        },
    }
)

if not stream:
    resp = [resp]
for part in resp:
    choices = part['data']["choices"]
    for c_idx, c in enumerate(choices):
        if len(choices) > 1:
            sys.stdout.write("===== Chat Completion {} =====\n".format(c_idx))
        if stream:
            delta = c.get("delta")
            if delta:
                sys.stdout.write(delta)
        else:
            sys.stdout.write(c["message"])
            if len(choices) > 1:
                sys.stdout.write("\n")
        sys.stdout.flush()

下面我们来line by line的解释

英文

  1. stream = True: This line sets a variable named stream. If True, it indicates that the output will be in a streaming fashion. Streaming output is typically used for real-time data processing.
  2. model_id = "nova-ptc-xl-v1": Here, model_id is set to the string "nova-ptc-xl-v1", which seems to be the identifier of a specific model in the Sensenova framework.
  3. resp = sensenova.ChatCompletion.create(…): This line calls the create method of the ChatCompletion class from the sensenova module. This method likely generates a chat completion or response based on the given parameters.
  4. messages=[{"role": "user", "content": "人生天地间,下一句是啥"}]: Specifies the input message for the chat model. Here, the role is set as "user" and the content is a Chinese phrase.
  5. model=model_id: Specifies the model to be used for chat completion.
  6. stream=stream: Passes the stream variable to control streaming behavior.
  7. max_new_tokens=1024: Limits the number of new tokens (words/characters) that the model can generate.
  8. n=1: Indicates that the number of completions to generate is 1.
  9. repetition_penalty=1.05: Adjusts the likelihood of the model repeating the same line.
  10. temperature=0.9: Sets the creativity or randomness of the response.
  11. top_p=0.7: Controls the diversity of the response.
  12. know_ids=[]: An empty list, possibly for specifying known IDs for context or tracking.
  13. user="sensenova-python-test-user": Specifies a user identifier.
  14. knowledge_config={…}: Configures how the model should use external knowledge.
  15. plugins={…}: Configures additional features or plugins, like injecting knowledge (associated_knowledge) and enabling web search (web_search).
  16. if not stream: resp = [resp]: If stream is False, this wraps resp in a list. This is probably for consistency in processing the response whether it’s streaming or not.
  17. for part in resp:: Iterates over each part in the response.
  18. choices = part[‘data’]["choices"]: Extracts the choices from the response data. This might contain the actual chat completions or responses.
  19. for c_idx, c in enumerate(choices):: Iterates over the choices, with c_idx being the index and c being the content.
  20. if len(choices) > 1: …: If there are multiple choices, it prints a separator with the index.
  21. Inside the nested if and else:
  22. If stream is True, it prints delta from each choice, which might be a part of the streaming response.
  23. If stream is False, it prints the message from each choice.
  24. sys.stdout.flush(): Ensures that everything written to the standard output is actually displayed. This is often used in streaming or real-time applications to update the output promptly.

This code seems to be a part of a chatbot implementation using the Sensenova framework, where it sends a message to a chat model and processes the response, either in a streaming manner or as a complete response.

中文

  • stream = True:这行代码设置了一个名为 stream 的变量。如果为 True,表示输出将以流式方式进行。流式输出通常用于实时数据处理。
  • model_id = "nova-ptc-xl-v1":这里,model_id 被设置为字符串 "nova-ptc-xl-v1",这似乎是 Sensenova 框架中特定模型的标识符。
  • resp = sensenova.ChatCompletion.create(…):这行代码调用了 sensenova 模块中 ChatCompletion 类的 create 方法。这个方法可能会根据给定的参数生成聊天回复。
  • messages=[{"role": "user", "content": "人生天地间,下一句是啥"}]:指定了聊天模型的输入消息。这里,角色被设置为 "user",内容是一个中文短语。
  • model=model_id:指定用于聊天完成的模型。
  • stream=stream:传递 stream 变量以控制流式行为。
  • max_new_tokens=1024:限制模型可以生成的新令牌(单词/字符)的数量。
  • n=1:表示要生成的完成次数为 1。
  • repetition_penalty=1.05:调整模型重复相同行的可能性。
  • temperature=0.9:设置回应的创造性或随机性。
  • top_p=0.7:控制回应的多样性。
  • know_ids=[]:一个空列表,可能用于指定上下文或跟踪的已知 ID。
  • user="sensenova-python-test-user":指定用户标识符。
  • knowledge_config={…}:配置模型如何使用外部知识。
  • plugins={…}:配置额外的功能或插件,如注入知识(associated_knowledge)和启用网络搜索(web_search)。
  • if not stream: resp = [resp]:如果 stream 为 False,则将 resp 包装在列表中。这可能是为了无论是否流式,处理响应时的一致性。
  • for part in resp::遍历响应中的每个部分。
  • choices = part[‘data’]["choices"]:从响应数据中提取 choices。这可能包含实际的聊天完成或响应。
  • for c_idx, c in enumerate(choices)::遍历 choices,c_idx 为索引,c 为内容。
  • if len(choices) > 1: …:如果有多个选项,它将打印一个分隔符和索引。
  • 在嵌套的 if 和 else 中:
    • 如果 stream 为 True,它会打印每个选项中的 delta,这可能是流式响应的一部分。
    • 如果 stream 为 False,它会打印每个选项中的 message。
  • sys.stdout.flush():确保写入标准输出的所有内容实际上都被显示。这在流式或实时应用中经常用于及时更新输出。

这段代码似乎是使用 Sensenova 框架的聊天机器人实现的一部分,其中它发送消息到聊天模型并处理响应,无论是以流式方式还是作为完整的响应。

核采样参数

top_p:核采样参数,用于解码生成token的过程。

“核采样参数,解码生成token时,在概率和大于等于top_p的最小token集合中进行采样”这句话描述的是一种称为“核采样”(Top-p sampling)的机制,它用于生成语言模型的回复。下面是这个概念的详细解释:

核采样(Top-p sampling):这是一种在自然语言处理中用于生成文本的技术。在生成下一个词(token)时,核采样只考虑那些累积概率和达到指定阈值 top_p 的最可能的词。 解码生成token:当语言模型生成回复时,它逐个生成词(token)。解码过程是选择每个步骤中应该生成哪个词的过程。 在概率和大于等于top_p的最小token集合中进行采样:这意味着在生成每个词时,模型会查看所有可能的下一个词及其概率。然后,它计算这些概率的累积和,并选择一个累积和至少为 top_p 的词的集合。模型仅从这个集合中随机选择下一个词,而不是从所有可能的词中选择。 举例来说,如果 top_p 设为0.7,模型会考虑累积概率和至少达到70%的那部分词。这样的选择过程确保了生成的文本既有一定的多样性(因为不总是选择最可能的词),同时也保持了一定的连贯性和可读性。 核采样是一种平衡生成文本多样性和可预测性的有效方法,常用于各种基于深度学习的语言生成模型。

python的class、instance

Instance:

In Python, an instance is a specific object created from a class. A class is a blueprint that defines the members (attributes and methods) it supports, and an instance is a concrete object created based on this blueprint. Each instance has the attributes and methods defined in the class.
Example: If you have a Dog class, when you create a Dog object, that object is an instance of the Dog class.

class Dog:
    def __init__(self, name):
        self.name = name

my_dog = Dog("Buddy")  # my_dog is an instance of the Dog class

Object:

In Python, an object is the fundamental unit in the program, and almost everything is an object, including numbers, strings, data structures, functions, and even classes themselves. Each object has a type (indicating what it is) and identity (a unique identifier).
Example: In the Dog class above, my_dog is not just an instance, but also an object.

Item:

In Python, an item typically refers to a single element within a container type like a list, tuple, or dictionary.
Example: In a list, each element at a position is an item.

numbers = [1, 2, 3]
first_item = numbers[0]  # first_item is an item in the list, with a value of 1

Attribute:

In Python, an attribute is a variable that belongs to an object. In a class definition, attributes are variables defined outside of methods and are used to store the state of an instance.
Example: In the Dog class, name is an attribute.

class Dog:
    def __init__(self, name):
        self.name = name  # name is an attribute

my_dog = Dog("Buddy")
print(my_dog.name)  # Accessing the name attribute of my_dog

In this example, Dog is a class, my_dog is an instance of the Dog class (and also an object), name is an attribute of the my_dog object, and [1, 2, 3] is a list where 1, 2, and 3 are items in the list.

中文解释

让我们结合Python语言来重新解释这些概念,并给出相应的例子:

实例(Instance):

在Python中,实例是根据类创建的具体对象。类是一种定义其成员(属性和方法)的模板,而实例是根据这个模板创建的具体对象。每个实例都拥有类中定义的属性和方法。
例子:如果有一个类Dog,当你创建一个Dog的对象时,这个对象就是Dog类的一个实例。

class Dog:
    def __init__(self, name):
        self.name = name

my_dog = Dog("Buddy")  # my_dog 是 Dog 类的一个实例

对象(Object):

在Python中,对象是程序中的基本单元,几乎所有东西都是对象,包括数字、字符串、数据结构、函数,以及类本身。每个对象都有类型(表示它是什么)和身份(标识它是独一无二的)。
例子:在上面的Dog类中,my_dog不仅是一个实例,也是一个对象。
项目(Item):
在Python中,项目通常指的是容器类型(如列表、元组、字典)中的单个元素。
例子:在一个列表中,每个位置的元素都是一个项目。

numbers = [1, 2, 3]
first_item = numbers[0]  # first_item 是列表中的一个项目,值为 1

属性(Attribute):

在Python中,属性是附属于对象的变量。在类的定义中,属性是定义在方法外的变量,它们用于存储实例的状态。
例子:在Dog类中,name是一个属性。

class Dog:
    def __init__(self, name):
        self.name = name  # name 是一个属性

my_dog = Dog("Buddy")
print(my_dog.name)  # 访问 my_dog 的 name 属性

在这个例子中,Dog是一个类,my_dog是Dog类的一个实例(同时也是一个对象),name是my_dog对象的一个属性,而[1, 2, 3]是一个列表,其中的1、2、3是列表的项目。