【机器学习 第二周】数据拆分&评价结果&超参数调整

最新推荐文章于 2024-03-13 08:26:37 发布
最新推荐文章于 2024-03-13 08:26:37 发布
阅读量467 收藏
点赞数
分类专栏： 机器学习 文章标签： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Gshiner/article/details/103114315
版权

梳理大纲： 数据拆分&评价结果
【1】数据拆分：训练数据集&测试数据集
【2】评价分类结果：精准度、混淆矩阵、精准率、召回率、F1 Score、ROC曲线等
【3】评价回归结果：MSE、RMSE、MAE、R Squared
【4】超参数调整 （引入调参器概念）

参考资料:
机器学习 西瓜书
微信文章 From【木东居士】 公众号

From 机器学习 小组：由【木东居士】公众号 定期发起
对数据感兴趣的伙伴们 可一同在此交流学习

【1】数据拆分

将数据集分隔为训练集和测试集

——手动实现 随机拆分数据集：

# 方法1：使用concatenate函数进行拼接

# 因为传入的矩阵必须具有相同的形状，因此需要对label进行reshape操作，#reshape(-1,1)表示行数自动计算，1列。axis=1表示纵向拼接。
tempConcat = np.concatenate((X, y.reshape(-1,1)), axis=1)

# 拼接好后，直接进行乱序操作
np.random.shuffle(tempConcat)

# 再将shuffle后的数组使用split方法拆分
shuffle_X,shuffle_y = np.split(tempConcat, [4,], axis=1)

#设置划分的比例
test_ratio = 0.2
test_size = int(len(X) * test_ratio)
X_train = shuffle_X[test_size:]
y_train = shuffle_y[test_size:]
X_test = shuffle_X[:test_size]
y_test = shuffle_y[:test_size]

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

# 方法2：将索引随机打乱

# 将x长度这么多的数，返回一个新的打乱顺序的数组，注意，数组中的元素不是原来的数据，而是混乱的索引
shuffle_index = np.random.permutation(len(X))

# 指定测试数据的比例
test_ratio = 0.2
test_size = int(len(X) * test_ratio)

test_index = shuffle_index[:test_size]
train_index = shuffle_index[test_size:]
X_train = X[train_index]
X_test = X[test_index]
y_train = y[train_index]
y_test = y[test_index]

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

——手动 起草函数-调用

import numpy as np

定义函数部分：
def train_test_split(X, y, test_ratio=0.2, seed=None):
    """将矩阵X和标签y按照test_ration分割成X_train, X_test, y_train, y_test"""
    
    # assert断言语句：用于规范输入
    assert X.shape[0] == y.shape[0], "the size of X must be equal to the size of y"
    assert 0.0 <= test_ratio <= 1.0, "test_train must be valid"

    if seed: # 是否使用随机种子，使随机结果相同，方便debug
        np.random.seed(seed)    
    shuffle_index = np.random.permutation(len(X))
	# permutation(n) 可直接生成一个随机排列的数组，含有n个元素
    test_size = int(len(X) * test_ratio)
    test_index = shuffle_index[:test_size]
    train_index = shuffle_index[test_size:]
    
    X_train = X[train_index]
    X_test = X[test_index]
    y_train = y[train_index]
    y_test = y[test_index]    
    
    return X_train, X_test, y_train, y_test

调用函数部分：
X_train, X_test, y_train, y_test = train_test_split(X, y)

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

——Sklearn中的分隔数据集功能

# 引入sklearn中的train_test_split
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

【2】评价分类结果

先引入概念：混淆矩阵

对于二分类问题来说，所有的问题被分为0和1两类，混淆矩阵是2*2的矩阵：
在这里插入图片描述

  • TN：真实值是0，预测值也是0，即我们预测是negative，预测正确了。
  • FP：真实值是0，预测值是1，即我们预测是positive，但是预测错误了。
  • FN：真实值是1，预测值是0，即我们预测是negative，但预测错误了。
  • TP：真实值是1，预测值是1，即我们预测是positive，预测正确了。

