机器学习——分类问题(2020最新版)

谁借莪１个温暖的怀抱￠ 2023-03-03 11:19 1阅读 0赞

直接使用梯度下降法去做逻辑回归，相当于完成底层实现。

直接调用sklearn的话，简单很多，具体实现无法学习到。

### 一、逻辑回归(Logistic Regression) ###

逻辑回归是用来处理分类问题的

![20200731102926349.png][]

Sigmoid/Logistic Function:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 1][]

**1、决策边界**

case 1:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 2][]

case 2:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 3][]

case 3:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 4][]

**2、逻辑回归的代价函数**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 5][]

(1) 所以对于non-convex func来说，梯度下降法的代价函数并不适合这种问题求解，需要新的代价函数。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 6][]

(2) 由上图可知，预测正确，cost的值越小(为0)，预测错误，cost的值越大(为无穷大)。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 7][]

(3) 这个就是逻辑回归的代价函数的公式，在后面深度学习里面使用的交叉熵，也是这个公式。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 8][]

使用梯度下降法，下面是求导过程：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 9][]

所以得到@j的每次更替的值用如下式子进行赋值：

![2020073110352680.png][]

**3、多分类问题如何解决**

逻辑回归一般是用来做这种二分类的问题的，那么对于多分类的情况，如何做？

可以做三个分类边界，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 10][]

**4、逻辑回归的正则化**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 11][]

——————————————————————————————————————————

在上面的介绍如何使用逻辑回归进行分类后，下面讲述如何去评价分类后的结果（评价指标）

——————————————————————————————————————————

**5、正确率(precision)/召回率(recall)/F1指标**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 12][]

举个例子，去理解正确率、召回率、F1-score：

![20200731103744821.png][]

![20200731103800870.png][]

![20200731103830320.png][]

因此，综合考虑precision和recall才是可行的，所以使用**F1-Score**来评价：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 13][]

