什么是神经网络

类似于大脑中的神经元传递信息的过程，将多个输入通过多层模型处理后得到结果输出的架构，就是神经网络

复杂神经网络的表示

从预测手写数据0和1 的过程，理解神经网络向前传播的计算原理

The parameters have dimensions that are sized for a neural network with 25 units in layer 1, 15 units in layer 2 and 1 output unit in layer 3.
the dimensions of these parameters are determined as follows:
If network has 𝑠𝑖𝑛 units in a layer and 𝑠𝑜𝑢𝑡 units in the next layer, then
𝑊 will be of dimension 𝑠𝑖𝑛×𝑠𝑜𝑢𝑡 .
𝑏 will a vector with 𝑠𝑜𝑢𝑡 elements
Therefore, the shapes of W, and b, are
layer1: The shape of W1 is (400, 25) and the shape of b1 is (25,)
layer2: The shape of W2 is (25, 15) and the shape of b2 is: (15,)
layer3: The shape of W3 is (15, 1) and the shape of b3 is: (1,)
Note: The bias vector b could be represented as a 1-D (n,) or 2-D (n,1) array. Tensorflow utilizes a 1-D representation and this lab will maintain that convention.

向前传播：从左到右计算，根据输入计算出输出，输出即预测结果，

使用tensorflow 实现向前传播的神经网络

具体实现

Tensorflow models are built layer by layer. A layer’s input dimensions ( 𝑠𝑖𝑛 above) are calculated for you. You specify a layer’s output dimensions and this determines the next layer’s input dimension. The input dimension of the first layer is derived from the size of the input data specified in the model.fit statment below.

Note: It is also possible to add an input layer that specifies the input dimension of the first layer. For example:
tf.keras.Input(shape=(400,)), #specify input shape
We will include that here to illuminate some model sizing.

调用numpy()方法可以实现张量和numpy matrix 之间的转换

使用tensorflow 实现神经网络的另外一种架构形式

The model.compile statement defines a loss function and specifies a compile optimization.
The model.fit statement runs gradient descent and fits the weights to the data.

图片识别0和1练习

神经网络的训练过程

如何选择激活函数

常见的三种激活函数

选择激活函数的一般规则
对于输出层，根据输出值来
如果是二分类问题，使用sigmoid
如果是输出正负值都有就选则线性激活函数
如果输出值非负，那么 就使用ReLu函数
对于中间层，一律使用ReLu函数
原因有三

1. 一个是作为激活函数，本身计算过程比sigmoid 函数简单
2. relu只有在小于0 的时候斜率为0，sigmoid 函数在趋向正负无穷的时候有两处斜率趋近0 的情况，会导致梯度下降计算过程变慢，所以ReLu函数在梯度下降过程相比之下会更快一些
3. 如果在隐藏层使用线性激活函数，输出层是sigmoid函数，整个过程等同于线性回归，最终始终会变成二分类的结果

什么是过拟合

训练得到的预测模型对于每个训练数据都非常吻合，导致对于新的测试数据无法正确评估的现象，就是过拟合
下面是线性回归和逻辑回归模型三种训练结果的展示

解决办法

1. 收集更多的数据进行训练
2. 选择和使用有价值的特性值参与运算
3. 减小部分特征值(对于结果预测关系不大的特征值)的参数值（正则化）

正则化

在成本函数或者损失函数中增加正则化参数，避免过拟合

在梯度下降计算过程中，会使得每个参数在原来基础上乘以一个比1小的数据再去进行减法运算，从而使得梯度下降过程中实现参数进一步缩小

cost and gradient functions for both linear and logistic regression. Note:

Cost

The cost functions differ significantly between linear and logistic regression, but adding regularization to the equations is the same.

Gradient

The gradient functions for linear and logistic regression are very similar. They differ only in the implementation of $f_{wb}$.

线性回归正则化

逻辑回归正则化

实践案例

背景&&解决问题

逻辑回归模型时一种解决二分类问题的算法

如果用线性回归去解决分类问题，会导致过拟合出现，每增加一个测试数据，都可能导致模型发生变化

通过使用sigmoid function函数，设置阈值，可以将线性回归产生的结果归类到两个结果上去