现在假设有1万人进行预测，填入混淆矩阵如下：
在这里插入图片描述
假设1万个人中，有9978个人本身并没有癌症
我们如果清一色预测所有人都没有得病，那最常规的accuray也能达到99.78%
所以这种正负样本严重失衡的情况下，使用accuracy判断 容易出现问题


因此 需要引入其他的评估指标

[1] 准确率 accuracy
accuracy_score：函数计算分类准确率，返回被正确分类的样本比例（default）或者是数量（normalize=False）

[2] 精准率 precision & 召回率 recall

根据混淆矩阵可以求得指标：
在这里插入图片描述

——手动代码实现：
（ 使用逻辑回归 - 验证像素集结果是否为9 ）

# 引入数据集&数据拆分
import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression

digits = datasets.load_digits()
X = digits.data
y = digits.target.copy()

# 要构造偏斜数据，将数字9的对应索引的元素设置为1，0～8设置为0
y[digits.target==9]=1
y[digits.target!=9]=0

# 使用逻辑回归做一个分类
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=666)

log_reg = LogisticRegression()
log_reg.fit(X_train,y_train)
# 得到X_test所对应的预测值
y_log_predict = log_reg.predict(X_test)

# 定义混淆矩阵
# TN
def TN(y_true, y_predict):
    assert len(y_true) == len(y_predict)
    # (y_true == 0)：向量与数值按位比较，得到的是一个布尔向量
    # 向量与向量按位与，结果还是布尔向量
    # np.sum 计算布尔向量中True的个数(True记为1，False记为0)
    return np.sum((y_true == 0) & (y_predict == 0))  
    # 向量与向量按位与，结果还是向量
TN(y_test, y_log_predict)

# FP
def FP(y_true, y_predict):
    assert len(y_true) == len(y_predict)
    # (y_true == 0)：向量与数值按位比较，得到的是一个布尔向量
    # 向量与向量按位与，结果还是布尔向量
    # np.sum 计算布尔向量中True的个数(True记为1，False记为0)
    return np.sum((y_true == 0) & (y_predict == 1))  # 向量与向量按位与，结果还是向量
FP(y_test, y_log_predict)

# FN
def FN(y_true, y_predict):
    assert len(y_true) == len(y_predict)
    # (y_true == 0)：向量与数值按位比较，得到的是一个布尔向量
    # 向量与向量按位与，结果还是布尔向量
    # np.sum 计算布尔向量中True的个数(True记为1，False记为0)
    return np.sum((y_true == 1) & (y_predict == 0))  
    # 向量与向量按位与，结果还是向量
FN(y_test, y_log_predict)

# TP
def TP(y_true, y_predict):
    assert len(y_true) == len(y_predict)
    # (y_true == 0)：向量与数值按位比较，得到的是一个布尔向量
    # 向量与向量按位与，结果还是布尔向量
    # np.sum 计算布尔向量中True的个数(True记为1，False记为0)
    return np.sum((y_true == 1) & (y_predict == 1))  # 向量与向量按位与，结果还是向量
TP(y_test, y_log_predict)

# 混淆矩阵
def confusion_matrix(y_true, y_predict):
    return np.array([
        [TN(y_true, y_predict), FP(y_true, y_predict)],
        [FN(y_true, y_predict), TP(y_true, y_predict)]
    ])
confusion_matrix(y_test, y_log_predict)

# 准确率计算
log_reg = LogisticRegression()
log_reg.fit(X_train,y_train)
# 得到X_test所对应的预测值
y_log_predict = log_reg.predict(X_test)
log_reg.score(X_test, y_test)

# 计算精准率
def precision_score(y_true, y_predict):
    tp = TP(y_true, y_predict)
    fp = FP(y_true, y_predict)
    try:
        return tp / (tp + fp)
    except:
        return 0.0
precision_score(y_test, y_log_predict)

# 计算召回率
def recall_score(y_true, y_predict):
    tp = TP(y_true, y_predict)
    fn = FN(y_true, y_predict)
    try:
        return tp / (tp + fn)
    except:
        return 0.0