**使用最基本的梯度下降法来实现线性逻辑回归：**

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    sks_logistic_regression_method
      Author:      newlinfeng
      Date:        2020/7/28 0028  11:47
      Description: 使用sklearn实现分类问题中的逻辑回归
    -------------------------------------------------------------------------------
    """
    import matplotlib.pyplot as plt
    import numpy as np
    from sklearn.metrics import classification_report
    from sklearn import preprocessing
    
    # 数据是否需要标准化
    scale = False
    
    # 载入数据
    data = np.genfromtxt(r"LR-testSet.csv", delimiter=",")
    x_data = data[:, :-1]
    y_data = data[:, -1]
    
    #为了画这个散点图
    def plot():
        x0 = []
        x1 = []
        y0 = []
        y1 = []
        #切分不同类型的数据
        for i in range(len(x_data)):
            if y_data[i] == 0:
                x0.append(x_data[i, 0])
                y0.append(x_data[i, 1])
            else:
                x1.append(x_data[i, 0])
                y1.append(x_data[i, 1])
        #画图
        scatter0 = plt.scatter(x0, y0, c='b', marker='o')
        scatter1 = plt.scatter(x1, y1, c='r', marker='x')
        #画图例
        plt.legend(handles=[scatter0, scatter1], labels=['label0', 'label1'], loc='best')
    
    
    
    #数据处理,添加偏执项
    x_data = data[:, :-1]
    y_data = data[:, -1, np.newaxis]
    
    #给样本添加偏执项
    X_data = np.concatenate((np.ones((100, 1)), x_data), axis=1)
    
    #逻辑回归的函数
    def sigmoid(x):
        return 1.0/(1+np.exp(-x))
    
    #逻辑回归的代价函数
    def cost(xMat, yMat, ws):
        left = np.multiply(yMat, np.log(sigmoid(xMat*ws))) #multiply()是对于矩阵元素的位置进行相乘(矩阵的形状必须一模一样)
        right = np.multiply(1-yMat, np.log(1-sigmoid(xMat*ws)))
        return np.sum(left + right)/-(len(xMat))
    
    #
    def gradAscent(xArr, yArr):
        if scale == True:
            xArr = preprocessing.scale(xArr)
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
    
        lr = 0.001 #学习率
        epochs = 10000 #迭代周期
        costList = [] #保存cost的值
        #计算数据行列数
        #行代表数据个数，列代表权值个数
        m, n = np.shape(xMat)
        #初始化权值矩阵
        ws = np.mat(np.ones((n, 1)))
    
        for i in range(epochs+1):
            #xMat和weights矩阵相乘
            h = sigmoid(xMat*ws)
            #计算误差
            ws_grad = xMat.T*(h-yMat)/m
            ws = ws - lr*ws_grad
    
            if i%50 == 0:
                costList.append(cost(xMat, yMat, ws))
        return ws,costList
    
    #训练模型，得到权重和cost值的变化
    ws, costList = gradAscent(X_data, y_data)
    print(ws)
    
    #是否做参数标准化
    if scale == False:
        #画图决策边界
        plot()
        #画那条线
        x_test = [[-4], [3]]
        y_test = (-ws[0] - x_test*ws[1])/ws[2]
        plt.plot(x_test, y_test, 'k')
        plt.show()
    
    #画下loss值的变化
    x = np.linspace(0, 10000, 201)
    plt.plot(x, costList, c='r')
    plt.title("Train")
    plt.xlabel("Epochs")
    plt.ylabel("Cost")
    plt.show()
    
    #预测
    def predict(x_data, ws):
        if scale == True:
            x_data = preprocessing.scale(x_data)
        xMat = np.mat(x_data)
        ws = np.mat(ws)
        return [1 if x>=0.5 else 0 for x in sigmoid(xMat*ws)]
    
    predictions = predict(X_data, ws)
    print(classification_report(y_data, predictions))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 14][]

相应的评价指标值为：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 15][]

**使用sklearn来实现线性逻辑回归：**

结果比上面好一些：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 16][]

![20200731104129748.png][]

**6、非线性逻辑回归**

**使用梯度下降法实现非线性逻辑回归：**

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    gradAscent_logistic_regression
      Author:      newlinfeng
      Date:        2020/7/28 0028  17:07
      Description: 
    -------------------------------------------------------------------------------
    """
    import matplotlib.pyplot as plt
    import numpy as np
    from sklearn.metrics import classification_report
    from sklearn import preprocessing
    from sklearn.preprocessing import PolynomialFeatures
    # 数据是否需要标准化
    scale = False
    
    # 载入数据
    data = np.genfromtxt(r"LR-testSet2.txt", delimiter=",")
    x_data = data[:, :-1]
    y_data = data[:, -1, np.newaxis]
    
    #为了画这个散点图
    def plot():
        x0 = []
        x1 = []
        y0 = []
        y1 = []
        #切分不同类型的数据
        for i in range(len(x_data)):
            if y_data[i] == 0:
                x0.append(x_data[i, 0])
                y0.append(x_data[i, 1])
            else:
                x1.append(x_data[i, 0])
                y1.append(x_data[i, 1])
        #画图
        scatter0 = plt.scatter(x0, y0, c='b', marker='o')
        scatter1 = plt.scatter(x1, y1, c='r', marker='x')
        #画图例
        plt.legend(handles=[scatter0, scatter1], labels=['label0', 'label1'], loc='best')
    
    plot()
    plt.show()
    
    #定义多项式回归，degree的值可以调节多项式的特征
    poly_reg = PolynomialFeatures(degree=3)
    #特征处理
    x_poly = poly_reg.fit_transform(x_data)
    
    #逻辑回归的函数
    def sigmoid(x):
        return 1.0/(1+np.exp(-x))
    
    #逻辑回归的代价函数
    def cost(xMat, yMat, ws):
        left = np.multiply(yMat, np.log(sigmoid(xMat*ws))) #multiply()是对于矩阵元素的位置进行相乘(矩阵的形状必须一模一样)
        right = np.multiply(1-yMat, np.log(1-sigmoid(xMat*ws)))
        return np.sum(left + right)/-(len(xMat))
    
    def gradAscent(xArr, yArr):
        if scale == True:
            xArr = preprocessing.scale(xArr)
        xMat = np.mat(xArr)
        yMat = np.mat(yArr)
    
        lr = 0.03 #学习率
        epochs = 50000 #迭代周期
        costList = [] #保存cost的值
        #计算数据行列数
        #行代表数据个数，列代表权值个数
        m, n = np.shape(xMat)
        #初始化权值矩阵
        ws = np.mat(np.ones((n, 1)))
    
        for i in range(epochs+1):
            #xMat和weights矩阵相乘
            h = sigmoid(xMat*ws)
            #计算误差
            ws_grad = xMat.T*(h-yMat)/m
            ws = ws - lr*ws_grad
    
            if i%50 == 0:
                costList.append(cost(xMat, yMat, ws))
        return ws,costList
    
    #训练模型，得到权重和cost值的变化
    ws, costList = gradAscent(x_poly, y_data)
    print(ws)
    
    #获取数据值所在的范围
    x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    
    #生成网格矩阵
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02))
    
    #ravel与flatten类似，多为数组转一维，flatten不会改变原始数据，ravel会改变
    z = sigmoid(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]).dot(np.array(ws)))
    for i in range(len(z)):
        if z[i] > 0.5:
            z[i] = 1
        else:
            z[i] = 0
    z = z.reshape(xx.shape)
    
    #等高线图
    cs = plt.contourf(xx, yy, z)
    plot()
    plt.show()
    
    #预测
    def predict(x_data, ws):
        xMat = np.mat(x_data)
        ws = np.mat(ws)
        return [1 if x >= 0.5 else 0 for x in sigmoid(xMat*ws)]
    
    predictions = predict(x_poly, ws)
    print(classification_report(y_data, predictions))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 17][]

![20200731104231690.png][]

**使用sklearn实现非线性逻辑回归：**

