机器学习(三)逻辑回归以及python简单实现

电玩女神 2022-11-19 07:46 192阅读 0赞

虽然有`回归`两个字，但是依然是解决的时分类问题，是最经典的二分类算法。  
分类算法有很多，例如支持向量机和神经网络。而逻辑回归算法应用的比较广，往往是优先选择的算法。

# Sigmod函数 #

表达式：  
 g ( z ) = 1 1 + e − z g(z)=\\frac\{1\}\{1+e^\{-z\}\} g(z)=1\+e−z1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70]  
自变量取值为任意实数，值域`[0,1]`  
在线性回归中的结果预测出一个值，将这个值放到这个sigmod中，得到一个输出结果，而这个结果可以表示为概率值。

假设预测函数：  h θ ( x ) = g ( θ T x ) = 1 1 + e − θ T x h\_\\theta(x)=g(\\theta^Tx)=\\frac\{1\}\{1+e^\{-\\theta^Tx\}\} hθ(x)=g(θTx)=1\+e−θTx1，  
其中  θ 0 + θ 1 x + θ 2 x + , . . . , θ n x = ∑ i = 1 n θ i x i = θ T x \\theta\_0+\\theta\_1x+\\theta\_2x+,...,\\theta\_nx=\\sum\_\{i=1\}^n\{\\theta\_ix\_i\}=\\theta^Tx θ0\+θ1x\+θ2x\+,...,θnx=∑i=1nθixi=θTx