虽然目标是二分类，即结果只能是0 或者1
但是f(w,b) = g(w·x+b) 计算的结果值A只能无限接近这两个值
这里可以将A理解成结果是1 的可能性

决策边界

在逻辑回归模型f(w,b) = g(w·x+b) 中
z = w·x+b 又称为 决策边界，将不同结果的数据在坐标系中进行隔离
如果特征在z 中没有多项式运算，那么，得到的边界必定是直线的，但是如果有多项式，拿得到的边界线就是非线性的

成本函数

线性回归的平方误差算法的成本函数在应用到逻辑回归时，会产生多个局部最小值，再用梯度下降的算法去找参数时，无法找到最小值

逻辑回归引入逻辑损失函数，根据单个数据集随参数变化的趋势，判断整体的变化趋势
操作就是将原本平方误差除以2的操作移到求和之前，单独计算每个特征值的部分就是损失函数

Logistic Regression uses a loss function more suited to the task of categorization where the target is 0 or 1 rather than any number.

these definitions are used:

Loss is a measure of the difference of a single example to its target value while the

Cost is a measure of the losses over the training set

下面是推导过程和最终的式子

梯度下降找到w&b

一些专业术语表达

x–> 训练数据入参，特征值，这里仅有一个，这个模型也被叫做 单变量线性回归模型 x(i) 第i个训练数据的x
y–> 训练数据入参，标记值， example 的lable ,y(i) 第i个训练数据的y
y-hat –> 出参，推测值, 模型（f（x）= wx + b） 的 结果值

成本函数

平方误差成本函数

在f(x) = wx+ b 的模型中
w: 斜率
b: 截距，intercepter 直接与Y轴交点距离远点距离

用J(w,b)表示成本函数，找到能够使J(w,b) 的值最小的w和b，就可以找到使f(x)最接近所有测试集的模型，最拟合训练数据的模型
先讨论在b = 0 的情况下，j（w） 随w 变化的趋势

找到使j(w) 最小的w,即U形线最凹的地方

现在把b的变化趋势也加入讨论，j(w,b) 随w，b 变化的趋势，将变成3d 的碗状

最凹的地方就是J(w,b)值最小的地方

利用等高线的表达方式，换一种视角找J(w,b)的最小值，就是将3D 图进行水平切割，得到关于w,b 的二维椭圆视图
不同(w,b) 组合可能会落在在同一条线上的，相同线上的J(w,b)值一样大
所以能够使J(w,b)值最小的(w,b)值，就是同心圆里面最里面那个圆上的多对(w,b), 当圆极限到一个点时，就只有一对(w,b)使J(w,b)最小

GradientDescentAlgorithm 梯度下降算法

是一种寻找使成本函数达到最小值参数的通用算法，现在不再局限与于f(x) = wx+b 单变量线性模型
对于多变量模型，也就意味着多个w, 这样J(w,b) 就会变成J(w0,…wi,b), J(w0, …wi) 的趋势不再是U形

梯度下降指的是，从一个点出发，环顾四周，找到能够下降的谷底的最快的方向，即梯度最陡的方向，下降一步，每走一步都按最陡方案下降，从而实现最快到达谷底的目的
达到谷底即意味着找到J(w0,…wi,b)最小值
但是梯度下降有一个特性，就是，虽然从同一点出发，如果第一步选择反向不同，或者走的方式不同，肯定会到达不同谷底
不同谷底意味着不同的J(w0,…wi,b)最小值，这些最小值，都叫做局部最小值

算法实现与理解

J(w,b)关于w 导数 表征 U形趋势线上随w 变化的梯度值，也就是斜率
前面的系数α表征 下坡的步伐大小 是一个0-1 的正小数值，称为学习率
w,b 同时变化，同时更新

当梯度大于0时，temp_w 逐渐变小，J(w,b) 的值也逐渐变小
当梯度小于0 时，temp_w 逐渐变大（负斜率，绝对值在变小）， J(w,b)的值逐渐变小
说明J(w,b) 的值随梯度的变化符合随w的变化趋势
当斜率绝对值逐渐变小时，就是都朝J(w,b) 最小值聚拢