# -*- coding: utf-8 -*- #
    """
    -------------------------------------------------------------------------------
      FileName:    skl_logistic_regression_method
      Author:      newlinfeng
      Date:        2020/7/28 0028  17:45
      Description: 使用sklearn实现非线性逻辑回归
    -------------------------------------------------------------------------------
    """
    import numpy as np
    import matplotlib.pyplot as plt
    from sklearn import linear_model
    from sklearn.datasets import make_gaussian_quantiles
    from sklearn.preprocessing import PolynomialFeatures
    
    #生成一个二维正态分布，生成的数据按照分位数分成两类，500个样本，2个样本特征
    #可以生成两类或多类数据
    x_data, y_data = make_gaussian_quantiles(n_samples=500, n_features=2, n_classes=2)
    
    plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    plt.show()
    
    logistic = linear_model.LogisticRegression()
    logistic.fit(x_data, y_data)
    
    #获取数据值所在的范围
    x_min, x_max = x_data[:, 0].min() - 1, x_data[:, 0].max() + 1
    y_min, y_max = x_data[:, 1].min() - 1, x_data[:, 1].max() + 1
    
    #生成网格矩阵
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02))
    
    #ravel与flatten类似，多维数据转一维。flatten不会改变原始数据，ravel会改变原始数据
    z = logistic.predict(np.c_[xx.ravel(), yy.ravel()])
    z = z.reshape(xx.shape)
    #等高线图
    cs = plt.contourf(xx, yy, z)
    #样本散点图
    plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    plt.show()
    
    print('score:', logistic.score(x_data, y_data))
    
    #定义多项式回归，degree的值可以调节多项式的特征
    poly_reg = PolynomialFeatures(degree=5)
    #特征处理
    x_poly = poly_reg.fit_transform(x_data)
    #定义逻辑回归模型
    logistic = linear_model.LogisticRegression()
    #训练模型
    logistic.fit(x_poly, y_data)
    
    #获取数据值所在的范围
    x_min, x_max = x_data[:, 0].min()-1, x_data[:, 0].max()+1
    y_min, y_max = x_data[:, 1].min()-1, x_data[:, 1].max()+1
    
    #生成网格矩阵
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02))
    
    #ravel和flatten类似,多维数据转一维。flatten不会改变原始数据,ravel会改变原始数据
    z = logistic.predict(poly_reg.fit_transform(np.c_[xx.ravel(), yy.ravel()]))
    z = z.reshape(xx.shape)
    #等高线图
    cs = plt.contourf(xx, yy, z)
    #样本散点图
    plt.scatter(x_data[:, 0], x_data[:, 1], c=y_data)
    plt.show()
    
    print('score:', logistic.score(x_poly, y_data))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 18][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 19][]

![20200731104330462.png][]

**2020-07-31更新**

[20200731102926349.png]: /images/20230208/8555a7648ce1451d9d1cb0696c984d3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70]: /images/20230208/6a42659a9c5c4960a469ecb92c55e4ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 1]: /images/20230208/5054737e15a44f1ab533689ba68ccd20.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 2]: /images/20230208/3c90b60a2a00498f81d0ceae4f8f4f56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 3]: /images/20230208/3855d298d1f54b43b182da5e94ce3cdd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 4]: /images/20230208/a3a25e27144948589e82152056eb6083.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 5]: /images/20230208/ade3c416b00b4c75a93d26e9f32b493e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 6]: /images/20230208/a74681e3289e456984b6c45c40d27071.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 7]: /images/20230208/497482d9eb054a658cf594bcec53c0b8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 8]: /images/20230208/f7473b6071fc419d8b5179b4ae2f98aa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 9]: /images/20230208/bbdd8c67dd2a47a4a9e6ae6df4b78ae8.png
[2020073110352680.png]: /images/20230208/799dbec7e7da4d94adab7a93e356dc58.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 10]: /images/20230208/18420027dbdc40668b7cb9e2b2153cad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 11]: /images/20230208/29296ad8b7b04583ba75859bf13cb3a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 12]: /images/20230208/88b343d2026944f99a774d544094e9e0.png
[20200731103744821.png]: /images/20230208/bdfaa978593d480787fe58a75deea578.png
[20200731103800870.png]: /images/20230208/2c33e57056ae428e997e333732948237.png
[20200731103830320.png]: /images/20230208/19cd58605b39433d8ff5e0d53752cafa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 13]: /images/20230208/33cabf2625044e8488c9fcbe8f54de33.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 14]: /images/20230208/01c30a0b56834e91a537217485ff83d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 15]: /images/20230208/5db9e005d3734997b978cfa576feef83.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 16]: /images/20230208/373b35cfe7014ce6918bdc218b2090d1.png
[20200731104129748.png]: /images/20230208/4f723cadac7147e9a4af466048c7b581.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 17]: /images/20230208/19644ccfc12b4a9da88b67f33efa977d.png
[20200731104231690.png]: /images/20230208/67bc7c2181644fa396b4bc8c727f56f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 18]: /images/20230208/ad3673d5a19b40fa8d6ff8765043ea5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L25ld2xpbmZlbmc_size_16_color_FFFFFF_t_70 19]: /images/20230208/db2e0115003f4a3cbfc80bd9da7076a1.png
[20200731104330462.png]: /images/20230208/685891f1e6cb463da281554c4a615739.png