假设这是一个二分类任务：  
 \{ P ( y = 1 ∣ x ; θ ) = h θ ( x ) P ( y = 0 ∣ x ; θ ) = 1 − h θ ( x ) \\begin\{cases\} P(y=1|x;\\theta)=h\_\\theta(x) \\\\ P(y=0|x;\\theta)=1-h\_\\theta(x) \\end\{cases\} \{ P(y=1∣x;θ)=hθ(x)P(y=0∣x;θ)=1−hθ(x)  
可以将上面的公式进行整合：  
 P ( y ∣ x ; θ ) = ( h θ ( x ) ) y ( 1 − h θ ( x ) ) 1 − y P(y|x;\\theta)=(h\_\\theta(x))^y(1-h\_\\theta(x))^\{1-y\} P(y∣x;θ)=(hθ(x))y(1−hθ(x))1−y  
上面的公式对于二分类任务(0,1)，整合后y取0只保留 ( 1 − h θ ( x ) ) 1 − y (1-h\_\\theta(x))^\{1-y\} (1−hθ(x))1−y，y取1只保留 ( h θ ( x ) ) y (h\_\\theta(x))^y (hθ(x))y

# 逻辑回归似然函数 #

L ( θ ) = ∏ i = 1 m P ( y i ∣ x i ; θ ) = ∏ i = 1 m ( h θ ( x i ) y i ( 1 − h θ ( x i ) ) 1 − y i ) L(\\theta)=\\prod\_\{i=1\}^mP(y\_i|x\_i;\\theta)=\\prod\_\{i=1\}^m(h\_\\theta(x\_i)^\{y\_i\}(1-h\_\\theta(x\_i))^\{1-y\_i\}) L(θ)=i=1∏mP(yi∣xi;θ)=i=1∏m(hθ(xi)yi(1−hθ(xi))1−yi)  
对数似然函数为：  
 l ( θ ) = l o g L ( θ ) = ∑ i = 1 m ( y i l o g h θ ( x i ) + ( 1 − y ) l o g ( 1 − h θ ( x i ) ) ) l(\\theta)=logL(\\theta)=\\sum\_\{i=1\}^m(y\_ilogh\_\\theta(xi)+(1-y)log(1-h\_\\theta(xi))) l(θ)=logL(θ)=i=1∑m(yiloghθ(xi)\+(1−y)log(1−hθ(xi)))  
而似然函数是要求一个最大值，此时应用梯度上升求最大值，但是一般通过引入 J ( θ ) = − 1 m l ( θ ) J(\\theta)=-\\frac\{1\}\{m\}l(\\theta) J(θ)=−m1l(θ)转换为梯度下降任务。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 1]  
其中 θ j \\theta\_j θj表示第 j j j个特征。最终结果为 1 m ∑ i = 1 m ( h θ ( x i ) − y i ) x i j \\frac\{1\}\{m\}\\sum\_\{i=1\}^m(h\_\\theta(x\_i)-y\_i)x\_i^j m1∑i=1m(hθ(xi)−yi)xij  
其中 x i j x\_i^j xij表示第 i i i个样本第 j j j个特征。

# 更新参数 θ j \\theta\_j θj #

θ j : = θ j − α 1 m ∑ i = 1 m ( h θ ( x i ) − y i ) x i j \\theta\_j :=\\theta\_j -\\alpha\\frac\{1\}\{m\}\\sum\_\{i=1\}^m(h\_\\theta(x\_i)-y\_i)x\_i^j θj:=θj−αm1i=1∑m(hθ(xi)−yi)xij  
其中 α \\alpha α表示步长， ∑ i = 1 m ( h θ ( x i ) − y i ) x i j \\sum\_\{i=1\}^m(h\_\\theta(x\_i)-y\_i)x\_i^j ∑i=1m(hθ(xi)−yi)xij表示方向， 1 m \\frac\{1\}\{m\} m1表示综合考虑每一个样本。

# 多分类softmax #

上面都是基于二分类的逻辑回归，而对于一个多分类问题，往往使用softmax算法，公式如下：  
 h θ ( x ( i ) ) = \[ p ( y ( i ) = 1 ∣ x ( i ) ; θ ) p ( y ( i ) = 2 ∣ x ( i ) ; θ ) ⋮ p ( y ( i ) = k ∣ x ( i ) ; θ ) \] = 1 ∑ j = 1 k e θ j T x ( i ) \[ e θ 1 T x ( i ) e θ 2 T x ( i ) ⋮ e θ k T x ( i ) \] h\_\\theta(x^\{(i)\})=\\begin\{bmatrix\} p(y^\{(i)\}=1|x^\{(i)\};\\theta) \\\\ p(y^\{(i)\}=2|x^\{(i)\};\\theta) \\\\ \\vdots \\\\ p(y^\{(i)\}=k|x^\{(i)\};\\theta) \\end\{bmatrix\}=\\frac\{1\}\{\\sum\_\{j=1\}^ke^\{\\theta^T\_jx^\{(i)\}\}\}\\begin\{bmatrix\} e^\{\\theta^T\_1x^\{(i)\}\} \\\\ e^\{\\theta^T\_2x^\{(i)\}\} \\\\ \\vdots \\\\ e^\{\\theta^T\_kx^\{(i)\}\} \\end\{bmatrix\} hθ(x(i))=⎣⎢⎢⎢⎡p(y(i)=1∣x(i);θ)p(y(i)=2∣x(i);θ)⋮p(y(i)=k∣x(i);θ)⎦⎥⎥⎥⎤=∑j=1keθjTx(i)1⎣⎢⎢⎢⎢⎡eθ1Tx(i)eθ2Tx(i)⋮eθkTx(i)⎦⎥⎥⎥⎥⎤

# python实现最简单的逻辑回归 #

我们将建立一个逻辑回归模型来预测一个学生是否被大学录取。假设你是一个大学系的管理员，你想根据两次考试的结果来决定每个申请人的录取机会。你有以前的申请人的历史数据，你可以用它作为逻辑回归的训练集。对于每一个培训例子，你有两个考试的申请人的分数和录取决定。为了做到这一点，我们将建立一个分类模型，根据考试成绩估计入学概率。

## 数据 ##

34.62365962451697,78.0246928153624,0
    30.28671076822607,43.89499752400101,0
    35.84740876993872,72.90219802708364,0
    60.18259938620976,86.30855209546826,1
    79.0327360507101,75.3443764369103,1
    45.08327747668339,56.3163717815305,0
    61.10666453684766,96.51142588489624,1
    75.02474556738889,46.55401354116538,1
    76.09878670226257,87.42056971926803,1
    84.43281996120035,43.53339331072109,1

## 1.1 引入库 ##

import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    %matplotlib inline

查看数据情况：

positive=pdData[pdData['Admitted']==1]
    negative=pdData[pdData['Admitted']==0]
    
    fig,ax=plt.subplots(figsize=(10,5))
    ax.scatter(positive['Exam 1'], positive['Exam 2'], s=30, c='b', marker='o',label='Admitted')
    ax.scatter(negative['Exam 1'], negative['Exam 2'], s=30, c='r', marker='x',label='Not Admitted')
    ax.legend()
    ax.set_xlabel('Exam 1 score')
    ax.set_ylabel('Exam 2 score')

输出结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 2]

# 2要完成的模块 #

*  sigmod：映射到概率的函数
 *  model：返回预测结果值
 *  cost：计算参数损失
 *  gradient：计算每个参数的梯度方向
 *  descent：进行参数更新
 *  accuracy：计算精度

## 2.1目标 ##