recall_score(y_test, y_log_predict)

——使用Sklearn内置函数 实现

# 混淆矩阵
from sklearn.metrics import confusion_matrix
confusion_matrix(y_test, y_log_predict)
# 输出:
# array([[403,   2],
#       [  9,  36]])

# 精准率
from sklearn.metrics import precision_score
precision_score(y_test, y_log_predict)
# 输出:
# 0.9473684210526315

# 召回率
from sklearn.metrics import recall_score
recall_score(y_test, y_log_predict)
# 输出:
# 0.8

【3】评估回归结果

首先，以线性回归模型的三个常用评价方法为例

简单线性回归的目标是：
在这里插入图片描述
在这里插入图片描述
【1】均方误差MSE

测试集中的数据量m不同，因为有累加操作，所以随着数据的增加 ，误差会逐渐积累；因此衡量标准和 m 相关
为了抵消掉数据量的形象，可以除去数据量，抵消误差。通过这种处理方式得到的结果叫做 均方误差MSE（Mean Squared Error）：
在这里插入图片描述
【2】 均方根误差RMSE

但是使用均方误差MSE收到量纲的影响
例如在衡量房产时，y的单位是（万元），那么衡量标准得到的结果是（万元平方）
为了解决量纲的问题，可以将其开方（为了解决方差的量纲问题，将其开方得到平方差）得到均方根误差RMSE（Root Mean Squarde Error）：
在这里插入图片描述

【3】平均绝对误差MAE

对于线性回归算法还有另外一种非常朴素评测标准
要求真实值 与 预测结果 之间的距离最小，可以直接相减做绝对值，加m次再除以m，即可求出平均距离，被称作平均绝对误差MAE（Mean Absolute Error）：
在这里插入图片描述
在之前确定损失函数时，由于绝对值函数不是处处可导的，因此没有使用绝对值。但是在评价模型时不影响。因此模型的评价方法可以和损失函数不同

【4】R Square
之前的分类准确率，就是在【0-1】之间取值。
但RMSE和MAE没有这样的性质，存在不同量纲之间无法比较的局限性
（比如我们在预测波士顿方差，RMSE值是4.9（万美元） 我们再去预测身高，可能得到的误差是10（厘米），我们不能说后者比前者更准确）

所以引入了R Square:
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

————手动代码实现：

# MSE 均方误差
mse_test = np.sum((y_predict - y_test) ** 2) / len(y_test)
mse_test

# RMSE 均方根误差
from math import sqrt
rmse_test = sqrt(mse_test)
rmse_test

# MAE 平均绝对误差
mae_test = np.sum(np.absolute(y_predict - y_test)) / len(y_test)
mae_test

# R Square
mean_squared_error(y_test, y_predict) / np.var(y_test)

——Sklearn中的MSE和MAE：


from sklearn.metrics import mean_squared_error
from sklearn.metrics import mean_absolute_error

# MSE
mean_squared_error(y_test, y_predict)
# 输出：24.156602134387438

# MAE
mean_absolute_error(y_test, y_predict)
# 输出：3.5430974409463873

# R Square
from sklearn.metrics import r2_score
r2_score(y_test, y_predict)

【4】超参数调整 （引入调参器概念）

所谓超参数，就是在机器学习算法模型执行之前需要指定的参数。
（调参调的就是超参数） 如kNN算法中的k