实验

关于学习率

太小会增加计算步骤，从而使梯度算法变慢
太大可能导致过冲，永远无法到达最小值;甚至无法实现聚拢趋势，导致发散

局部最小值

如果当前参数已经使得成本函数到达一个局部最小值，那么J(w,b) 关于w 导数值将会是0，那么temp_w 会始终停留在一个固定的值，不再变化
梯度下降算法将不会再进行下一步的计算，保持当前参数在当前的这个一个局部最小值的状态

随这个梯度下降，我们可以知道我们正在朝成本函数最小值靠近，在学习率固定情况下，更新步骤也在下降(斜率本身朝0在逐渐变小)，说明没有学习率的变化，也能到达局部最小值
但如果同时将学习率调小，降低下降的步伐，可以更小幅度的一点点接近最小值，最终找到成本函数最小值

小结

线性回归模型，成本函数，和梯度下降算法


上述梯度下降算法具体来说是批量梯度下降，因为每一步都用到了所有训练数据

多元线性回归

以上讨论的是只有一个特征值x 作为输入的情况，下面要讨论的是同时有n个特征值做输入的模型，被称为多元线性回归模型

一些符号的表示方法

模型表达式

向量化

好处

1. 代码实现简洁
2. 运算速度快

对于多元线性回归 的 梯度下降算法

w 相关的计算转成向量计算，不同权重值，取对应特征值进行计算

实验

实践技巧

如何更快的找到合适的参数去拟合训练集

特征缩放

参数大小与特征值大小关系

如果某一特征值(x1 属于[1000,5000]范围)相对其他特征值(x2,x3,..xn,属于[1,10]范围),数值范围较大，其对应参数w1 则相对其他较小
反之，如果特征值较小，则参数较大，这样的规律可以更快的找到适合的参数


如果特征值的取值范围非常不同时，会导致梯度下降速度变慢
但如果将所有特征值想办法归一到相同的范围内，就可以加快梯度下降过程，降低计算步骤

缩放计算方式

除以最大值

特征值除以各自范围的最大值

均值归一化

特征值 减去平均值，再除以极差值(范围最大值减去范围最小值)

Z-SCORE归一化

特征值 减去 标准差，除以 平均值

说明

并不一定非要落在-1 到1 之间，落在相同的数量级之间就可接受

如何找到成本函数最小值

学习曲线

绘制成本函数随迭代次数变化的趋势图，称为学习曲线，主要是根据曲线走势判断梯度是否在收敛
如果随迭代次数增加，成本函数一直呈下降趋势，说明梯度正在下降，是正常的
当下降到一定程度，随迭代次数成本函数不再有明显下降，说明梯度收敛到了极限，也就是找到了成本函数的最低点
但如果随次数增加，成本函数出现上升，这是不正常的，则说明学习率选取过大，需要重新选取，或者代码出现错误

自动收敛测试

自行定义一个极小的值，当某次迭代后成本函数值小于该值时，就认为梯度下降关闭，成本函数达到最小值，停止迭代，取当前迭代wb做模型参数
缺点就是极小值难以估计，且结果不太可靠

如何选择合适学习率

根据学习曲线调整学习率
学习率太大会导致学习曲线出现上升趋势
太小会导致迭代次数增加

可以先对不同量级的学习率进行测试，观察学习曲线变化快慢
然后进行N倍测试，再比较，通过多组测试观察学习曲线变化快慢进行选取

特征工程

通过转换或者合并直接(原始)的特征值，生成新的特征值进行模型训练

多项式回归

如果特征值只有一个的情况下，不希望得到线性回归的直线模型，希望用曲线去拟合训练集
可以采用下面两种方法去拟合

1. 通乘方构建新特征值，但是在进行训练时要进行归一化处理，因为乘方处理后，各个特质值范围的数量级会变得不同
2. 通过开方进行新特征值构建
   

如何在colab中运行github 上的jupiter文件

下面这个链接时梯度下降实现的.ipynb 文件