建立分类器，求解出三个参数 θ 0 , θ 1 , θ 2 \\theta\_0,\\theta\_1,\\theta\_2 θ0,θ1,θ2，其中 θ 1 \\theta\_1 θ1对应第一个考试成绩， θ 2 \\theta\_2 θ2对应第二个考试成绩， θ 0 \\theta\_0 θ0对应偏置项。  
设置阈值，根据阈值判断录取结果。

## 2.2 sigmod函数 ##

def sigmod(z):
        return 1/(1+np.exp(-1))

举例展示：

nums = np.arange(-10, 10, step=1)
    fig,ax=plt.subplots(figsize=(12, 4))
    ax.plot(nums,sigmod(nums),'r')

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 3]

## 2.3 model ##

def model(X, theta):
        return sigmod(np.dot(X, theta.T)) # 进行矩阵乘法

( θ 0 , θ 1 , θ 2 ) × \[ 1 x 1 x 2 \] = θ 0 + θ 1 x 1 + θ 2 x 2 (\\theta\_0, \\theta\_1, \\theta\_2) \\times \\begin\{bmatrix\} 1 \\\\ x\_1 \\\\ x\_2 \\end\{bmatrix\}=\\theta\_0 + \\theta\_1x\_1 + \\theta\_2x\_2 (θ0,θ1,θ2)×⎣⎡1x1x2⎦⎤=θ0\+θ1x1\+θ2x2  
构造初始化数据：

pdData.insert(0, 'Ones', 1) # 添加列,列名Ones，数据全为1
    orig_data = pdData.values # 将DataFrame转为矩阵
    
    cols = orig_data.shape[1] #获取列数量 4
    X = orig_data[:,0:cols-1] # 获取第一列、第二列、第三列数据
    y = orig_data[:,cols-1:cols] #获取第四列数据
    theta = np.zeros([1,3]) # 创建1行3列的零矩阵

查看数据X：  
![在这里插入图片描述][20210128114321923.png]  
查看标签y：  
![在这里插入图片描述][20210128141206432.png]

查看参数 θ \\theta θ:  
![在这里插入图片描述][20210128114400585.png]  
查看shape：  
![在这里插入图片描述][2021012811444191.png]

## 2.4 损失函数 ##

将上面所讲的对数似然函数取负号，因为要转为梯度下降：  
 D ( h θ ( x ) , y ) = − y l o g ( h θ ( x ) ) − ( 1 − y ) l o g ( 1 − h θ ( x ) ) D(h\_\\theta(x),y) = -ylog(h\_\\theta(x))-(1-y)log(1-h\_\\theta(x)) D(hθ(x),y)=−ylog(hθ(x))−(1−y)log(1−hθ(x))  
求平均损失：  
 J ( θ ) = 1 n ∑ i = 1 n D ( h θ ( x i ) , y i ) J(\\theta) = \\frac\{1\}\{n\}\\sum\_\{i=1\}^nD(h\_\\theta(x\_i),y\_i) J(θ)=n1i=1∑nD(hθ(xi),yi)

def cost(X,y,theta):
        left=np.multiply(-y, np.log(model(X,theta)))
        right=np.multiply(1-y,np.log(1-model(X,theta)))
        return np.sum(left - right)/(len(X))

运行损失函数：

cost(X,y,theta)

结果如下：

0.6931471805599453

## 2.5 计算梯度 ##

根据上面得出的偏导公式：  
 ∂ J ∂ θ j = 1 m ∑ i = 1 n ( h θ ( x i ) − y i ) x i j \\frac \{\\partial J\}\{\\partial \\theta\_j\}=\\frac\{1\}\{m\}\\sum\_\{i=1\}^n(h\_\\theta(x\_i)-y\_i)x\_i^j ∂θj∂J=m1i=1∑n(hθ(xi)−yi)xij  
m表示样本个数，n表示参数 θ \\theta θ个数

def gradient(X,y,theta):
        grad = np.zeros(theta.shape) # 当前有三个参数，因此有三个梯度，梯度与theta一一对应
        error = (model(X,theta) - y).ravel() # 将负号提到里面
        for j in range(len(theta.ravel())): # 3个参数，求三次偏导
            term = np.multiply(error, X[:,j])
            grad[0,j] = np.sum(term)/len(X)
        return grad

这样就获取到三个特征的梯度。

# 3 批量梯度下降GD、随机梯度下降SGD、小批量梯度下降的各自表现 #

STOP_ITER=0 # 迭代次数，按照迭代次数停止，
    STOP_COST=1 # 损失变化，可以看迭代前的目标函数，和迭代后的目标函数，如果这两次迭代生成的目标函数差异非常小，就可以停止
    STOP_GRAD=2 # 梯度变化，梯度如果变化很小，那么可以停止
    
    def stopCriterion(type, value, threshold):
        # 设定三种不同的停止策略
        if type == STOP_ITER: return value > threshold
        elif type == STOP_COST: return abs(value[-1]-value[-2]) < threshold
        elif type == STOP_GRAD: return np.linalg.norm(value) < threshold