如何选择最佳的超参数？
以KNN模型为例：
KNN的超参数除了k，还有weights，weights默认是uniform即不考虑距离，也可以写distance来考虑距离权重(默认是欧拉距离，如果要是曼哈顿距离，则可以写参数p（明可夫斯基距离的参数）

—— 手动代码实现：

# 遍历循环参数的可能性
best_method = ""
best_score = 0.0
best_k = -1
for method in ["uniform","distance"]:    
	for k in range(1, 11):
        knn_clf = KNeighborsClassifier(n_neighbors=k, weights=method, p=2)
        knn_clf.fit(X_train, y_train)
        score = knn_clf.score(X_test, y_test)        
        if score > best_score:
            best_k = k
            best_score = score
            best_method = method
print("best_method = ", method)
print("best_k = ", best_k)
print("best_score = ", best_score)

输出：best_method =  distance
best_k =  4best_score =  0.9916666666666667

—— Sklearn中的超参数网格搜索方法Grid Search：

param_search = [
    {"weights":["uniform"],"n_neighbors":[i for i in range(1,11)]
    },
    {"weights":["distance"],"n_neighbors":[i for i in range(1,11)],"p":[i for i in range(1,6)]
    }
]

knn_clf = KNeighborsClassifier()
from sklearn.model_selection import GridSearchCV

grid_search = GridSearchCV(knn_clf, param_search)
grid_search.fit(X_train, y_train)
——————————————————————————————————————
输出：CPU times: user 2min 21s, sys: 628 ms, total: 2min 21s
Wall time: 2min 23s
GridSearchCV(cv=None, error_score='raise',
       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform'),
       fit_params=None, iid=True, n_jobs=1,
       param_grid=[{'weights': ['uniform'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}, {'weights': ['distance'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'p': [1, 2, 3, 4, 5]}],
       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',
       scoring=None, verbose=0)
——————————————————————————————————————

# 返回的是网格搜索搜索到的最佳的分类器对应的参数 
grid_search.best_estimator_
——————————————————————————————————————
输出：KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=3, p=3,
           weights='distance')
——————————————————————————————————————

grid_search.best_score_
输出：0.9853862212943633

grid_search.beat_params_
输出：{'n_neighbors':3, 'p':3, 'weights':'distance'}

knn_clf = grid_search.beat_estimator_
knn_clf.score(X_test, y_test)
输出：0.9833333333328

注：best_estimator_和best_score_参数后面有一个_。这是一种常见的语法规范，不是用户传入的参数，而是根据用户传入的规则，自己计算出来的结果，参数名字后面接_

Gshiner
关注
专栏目录
能否用测试集调超参数？
AlphaFinance
04-10 895
您可以在训练集上训练模型，在验证集上调整超参数（如学习率、正则化参数等），然后在测试集上评估模型的最终性能。不建议使用测试集来调整超参数。测试集的目的是在模型训练和调优完成后，评估模型在未见过的数据上的泛化性能。为了公平地评估模型在未见过的数据上的性能，应该在独立的数据集（验证集）上进行调优。更准确的性能评估：使用验证集进行超参数调整可以确保测试集在评估过程中保持未知，从而更准确地估计模型在实际应用中的性能。因此，在模型训练和调参过程中，应遵循训练-验证-测试的原则，以获得更可靠的性能评估。
机器学习流程—数据预处理 清洗
03-05 3万+
这里我们需要说明一下，虽然这里我们讲的是数据预处理，但是我们这里为了更加充分的理解我们后面的数据预处理，这里我们说明一下我们要解决什么样的问题，也就是定义问题。itanic数据集作为kaggle比赛中的经典数据集，今天我们使用的数据也是这个数据集，这个数据集描述的主要是泰坦尼克号邮轮上乘客的数据，我们要做的事情就是根据乘客的数据预测乘客在泰坦尼克号沉没的时候时候可以活下来。
机器学习入门之数据拆分、评价分类结果（二）
ymhua的专栏
11-17 448
1.数据拆分 在上篇文章《机器学习入门算法之KNN》中，提到了训练数据和测试数据，即数据拆分的两个子集。 训练集 - 用于训练模型的子集； 测试集 -需要测试分类的数据。 为什么需要将数据拆分呢，比如我们在建立一个模型后，能够得到一个预测结果，如何来判断这个模型预测的结果是准确的呢？ 因此，一般会将一组原始数据拆分为训练数据和测试数据两个子集，训练数据用于训练模型，而测试数据用于测试模型的准确度。...
Task6：掌握分类问题的评估及超参数调优
csdnshenjiaye的博客
03-28 723
1.超参数简介 1.1超参数的“学院派”定义 在机器学习的过程中， 超参= 在开始机器学习之前，就人为设置好的参数。 模型参数=通过训练得到的参数数据。 通常情况下，需要对超参数进行优化，给学习机选择一组最优超参数，以提高学习的性能和效果 1.2怎么决定超参数 1. 定义关于模型的更高层次的概念，如复杂性或学习能力。 2. 不能直接从标准模型培训过程中的数据中学习，需要预先定义。 3. 可以通过设置不同的值，训练不同的模型和选择更好的测试值来决定 1.3超参数的“通俗”定义 超参数也是一种参数，
机器学习中的数据集切分
Laurence的技术博客
12-26 1461
应用有监督的机器学习算法时，需要将数据集切分成训练数据集和测试数据集两部分。在《Handson ML》一书中，使用了numpy.random.permutation，对数据集进行了切分。其思路是：利用permutation生成shuffle后记录索引(打乱顺序的索引集合)，然后按比例
6-2指针做参数传递 拆分实数的整数与小数部分
qq_62112446的博客
12-01 298
互相学习，有好的建议欢迎提出 #include <stdio.h> void splitfloat( float x, int *intpart, float *fracpart ); int main() { float x, fracpart; int intpart; scanf("%f", &x); splitfloat(x, &intpart, &fracpart); printf("The integer par...
机器学习——基于python的鸢尾花SVM练习（包含超参数批量筛选、交叉验证）
Dzfly
04-01 6094
基于python的鸢尾花SVM练习，包含超参数的批量筛选，重复交叉验证。
python模型参数估计_【干货】Python机器学习项目实战2——模型选择，超参数调整和评估（附代码）...
weixin_33831334的博客
12-28 761
【导读】这是一篇完全手把手进行机器学习项目构建的教程，包含：1. 数据清理和格式化 2. 探索性数据分析 3. 特征工程和特征选择 4. 在性能指标上比较几种机器学习模型 5. 对最佳模型执行超参数调整 6. 在测试集合中评估最佳模型 7. 解释模型结果 8. 得出结论。在第一篇文章中，我们对数据进行了清理和结构化，进行了探索性的数据分析，开发了一组用于我们模型的特征，并建立了一个基准(basel...
数据分析--机器学习
weixin_43784274的博客
03-16 607
计算样本i和簇内其他样本间的平均距离得到样本i的簇内不相似度，计算样本i和其他簇内样本间的平均距离得到样本i的簇间不相似度bi。优点：朴素贝叶斯算法假设了数据集属性之间是相互独立的，因此算法的逻辑性十分简单，并且算法较为稳定，即朴素贝叶斯算法的稳定性比较好，对于不同类型的数据集不会呈现出太大的差异性。是监督学习，数据集是带Label的数据，没有明显的训练过程。缺点：数据集属性的独立性在很多情况下是很难满足的，因为数据集的属性之间往往都存在着相互关联，如果在分类过程中出现这种问题，会导致分类的效果大大降低。
机器学习基础入门：利用机器学习技术进行数据驱动的分析
程序员光剑
08-21 477
什么是机器学习？为什么需要用到机器学习？机器学习是指计算机通过数据编程的方法自动分析、学习并优化一个系统或模型，从而提高其性能、准确性、效率、理解力等方面。由于统计学、数学、工程、计算机科学等多领域知识的综合运用，机器学习技术正在成为当今热门的应用领域之一。近年来，随着大数据的出现，人们对利用机器学习技术进行数据驱动的分析产生了更大的需求。随着人工智能领域蓬勃发展，机器学习将迎来一个全新的时代。
python划分数据集_Python数据集切分实例
weixin_39796152的博客
12-05 1266
在处理数据过程中经常要把数据集切分为训练集和测试集，因此记录一下切分代码。'''data:数据集test_ratio:测试机占比如果data为numpy.numpy.ndarray直接使用此代码如果data为pandas.DatFrame类型则return data[train_indices],data[test_indices]修改为return data.iloc[train_indices...
python划分训练集、验证集和测试集
热门推荐
haoji007的博客
05-16 10万+
机器学习简单流程： 使用大量和任务相关的数据集来训练模型； 通过模型在数据集上的误差不断迭代训练模型，得到对数据集拟合合理的模型； 将训练好调整好的模型应用到真实的场景中； 我们最终的目的是将训练好的模型部署到真实的环境中，希望训练好的模型能够在真实的数据上得到好的预测效果，换句话说就是希望模型在真实数据上预测的结果误差越小越好。我们把模型在真实环境中的误差叫做泛化误差，最终的目的是希望训练好的模型泛化误差越低越好。 我们希望通过某个信号来了解模型的泛化误差，这样就可以指导我们得到泛化能力更强的模型
[YOLOv8] 缺陷检测之如何划分训练集，验证集和测试集
老狼工作室的博客
12-15 6364
本文介绍了如何通过python代码把来自AnyLabeling管理的数据集，按照设定的训练集，验证集，测试集的比例进行随机划分，并生成YOLOv8训练时用到的data.yaml文件.
[012] 不同数据集划分与验证方法的实现与比较
Pysamlam的博客
01-24 1081
“哈哈，我们在训练我们的模型并且希望得到更加准确的结果，但基于实际的情况（比如算力、时间），往往会按照一定策略来选择。本文介绍了几种常见的数据集划分与交叉验证的方法策略以及它们的优缺点，...
模型评估、选择与验证——数据集切分
As的博客
04-14 2350
train_test_split模型原型class sklearn.model_selection.train_test_split(arrays, *options) 参数 *arrays : 一个或多个数据集 test_size : 指定测试集的大小 浮点数：测试集占原始数据集的比例 整数：测试集的大小 None：测试集大小=原始数据集大小-训练数据集大小 train_size : 指定训练
Python数据集切分
好记性不如烂笔头
01-12 3万+
在处理数据过程中经常要把数据集切分为训练集和测试集，因此记录一下切分代码。在处理数据过程中经常要把数据集切分为训练集和测试集，因此记录一下切分代码。''' data:数据集 test_ratio:测试机占比 如果data为numpy.numpy.ndarray直接使用此代码 如果data为pandas.DatFrame类型则 return data[train_indices],data[t
交叉验证（Cross Validation）
错位的梦寐的博客
10-25 2398
一、训练集 vs. 测试集 在模式识别（pattern recognition）与机器学习（machine learning）的相关研究中，经常会将数据集（dataset）分为训练集（training set）跟测试集（testing set）这两个子集，前者用以建立模型（model），后者则用来评估该模型对未知样本进行预测时的精确度，正规的说法是泛化能力（generalization abili...
数据可视化--头歌数据挖掘实训
最新发布
geekchen的博客
03-13 1486
第1关：单个属性观测值分布——直方图 第2关：单个属性观测值分布——盒状图 第3关：单个属性观测值分布——饼图 第4关：两个属性之间的关系——散布图 第5关：时间空间数据的可视化——等高线图 第6关：时间空间数据的可视化——曲面图 第7关：时间空间数据的可视化——GIS可视化 第8关：可视化高维度数据——数据矩阵 第9关：可视化高维度数据——相关矩阵 第10关：可视化高维度数据——平行坐标系
1.机器学习之(3)train-test-split进行算法性能测试
xdzhangzhenhao的博客
07-18 2293
将数据集进行test和train划分的意义 如果将所有的数据都作为训练数集，那么我们训练完模型就无从验证，将没有验证过的模型直接用于实际环境中，那么效果不一定理想，好坏只能听天由命，那么有什么办法能在实际应用我们的机器学习算法之前就大概能知道我们的算法能不能适用到实际环境呢？答案是对手里的数据进行test和train的划分，训练完模型后就用test数据进行测试。根据测试结果决定对模型的后续操作！...
机器学习实战：KNN算法的测试集与超参数优化
在机器学习的“傻瓜式”理解中，第四个章节深入探讨了KNN算法的数据处理以及超参数的重要性。KNN（K-Nearest Neighbors）算法是一种基于实例的学习方法，其核心思想是根据新样本与训练集中已知样本的相似性来进行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值