https://github.com/kaieye/2022-Machine-Learning-Specialization/blob/main/Supervised%20Machine%20Learning%20Regression%20and%20Classification/week1/work/C1_W1_Lab05_Gradient_Descent_Soln.ipynb

复制域名之后的path
kaieye/2022-Machine-Learning-Specialization/blob/main/
Supervised%20Machine%20Learning%20Regression%20and%20Classification/week1/work/C1_W1_Lab05_Gradient_Descent_Soln.ipynb
拼接到 https://colab.research.google.com/github/ 后面

得到访问链接

https://colab.research.google.com/github/kaieye/2022-Machine-Learning-Specialization/blob/main/Supervised%20Machine%20Learning%20Regression%20and%20Classification/week1/work/C1_W1_Lab05_Gradient_Descent_Soln.ipynb

如果.ipynb有依赖其他py 文件，可以点击上传图标直接上传

但是要注意这里上传的文件都是运行时的状态，页面关闭即销毁，
如果想要保存自己修改后的.ipynb文件可以通过添加副本到google/drive 来实现

什么是机器学习

filed of study that gives computers the ability to learn without being explicity programmed.

让计算机在没有明确编程的情况下学习的研究领域

– Arthur Samuel (1959)

Supervised Learning 监督学习

learns from being given ‘right answers’

learns from data labeled with ‘right answers’

regression algorithms 回归算法

从无限多可能数字中预测数字

predict a number 预测无限可能中的一种
infinitely many possible outputs

classify algorithms 分类算法

predict categories 预测有限分类中的一类
small number of possible outputs

Unsupervised Learning 无监督学习

find sth interesting in unlabeled data
data only comes with input x ,but not output labels y, algorithm has to find structure in the data

clustering algorithms 聚类算法

place the unlabeled data (automatically group) into different clusters

eg. google news, grouping customers

==> group similar data points together

Anomaly detection 异常检测

find unusal data points (events)

eg. 金融诈骗中的交易异常

Dimensionality reduction 降维算法

compressn data using fewer numbers

压缩大数据集到小数据集，同时丢失尽可能少的信息

Reinforcement Learning 强化学习

todo 下载 代码，看原理流程，运行耗token, 测试

跑测试
重新听

to do
整理书中知识点

LangSmith

1. 安装 LangSmith

   1	pip install --upgrade langsmith

2. 注册账号，并申请一个 LANGCHAIN_API_KEY

3. 在环境变量中设置以下值

   1 2 3

   export LANGCHAIN_TRACING_V2=true export LANGCHAIN_PROJECT=YOUR_PROJECT_NAME #自定义项目名称（可选） export LANGCHAIN_API_KEY=LANGCHAIN_API_KEY # LangChain API Key

4. 程序中的调用将自动被记录

   1 2 3 4

   import os from datetime import datetime os.environ["LANGCHAIN_TRACING_V2"] = "true" os.environ["LANGCHAIN_PROJECT"] = "hello-world-"+datetime.now().strftime("%d/%m/%Y %H:%M:%S")

基本功能

1. Traces
2. LLM Calls
3. Monitor
4. Playground

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

from langchain.prompts import (
    ChatPromptTemplate,
    HumanMessagePromptTemplate,
)
from langchain_core.output_parsers import StrOutputParser
from langchain_openai import ChatOpenAI
from langchain_core.runnables import RunnablePassthrough

model = ChatOpenAI(model="gpt-3.5-turbo")

prompt = ChatPromptTemplate.from_messages([
    HumanMessagePromptTemplate.from_template("Say hello to {input}!")
])

# 定义输出解析器
parser = StrOutputParser()

chain = (
    {"input": RunnablePassthrough()}
    | prompt
    | model
    | parser
)
chain.invoke("王卓然")

在线标注(在平台上进行标注)

上传已有数据集
定义评估函数
运行测试

基于 LLM 的评估函数

1

https://docs.smith.langchain.com/evaluation/faq/evaluator-implementations

维护一个生产级的 LLM 应用，我们需要做什么

1. 各种指标监控与统计：访问记录、响应时长、Token 用量、计费等等
2. 调试 Prompt
3. 测试/验证系统的相关评估指标
4. 数据集管理（便于回归测试）
5. Prompt 版本管理（便于升级/回滚）