## 3.1 数据洗牌 ##

防止数据有一定的规律，让模型的泛化能力能强，对数据进行洗牌，

import numpy.random
    
    #洗牌
    def shuffleData(data):
        np.random.shuffle(data)
        cols = data.shape[1]
        X = data[:, 0:cols-1]
        y = data[:, cols-1:]
        return X,y

## 3.2 梯度下降 ##

import time
    
    def descent(data, theta, batchSize, stopType, thresh, alpha):
        # data:数据
        # theta: 参数
        # batchSize=1 表示随机梯度下降，batchSize=总样本数 表示梯度下降，batchSize=（1到总体之间）表示小批量梯度下降
        # stopType表示停止策略
        # thresh表示停止策略对应的阈值
        # alpha表示学习率
        
        # 初始化
        init_time = time.time()
        i = 0 # 迭代次数
        k = 0 # batch
        X, y = shuffleData(data)
        grad = np.zeros(theta.shape) # 梯度
        costs = [cost(X, y, theta)] # 损失值
        
        while True:
            grad = gradient(X[k:k+batchSize], y[k:k+batchSize], theta)
            k += batchSize # 取batch数量个数据
            if k >= n:
                k = 0
                X, y = shuffleData(data) # 重新洗牌
            theta = theta-alpha*grad #更新参数
            costs.append(cost(X, y, theta)) # 重新计算新的损失
            i += 1
            
            if stopType == STOP_ITER: value = i
            elif stopType == STOP_COST: value = costs
            elif stopType == STOP_GRAD: value = grad
            if stopCriterion(stopType, value, thresh): break
        
        return theta, i-1, costs, grad, time.time() - init_time

## 3.3 执行梯度下降函数 ##

def runExpe(data, theta, batchSize, stopType, thresh, alpha):
        #import pdb; pdb.set_trace();
        theta, iter, costs, grad, dur = descent(data, theta, batchSize, stopType, thresh, alpha)
        name = "Original" if (data[:,1]>2).sum() > 1 else "Scaled"
        name += " data - learning rate: {} - ".format(alpha)
        if batchSize==n: strDescType = "Gradient"
        elif batchSize==1:  strDescType = "Stochastic"
        else: strDescType = "Mini-batch ({})".format(batchSize)
        name += strDescType + " descent - Stop: "
        if stopType == STOP_ITER: strStop = "{} iterations".format(thresh)
        elif stopType == STOP_COST: strStop = "costs change < {}".format(thresh)
        else: strStop = "gradient norm < {}".format(thresh)
        name += strStop
        print ("***{}\nTheta: {} - Iter: {} - Last cost: {:03.2f} - Duration: {:03.2f}s".format(name, theta, iter, costs[-1], dur))
        fig, ax = plt.subplots(figsize=(12,4))
        ax.plot(np.arange(len(costs)), costs, 'r')
        ax.set_xlabel('Iterations')
        ax.set_ylabel('Cost')
        ax.set_title(name.upper() + ' - Error vs. Iteration')
        return theta

### 3.3.1 批量梯度下降GD ###

#### 3.3.1.1 根据迭代次数进行停止 ####

runExpe(orig_data, theta, 100, STOP_ITER, thresh=5000, alpha = 0.000001)

按照迭代次数进行停止，迭代5000次，学习率是 0.000001  
运行结果：

***Original data - learning rate: 1e-06 - Gradient descent - Stop: 5000 iterations
    Theta: [[-0.00027127  0.00705232  0.00376711]] - Iter: 5000 - Last cost: 0.63 - Duration: 0.77s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 4]  
其中x轴是迭代次数，y轴是损失值，随着迭代次数的增加，目标函数逐渐收敛。  
当前的时间消耗0.77s。

#### 3.3.1.2 根据损失函数变化进行停止 ####

runExpe(orig_data, theta, 100, STOP_COST, thresh=0.000001, alpha = 0.001)

设置阈值1E-6，差不多需要迭代110000次。  
输出结果如下：

***Original data - learning rate: 0.001 - Gradient descent - Stop: costs change < 1e-06
    Theta: [[-5.13364014  0.04771429  0.04072397]] - Iter: 109901 - Last cost: 0.38 - Duration: 17.36s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 5]  
可以看出时间花了17.36s

#### 3.3.1.3 根据梯度值进行停止 ####