针对以上需求，目前有两个生产级 LLM App 维护平台

1. LangFuse: 开源 + SaaS（免费/付费），LangSmith 平替，可集成 LangChain 也可直接对接 OpenAI API；
2. LangSmith: LangChain 的官方平台，SaaS 服务（免费/付费），非开源，企业版支持私有部署；

根据自己的技术栈，选择：

1. LangFuse：开源平台，支持 LangChain 和原生 OpenAI API
2. LangSmith: LangChain 的原始管理平台
3. Prompt Flow：开源平台，支持 Semantic Kernel

LangFuse

开源，支持 LangChain 集成或原生 OpenAI API 集成

官方网站：https://langfuse.com/

项目地址：https://github.com/langfuse

文档地址：https://langfuse.com/docs

API文档：https://api.reference.langfuse.com/

1. Python SDK:
   https://python.reference.langfuse.com/

2. JS SDK:
   https://js.reference.langfuse.com/

3. 通过官方云服务使用：

   1. 注册: cloud.langfuse.com
   2. 创建 API Key

1
2

LANGFUSE_SECRET_KEY="sk-lf-..."
LANGFUSE_PUBLIC_KEY="pk-lf-..."

2. 通过 Docker 本地部署

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

# Clone repository
git clone https://github.com/langfuse/langfuse.git
cd langfuse

# Run server and db
docker compose up -d

# 在自己部署的系统中生成上述两个 KEY
# 并在环境变量中指定服务地址

LANGFUSE_SECRET_KEY="sk-lf-..."
LANGFUSE_PUBLIC_KEY="pk-lf-.."
LANGFUSE_HOST="http://localhost:3000"

几个基本概念

1. Trace 一般表示用户与系统的一次交互，其中记录输入、输出，也包括自定义的 metadata 比如用户名、session id 等；
2. 一个 trace 内部可以包含多个子过程，这里叫 observarions；
3. Observation 可以是多个类型：
   1. Event 是最基本的单元，用于记录一个 trace 中的每个事件；
   2. Span 表一个 trace 中的一个”耗时”的过程；
   3. Generation 是用于记录与 AI 模型交互的 span，例如：调用 embedding 模型、调用 LLM。
4. Observation 可以嵌套使用。

通过装饰器记录（上报）

observe() 装饰器的参数

1
2
3
4
5
6
7
8
9

def observe(
    self,
    *,
    name: Optional[str] = None, # Trace 或 Span 的名称，默认为函数名
    as_type: Optional[Literal['generation']] = None, # 将记录定义为 Observation (LLM 调用）
    capture_input: bool = True, # 记录输入
    capture_output: bool = True, # 记录输出
    transform_to_string: Optional[Callable[[Iterable], str]] = None # 将输出转为 string
) -> Callable[[~F], ~F]

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

from langfuse.decorators import observe
from langfuse.openai import openai # OpenAI integration

@observe()
def run():
    return openai.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
          {"role": "user", "content": "对我说Hello, World!"}
        ],
    ).choices[0].message.content

print(run())

通过 langfuse_context 记录 User ID、Metadata 等

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

from langfuse.decorators import observe, langfuse_context
from langfuse.openai import openai # OpenAI integration

@observe()
def run():
    langfuse_context.update_current_trace(
        name="HelloWorld",
        user_id="wzr",
        metadata={"test":"test value"}
    )
    return openai.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[
          {"role": "user", "content": "对我说Hello, World!"}
        ],
    ).choices[0].message.content

print(run())

通过 LangChain 的回调集成

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

from langfuse.decorators import langfuse_context, observe

@observe()
def run():
    langfuse_context.update_current_trace(
            name="LangChainDemo",
            user_id="wzr",
        )
    
    # 获取当前 LangChain 回调处理器
    langfuse_handler = langfuse_context.get_current_langchain_handler()
    
    return chain.invoke(input="AGIClass", config={"callbacks": [langfuse_handler]})

print(run())

用 Trace 记录一个多次调用 LLM 的过程

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 uuid
from langfuse.decorators import langfuse_context, observe