runExpe(orig_data, theta, 100, STOP_GRAD, thresh=0.05, alpha = 0.001)

输出结果如下：

***Original data - learning rate: 0.001 - Gradient descent - Stop: gradient norm < 0.05
    Theta: [[-2.37033409  0.02721692  0.01899456]] - Iter: 40045 - Last cost: 0.49 - Duration: 6.67s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 6]

> 根据第一张图，看似迭代5000次就已经到达瓶颈了，其实如果迭代11万次依然可以达到一个很高的准确率，所以不要被一张图蒙蔽了。

### 3.3.2 随机梯度下降SGD ###

每次只迭代一个样本

#### 3.3.2.1 根据迭代次数进行停止 ####

runExpe(orig_data, theta, 1, STOP_ITER, thresh=5000, alpha = 0.001)

这里的学习率是`0.001`，根本不能收敛  
输出结果如下：

***Original data - learning rate: 0.001 - Stochastic descent - Stop: 5000 iterations
    Theta: [[-0.38304524  0.02692472  0.07197214]] - Iter: 5000 - Last cost: 1.98 - Duration: 0.27s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 7]  
而当我们的学习率改为0.000001后，输出结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 8]

### 3.3.3 小批量梯度下降 ###

每次只迭代一批样本

runExpe(orig_data, theta, 16, STOP_ITER, thresh=5000, alpha = 0.001)

输出结果如下：

***Original data - learning rate: 0.001 - Mini-batch (16) descent - Stop: 5000 iterations
    Theta: [[-0.35752768  0.01835205  0.0004876 ]] - Iter: 5000 - Last cost: 0.61 - Duration: 0.35s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 9]  
与上面的图像相似，同样可以通过修改学习率进行改善：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 10]  
除了将学习率调小之外，还有其他方式来改善。  
可以通过对数据进行标准化，将数据按其属性（按列进行）减去其均值，然后除以其方差。最后得到的结果是，对每个属性/每列来说所有数据都聚集在0附近，方差值为1。实现方式如下：

from sklearn import preprocessing as pp
    
    scaled_data = orig_data.copy()
    scaled_data[:, 1:3] = pp.scale(orig_data[:, 1:3])
    runExpe(scaled_data, theta, n, STOP_ITER, thresh=5000, alpha = 0.001)

输出结果如下：

***Scaled data - learning rate: 0.001 - Gradient descent - Stop: 5000 iterations
    Theta: [[0.3080807  0.86494967 0.77367651]] - Iter: 5000 - Last cost: 0.38 - Duration: 0.86s

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 11]  
昨晚sklearning之后，变得收敛了。

# 4. 精度 #

def predict(X, theta):
        return [1 if x >= 0.5 else 0 for x in model(X, theta)]
        
    scaled_X = scaled_data[:, :3]
    y = scaled_data[:, 3]
    predictions = predict(scaled_X, theta)
    correct = [1 if ((a==1 and b==1) or (a==0 and b==0)) else 0 for (a,b) in zip(predictions, y)]
    accuracy = (sum(map(int, correct)) % len(correct))
    print('accuracy = {0}%'.format(accuracy))

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70]: /images/20221119/fd1502f627684200a1ea8126986b3ef6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 1]: /images/20221119/693ca019478f46f6a3d2ad8ee8ad21e7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 2]: /images/20221119/23bec78d98a44f76976a1a2ac2fc4671.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 3]: /images/20221119/c9db0f4e27ef41d5874e19d8c4b8d36a.png
[20210128114321923.png]: /images/20221119/e6d48d7a3f2b48d4912c0ef63e681c78.png
[20210128141206432.png]: /images/20221119/aec650c8af764a4bb917d3245846c712.png
[20210128114400585.png]: /images/20221119/0d3317fce3e9447eb8089c5f40fac4da.png
[2021012811444191.png]: /images/20221119/2e967439b41f4057b2c370afc8409677.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 4]: /images/20221119/5d374a58794c473caf3a8a91f4b775f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 5]: /images/20221119/16351ee607dc4b9d991fef8f71659268.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 6]: /images/20221119/295bfa5abbd34863ae80365cdeb7ba92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 7]: /images/20221119/e384da668a2148ba9a08d3c9033dd852.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 8]: /images/20221119/5a4f2c5693914bd890d3d21ad70aa594.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 9]: /images/20221119/80f6f7f18bdc4805b17ef52bd85f7c44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 10]: /images/20221119/893452e9d9724c86a5f8eb95b313ed87.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZpbmNlbnRfZHVhbg_size_16_color_FFFFFF_t_70 11]: /images/20221119/496e82788f414958927176c42e6e86cf.png