# 主流程
@observe()
def verify_question(
    question: str,
    outlines: str,
    question_list: list,
    user_id: str,
) -> bool:
    langfuse_context.update_current_trace(
            name="AGIClassAssistant",
            user_id=user_id,
        )
    langfuse_handler = langfuse_context.get_current_langchain_handler()
    # 判断是否需要回答
    if need_answer_chain.invoke(
        {"user_input": question, "outlines": outlines},
        config={"callbacks": [langfuse_handler]}
    ) == 'Y':
        # 判断是否为重复问题
        if is_duplicated_chain.invoke(
            {"user_input": question,
                "question_list": "\n".join(question_list)},
            config={"callbacks": [langfuse_handler]}
        ) == 'N':
            question_list.append(question)
            return True
    return False

用 Session 记录一个用户的多轮对话

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

@observe()
def chat_one_turn(user_input, user_id, turn_id):
    langfuse_context.update_current_trace(
        name=f"ChatTurn{turn_id}",
        user_id=user_id,
        session_id="chat-"+now.strftime("%d/%m/%Y %H:%M:%S")
    )
    langfuse_handler = langfuse_context.get_current_langchain_handler()
    messages.append(HumanMessage(content=user_input))
    response = llm.invoke(messages, config={"callbacks": [langfuse_handler]})
    messages.append(response)
    return response.content

数据集与测试

在线标注(在平台上进行标注)

上传已有数据集

定义评估函数

运行测试

Prompt 调优与回归测试

Prompt 版本管理

目前只支持 Langfuse 自己的 SDK

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

# 按名称加载
prompt = langfuse.get_prompt("need_answer_v1")

# 按名称和版本号加载
prompt = langfuse.get_prompt("need_answer_v1", version=2)

# 对模板中的变量赋值
compiled_prompt = prompt.compile(input="老师好", outlines="test")

print(compiled_prompt)

# 获取 config

prompt = langfuse.get_prompt("need_answer_v1", version=5)

print(prompt.config)

如何比较两个句子的相似性：一些经典 NLP 的评测方法（选）

用途：比较llm 返回值和预期值，从而进行打分计算

1. 编辑距离：也叫莱文斯坦距离(Levenshtein),是针对二个字符串的差异程度的量化量测，量测方式是看至少需要多少次的处理才能将一个字符串变成另一个字符串。
   1. 具体计算过程是一个动态规划算法：https://zhuanlan.zhihu.com/p/164599274
   2. 衡量两个句子的相似度时，可以以词为单位计算
2. BLEU Score:
   1. 计算输出与参照句之间的 n-gram 准确率（n=1…4）
   2. 对短输出做惩罚
   3. 在整个测试集上平均下述值
   4. 函数库：https://www.nltk.org/_modules/nltk/translate/bleu_score.html
3. Rouge Score:
   1. Rouge-N：将模型生成的结果和标准结果按 N-gram 拆分后，只计算召回率；
   2. Rouge-L: 利用了最长公共子序列（Longest Common Sequence）
   3. 函数库：https://pypi.org/project/rouge-score/
   4. 对比 BLEU 与 ROUGE：
      1. BLEU 能评估流畅度，但指标偏向于较短的翻译结果（brevity penalty 没有想象中那么强）
      2. ROUGE 不管流畅度，所以只适合深度学习的生成模型：结果都是流畅的前提下，ROUGE 反应参照句中多少内容被生成的句子包含（召回）
4. METEOR: 另一个从机器翻译领域借鉴的指标。与 BLEU 相比，METEOR 考虑了更多的因素，如同义词匹配、词干匹配、词序等，因此它通常被认为是一个更全面的评价指标。
   1. 对语言学和语义词表有依赖，所以对语言依赖强。

此类方法常用于对文本生成模型的自动化评估。实际使用中，我们通常更关注相对变化而不是绝对值（调优过程中指标是不是在变好）。

基于 LLM 的测试方法

LangFuse 集成了一些原生的基于 LLM 的自动测试标准。

具体参考：https://langfuse.com/docs/scores/model-based-evals

划重点：此类方法，对于用于评估的 LLM 自身能力有要求。需根据具体情况选择使用。