Python 全栈体系【四阶】（十三）

第四章 机器学习

十六、模型评估与优化

1. 模型评估

1.1 性能度量
1.1.1 错误率与精度

错误率和精度是分类问题中常用的性能度量指标，既适用于二分类任务，也适用于多分类任务。

  • 错误率（error rate）：指分类错误的样本占样本总数的比例，即 （ 分类错误的数量 / 样本总数数量）

  • 精度（accuracy）：指分类正确的样本占样本总数的比例，即 （分类正确的数量 / 样本总数数量）

    精度 = 1 − 错误率 精度 = 1 - 错误率 精度=1−错误率

1.1.2 查准率、召回率与 F1 得分

错误率和精度虽然常用，但并不能满足所有的任务需求。例如，在一次疾病检测中，我们更关注以下两个问题：

  • 检测出感染的个体中有多少是真正病毒携带者？
  • 所有真正病毒携带者中，有多大比例被检测了出来？

类似的问题在很多分类场景下都会出现，“查准率”（precision）与“召回率”（recall）是更为适合的度量标准。对于二分类问题，可以将真实类别、预测类别组合为“真正例”（true positive）、“假正例”（false positive）、“真反例”（true negative）、“假反例”（false negative）四种情形，见下表：

在这里插入图片描述

  • 样例总数：TP + FP + TN + FN

  • 查准率： TP / (TP + FP)，表示分的准不准

  • 召回率：TP / (TP + FN)，表示分的全不全，又称为“查全率”

  • F1 得分：
    f 1 = 2 ∗ 查准率 ∗ 召回率 查准率 + 召回率 f1 = \frac{2 * 查准率 * 召回率}{查准率 + 召回率} f1=查准率+召回率2∗查准率∗召回率​

查准率和召回率是一对矛盾的度量。一般来说，查准率高时，召回率往往偏低；召回率高时，查准率往往偏低。例如，在病毒感染者检测中，若要提高查准率，只需要采取更严格的标准即可，这样会导致漏掉部分感染者，召回率就变低了；反之，放松检测标准，更多的人被检测为感染，召回率升高了，查准率又降低了。通常只有在一些简单任务中，才能同时获得较高查准率和召回率。

查准率和召回率在不同应用中重要性也不同。例如，在商品推荐中，为了尽可能少打扰客户，更希望推荐的内容是用户感兴趣的，此时查准率更重要；而在逃犯信息检索系统中，希望让更少的逃犯漏网，此时召回率更重要。

请添加图片描述

  • 真：预测对的
  • 假：预测错的
  • 正例：预测狗，狗就是正例，猫就是反例
1.1.3 混淆矩阵

混淆矩阵也称误差矩阵，是表示精度评价的一种标准格式，用 n 行 n 列的矩阵形式来表示。每一行（数量之和）表示一个真实类别的样本，每一列（数量之和）表示一个预测类别的样本。

以下是一个预测结果准确的混淆矩阵：

  • 对的个数：主对角线上的值
  • 预测出来的个数：当前列的和
  • 真实的样本个数：当前行的和
A 类别B 类别C 类别
A 类别500
B 类别060
C 类别007

上述表格表示的含义为：A 类别实际有 5 个样本，B 类别实际有 6 个样本，C 类别实际有 7 个样本；预测结果中，预测结果为 A 类别的为 5 个，预测结果为 B 类别的为 6 个，预测结果为 C 类别的为 7 个。

以下是一个预测结果不准确的混淆矩阵：

A 类别B 类别C 类别
A 类别311
B 类别042
C 类别007

上述表格表示的含义为：A 类别实际有 5 个样本，B 类别实际有 6 个样本，C 类别实际有 7 个样本；预测结果中，A 类别有 3 个样本预测准确，另外各有 1 个被预测成了 B 和 C；B 类别有 4 个预测准确，另外 2 个被预测成了 C 类别；C 类别 7 个全部预测准确，但有 1 个本属于 A 类别、2 个本属于 B 类别的被预测成了 C 类别。

根据混淆矩阵，查准率、召回率也可表示为：

查准率 = 主对角线上的值 / 该值所在列的和

召回率 = 主对角线上的值 / 该值所在行的和

1.1.4 分类报告
sm.classification_report(test_y, pred_test_y)
1.1.5 实验

利用 sklearn 提供的朴素贝叶斯分类器分类，并打印查准率、召回率、R2 得分和混淆矩阵：

# 混淆矩阵示例
import numpy as np
import sklearn.model_selection as ms
import sklearn.metrics as sm
import sklearn.naive_bayes as nb

# 输入，输出
x, y = [], []

# 读取数据文件
with open("../data/multiple1.txt", "r") as f:
    for line in f.readlines():
        data = [float(substr) for substr in line.split(",")]
        x.append(data[:-1])  # 输入样本：取从第一列到导数第二列
        y.append(data[-1])  # 输出样本：取最后一列

# 样本转数组
x = np.array(x)
y = np.array(y, dtype=int)

# 划分训练集和测试集
train_x, test_x, train_y, test_y = ms.train_test_split(
    x, y, test_size=0.25, random_state=7)

# 创建高斯朴素贝叶斯分类器对象
model = nb.GaussianNB()
model.fit(train_x, train_y)  # 使用划分的训练集来训练模型
pred_test_y = model.predict(test_x)  # 预测

print("recall:", sm.recall_score(test_y,  # 真实值
                                 pred_test_y,  # 预测值
                                 average="macro"))  # 计算平均值，不考虑样本权重
print("precision:", sm.precision_score(test_y,  # 真实值
                                       pred_test_y,  # 预测值
                                       average="macro"))  # 计算平均值，不考虑样本权重
print("F1:", sm.f1_score(test_y, pred_test_y,average="macro"))

# 计算并打印模型预测的混淆矩阵
print("\n Confusion Matrix:")
cm = sm.confusion_matrix(test_y, pred_test_y)
print(cm)

打印输出：

recall: 0.9910714285714286
precision: 0.9903846153846154
F1: 0.9905525846702318

 Confusion Matrix:
[[22  0  0  0]
 [ 0 27  1  0]
 [ 0  0 25  0]
 [ 0  0  0 25]]
1.2 训练集与测试集

通常情况下，评估一个模型性能的好坏，将样本数据划分为两部分，一部分专门用于模型训练，这部分称为“训练集”，一部分用于对模型进行测试，这部分被称为“测试集”，训练集和测试集一般不存在重叠部分。常用的训练集、测试集比例有：9:1, 8:2, 7:3 等。训练集和测试的划分，尽量保持均衡、随机，不能集中于某个或少量类别。

有些公共数据集在创建时，已经进行了划分。有时候，我们需要自己对数据集进行划分，划分的方式是先打乱数据集，然后使用一种计算方法，将一部分数据划入训练集，一部分数据划入测试集。

在这里插入图片描述

ms.train_test_split(x, y,
					test_size=0.1,
					random_state=7,
					stratify=y)	# Equally divided by category
1.3 交叉验证法
1.3.1 什么是交叉验证

在样本数量较少的情况下，如果将样本划分为训练集、测试集，可能导致单个集合样本数量更少，可以采取交叉验证法来训练和测试模型。

“交叉验证法”（cross validation）先将数据集 D 划分为 k 个大小相同（或相似）的、互不相交的子集，每个子集称为一个"折叠"（fold），每次训练，轮流使用其中的一个作为测试集、其它作为训练集。 这样，就相当于获得了 k 组训练集、测试集，最终的预测结果为 k 个测试结果的平均值。

在这里插入图片描述

1.3.2 如何实现交叉验证

sklearn 中，提供了 cross_val_score 函数来实现交叉验证并返回评估指标值：

import sklearn.model_selection as ms

n = ms.cross_val_score(model, #模型
                       train_x, train_y,# 样本输入、输出
                       cv,  # 折叠数量
                       scoring) # 指定返回的指标

以下是关于朴素贝叶斯模型的交叉验证实现：

# 交叉验证示例
import numpy as np
import sklearn.model_selection as ms
import sklearn.naive_bayes as nb
import matplotlib.pyplot as mp

x, y = [], []  # 输入，输出

# 读取数据文件
with open("../data/multiple1.txt", "r") as f:
    for line in f.readlines():
        data = [float(substr) for substr in line.split(",")]
        x.append(data[:-1])  # 输入样本：取从第一列到导数第二列
        y.append(data[-1])  # 输出样本：取最后一列

train_x = np.array(x)
train_y = np.array(y, dtype=int)

# 划分训练集和测试集
#train_x, test_x, train_y, test_y = ms.train_test_split(
#    x, y, test_size=0.25, random_state=7)

# 创建高斯朴素贝叶斯分类器对象
model = nb.GaussianNB()
# 先做交叉验证，如果得分结果可以接受，再执行训练和预测
pws = ms.cross_val_score(model, x, y,
                         cv=5,  # 折叠数量
                         scoring='precision_weighted')  # 查准率
print("precision:", pws.mean())

rws = ms.cross_val_score(model, x, y, cv=5,
                         scoring='recall_weighted')  # 召回率
print("recall:", rws.mean())

f1s = ms.cross_val_score(model, x, y, cv=5,
                         scoring='f1_weighted')  # F1得分
print("f1:", f1s.mean())

acc = ms.cross_val_score(model, x, y,
                         cv=5, scoring='accuracy')  # 准确率
print("acc:", acc.mean())

执行结果：

precision: 0.996822033898305
recall: 0.9966101694915255
f1: 0.9966063988235516
acc: 0.9966101694915255

2. 模型优化

2.1 验证曲线与学习曲线
2.1.1 验证曲线

验证曲线是指根据不同的评估系数，来评估模型的优劣。例如，构建随机森林，树的数量不同，模型预测准确度有何不同？以下是一个验证曲线的示例：

# 验证曲线示例
import numpy as np
import sklearn.preprocessing as sp
import sklearn.ensemble as se
import sklearn.model_selection as ms
import matplotlib.pyplot as mp

data = []
with open("../data/car.txt", "r") as f:
    for line in f.readlines():
        data.append(line.replace("\n", "").split(","))

data = np.array(data).T  # 转置
encoders, train_x = [], []

# 对样本数据进行标签编码
for row in range(len(data)):
    encoder = sp.LabelEncoder()  # 创建标签编码器
    encoders.append(encoder)
    if row < len(data) - 1:  # 不是最后一行，为样本特征
        lbl_code = encoder.fit_transform(data[row])  # 编码
        train_x.append(lbl_code)
    else:  # 最后一行，为样本输出
        train_y = encoder.fit_transform(data[row])

train_x = np.array(train_x).T  # 转置回来，变为编码后的矩阵
# print(train_x)

model = se.RandomForestClassifier(max_depth=8,  # 最大树高
                                  random_state=7)  # 随机种子
# 调用validation_curve，返回训练集、测试集得分矩阵
n_estimators = np.arange(50, 550, 50)  # 超参数值表
print("n_estimators.shape:", n_estimators.shape)
print("n_estimators:", n_estimators)

# 通过不同参数，构建多棵决策树，验证其准确性
train_scores1, test_scores1 = ms.validation_curve(model,  # 模型
                                                  train_x, train_y,
                                                  'n_estimators',  # 模型参数名称
                                                  n_estimators,  # 模型参数值
                                                  cv=5)
train_mean = train_scores1.mean(axis=1)
print("train_mean:", train_mean)
test_mean = test_scores1.mean(axis=1)
print("test_mean:", test_mean)

# 可视化
mp.figure('n_estimators', facecolor='lightgray')
mp.title('n_estimators', fontsize=20)
mp.xlabel('n_estimators', fontsize=14)
mp.ylabel('F1 Score', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
mp.plot(n_estimators, test_mean, 'o-', c='blue', label='Testing')
mp.legend()
mp.show()

执行结果：

在这里插入图片描述

2.1.2 学习曲线

学习曲线是用来评估不同大小的训练集下模型的优劣程度，如果预测结果随着训练集样本的增加而变化不大，那么增加样本数量不会对模型产生明显优化作用。以下是一个学习曲线的示例：

# 学习曲线示例
import numpy as np
import sklearn.preprocessing as sp
import sklearn.ensemble as se
import sklearn.model_selection as ms
import matplotlib.pyplot as mp

data = []
with open("../data/car.txt", "r") as f:
    for line in f.readlines():
        data.append(line.replace("\n", "").split(","))

data = np.array(data).T  # 转置
encoders, train_x = [], []

# 对样本数据进行标签编码
for row in range(len(data)):
    encoder = sp.LabelEncoder()  # 创建标签编码器
    encoders.append(encoder)
    if row < len(data) - 1:  # 不是最后一行，为样本特征
        lbl_code = encoder.fit_transform(data[row])  # 编码
        train_x.append(lbl_code)
    else:  # 最后一行，为样本输出
        train_y = encoder.fit_transform(data[row])

train_x = np.array(train_x).T  # 转置回来，变为编码后的矩阵
print(train_x)

# 获得学习曲线
model = se.RandomForestClassifier(max_depth=9,  # 最大树高
                                  n_estimators=200, # 评估系数
                                  random_state=7)  # 随机种子

train_sizes = np.linspace(0.1, 1, 10)
train_sizes, train_scores, test_scores = ms.learning_curve(
                                                        model,
                                                        train_x, train_y,
                                                        train_sizes=train_sizes,
                                                        cv=5)#交叉验证折叠数量
train_means = train_scores.mean(axis=1)
test_means = test_scores.mean(axis=1)
for size, score in zip(train_sizes, train_means):
    print(size, '->', score)

# 可视化
mp.figure('Learning Curve', facecolor='lightgray')
mp.title('Learning Curve', fontsize=20)
mp.xlabel('Train Size', fontsize=14)
mp.ylabel('F1 Score', fontsize=14)
mp.tick_params(labelsize=10)
mp.grid(linestyle=':')
mp.plot(train_sizes, train_means, 'o-', c='dodgerblue', label='Training')
mp.plot(train_sizes, test_means, 'o-', c='orangered', label='Testing')
mp.legend()
mp.show()

执行结果：

在这里插入图片描述

2.2 超参数优化
2.2.1 什么是超参数

超参数是在开始学习过程之前设置值的参数，而不是通过训练得到的参数数据。超参数的设置主要依赖于经验、实验或经过比较的优选值。以下是一些模型中常见的超参数：

  • 决策树模型树的最大深度；
  • 随机森林模型树的数量；
  • 交叉验证中折叠的额数量；
  • 训练集/测试集的比例等等。

超参数选择主要有随机搜索、网格搜索等方法。

2.2.2 网格搜索

网格搜索指将主要参数以及这些参数的主要取值，通过穷举法产生不同组合，计算并比较预测结果，来寻找这些参数的最优组合。

以下是利用网格搜索法，寻找 SVM 的最优超参数的示例：

# 网格搜索示例
import numpy as np
import sklearn.model_selection as ms
import sklearn.svm as svm
import sklearn.metrics as sm
import matplotlib.pyplot as mp

x, y = [], []
with open("../data/multiple2.txt", "r") as f:
    for line in f.readlines():
        data = [float(substr) for substr in line.split(",")]
        x.append(data[:-1])  # 输入
        y.append(data[-1])  # 输出

x = np.array(x)
y = np.array(y, dtype=int)

# 通过网格搜索确定最优参数组合
# 定义参数字典
params = [
    {"kernel": ["linear"],
     "C": [1, 10, 100, 1000]
     },
    {"kernel": ["poly"],
     "C": [1],
     "degree": [2, 3]
     },
    {"kernel": ["rbf"],
     "C": [1, 10, 100, 1000],
     "gamma": [1, 0.1, 0.01, 0.001]
     }
]

model = ms.GridSearchCV(svm.SVC(), params, cv=5)  # 创建网格搜索对象
model.fit(x, y)  # 训练

print("best_score_:", model.best_score_)
print("best_params_:\n", model.best_params_)
#print("best_estimator_:\n", model.best_estimator_)

l, r, h = x[:, 0].min() - 1, x[:, 0].max() + 1, 0.005
b, t, v = x[:, 1].min() - 1, x[:, 1].max() + 1, 0.005
grid_x = np.meshgrid(np.arange(l, r, h), np.arange(b, t, v))
flat_x = np.c_[grid_x[0].ravel(), grid_x[1].ravel()]
flat_y = model.predict(flat_x)
grid_y = flat_y.reshape(grid_x[0].shape)

mp.figure("SVM RBF Classifier", facecolor="lightgray")
mp.title("SVM RBF Classifier", fontsize=14)
mp.xlabel("x", fontsize=14)
mp.ylabel("y", fontsize=14)
mp.tick_params(labelsize=10)
mp.pcolormesh(grid_x[0], grid_x[1], grid_y, cmap="gray")

C0, C1 = (y == 0), (y == 1)
mp.scatter(x[C0][:, 0], x[C0][:, 1], c="orangered", s=80)
mp.scatter(x[C1][:, 0], x[C1][:, 1], c="limegreen", s=80)

mp.show()

打印输出：

best_score_: 0.95
best_params_:
 {'C': 1, 'gamma': 1, 'kernel': 'rbf'}

执行结果可视化：

在这里插入图片描述

2.2.3 随机搜索

随机搜索的思想与网格搜索比较相似，只是不再测试上界和下界之间的所有值，而是在搜索范围中随机选取样本点。它的理论依据是，如果样本点集足够大，那么通过随机采样也能大概率地找到全局最优值，或其近似值。随机搜索一般会比网格搜索要快一些，但是和网格搜索的快速版一样，它的结果也是没法保证的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/314337.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

NowinAndroid—2024 Android现代开发全功能应用

NowinAndroid—2024 Android现代开发全功能应用

NowinAndroid—2024 Android现代开发全功能应用 现代Android开发全功能示例应用Now-in-Android&#xff0c;它是用Kotlin和Jetpack Compose开发的&#xff0c;功能非常强大。这个应用遵循了安卓设计和开发的最佳方法&#xff0c;旨在给开发者提供实用的参考资料。无论你是新手…
阅读更多...
做饭这些事：工程师用热风枪来烤鸡翅~

做饭这些事：工程师用热风枪来烤鸡翅~

作为一枚合格的工程师&#xff0c;经常会重点关注如何用自身本领及工具来处理事情&#xff0c;其中之一便是做饭&#xff01;工程师人才济济&#xff0c;区区做饭这些事&#xff0c;So Easy&#xff01;下面将分享如何用热风枪制作一盆香喷喷的烤鸡翅~ 1、准备工作首先&#xf…
阅读更多...
计算机系统（软考版）----计算机系统基础知识、基本单位与进制（1）

计算机系统（软考版）----计算机系统基础知识、基本单位与进制（1）

文章目录 计算机系统基础知识一 硬件组成二 CPU功能三 CPU组成运算器控制器寄存器组 练习题&#xff08;答案为加粗部分&#xff09; 计算机基本单位与进制一 计算机基本单位二 进制1 概述2 进制转换3 进制加减 练习题&#xff08;答案为加粗部分&#xff09; 计算机系统基础知…
阅读更多...
Rust 最新版1.75.0升级记

Rust 最新版1.75.0升级记

升级方法 稳定版 C:\>rustup update stable info: syncing channel updates for stable-x86_64-pc-windows-msvc info: latest update on 2023-12-28, rust version 1.75.0 (82e1608df 2023-12-21) info: downloading component cargo 5.9 MiB / 5.9 MiB (100 %) 3.…
阅读更多...
C#超市管理系统源码

C#超市管理系统源码

C#超市管理系统源码 功能齐全的超市管理系统&#xff0c;专门美化过UI 请先附加数据库&#xff0c;否则无法进入系统 默认拥有最高权限账户为经理&#xff0c;密码为admin 压缩包内有使用说明
阅读更多...
Postman接口测试神器从安装到精通

Postman接口测试神器从安装到精通

Postman 的优点&#xff1a; 支持各种的请求类型: get、post、put、patch、delete 等支持在线存储数据&#xff0c;通过账号就可以进行迁移数据很方便的支持请求 header 和请求参数的设置支持不同的认证机制&#xff0c;包括 Basic Auth&#xff0c;Digest Auth&#xff0c;OAu…
阅读更多...
索引策略-多列索引

索引策略-多列索引

一. 前言 当我们对多列索引的理解不够深刻的时候,往往会为每个列创建独立的索引或者按照错误的顺序创建多列索引。 二. 案例说明 问题一: 为每个列创建独立索引 CREATE TABLE t(c1 INT,c2 INT,c3 INT,KEY(c1),KEY(c2),KEY(c3) );这种索引策略,一般都是由于人们听到一些专家诸…
阅读更多...
【Python进阶必备】一文掌握re库：实战正则表达式

【Python进阶必备】一文掌握re库：实战正则表达式

目录 re库初识 re库基础使用方法 compile()函数 基本用法 正则表达式常用规则字符 match与search方法 match search match/search findall与finditer方法 使用findall()返回所有匹配项 使用findall()提取多个组的匹配 使用finditer()逐个返回Match对象 使用findi…
阅读更多...
Android14之解决Pixel手机联网出现感叹号(一百八十)

Android14之解决Pixel手机联网出现感叹号(一百八十)

简介&#xff1a; CSDN博客专家&#xff0c;专注Android/Linux系统&#xff0c;分享多mic语音方案、音视频、编解码等技术&#xff0c;与大家一起成长&#xff01; 优质专栏&#xff1a;Audio工程师进阶系列【原创干货持续更新中……】&#x1f680; 优质专栏&#xff1a;多媒…
阅读更多...
MySQL的Windows系统安装

MySQL的Windows系统安装

一、MySQL的Windows系统安装 1、下载MySQL安装包 打开如下链接地址&#xff0c;下载安装包 2、安装并配置 双击下载好的安装包进行安装&#xff0c;出现如下界面&#xff1a; 选择【 Full 】选项&#xff0c;然后单击【 Next 】按钮。 出现如下界面&#xff0c;单击【 Execute…
阅读更多...
数据结构实战：利用JavaScript和Python实现链表

数据结构实战：利用JavaScript和Python实现链表

文章目录 一、实战概述二、链表&#xff08;一&#xff09;链表概述&#xff08;二&#xff09;结点结构&#xff08;二&#xff09;链表结构 三、利用JavaScript实现链表&#xff08;一&#xff09;创建LinkedList.js&#xff08;二&#xff09;创建LinkedList.html&#xff0…
阅读更多...
数字图像处理常用算法的原理和代码实现详解

数字图像处理常用算法的原理和代码实现详解

本专栏详细地分析了常用图像处理算法的数学原理、实现步骤。配有matlab或C实现代码&#xff0c;并对代码进行了详细的注释。最后&#xff0c;对算法的效果进行了测试。相信通过这个专栏&#xff0c;你可以对这些算法的原理及实现有深入的理解&#xff01;   如有疑问&#xf…
阅读更多...
中通快递批量查询方法

中通快递批量查询方法

你是否经常需要处理大量的中通快递单号&#xff0c;却苦于一个个等待查询&#xff1f;现在&#xff0c;有了固乔快递查询助手&#xff0c;这个问题迎刃而解&#xff01;通过批量查询功能&#xff0c;你可以轻松管理、追踪你的中通快递单号&#xff0c;大大提高工作效率。 一、下…
阅读更多...
结构体成员 分数比较大小

结构体成员 分数比较大小

题目&#xff1a; 代码&#xff1a; #include <bits/stdc.h> #include<cstring>using namespace std;struct Num{double fenzi;double fenmu;char fenhao;};bool cmp(Num r1,Num r2){return r1.fenzi/r1.fenmu<r2.fenzi/r2.fenmu;}int main(){int n;Num num[n…
阅读更多...
基于net6的asp.net core webapi项目打包为docker镜像，并推送至私有镜像仓库harbor中

基于net6的asp.net core webapi项目打包为docker镜像，并推送至私有镜像仓库harbor中

基于net6的asp.net core webapi项目打包为docker镜像&#xff0c;并推送至私有镜像仓库harbor中 0、环境说明1、打包步骤1.1 创建Asp.net core WebApi项目1.2 在Asp.net core WebApi项目根目录下创建Dockerfile文件1.3 在子系统Ubuntu20.04.4中通过docker build生成docker镜像1…
阅读更多...
游戏测试大揭秘，帮你轻松过关

游戏测试大揭秘，帮你轻松过关

游戏测试可以看作是软件测试的一个分支&#xff0c;黑盒测试最基本的要求是会玩游戏。小公司会要求测试能力更加全面的员工&#xff0c;其中除了功能测试还要会性能测试&#xff0c;兼容测试&#xff0c;弱网测试&#xff0c;自动化测试等。 游戏测试是游戏开发过程中必不可少…
阅读更多...
vue2-手写轮播图

vue2-手写轮播图

轮播图5长展示&#xff0c;点击指示器向右移动一个图片&#xff0c;每隔2秒移动一张照片&#xff01; <template><div class"top-app"><div class"carousel-container"><div class"carousel" ref"carousel">&…
阅读更多...
Tensorflow2.0笔记 - 修改形状和维度

Tensorflow2.0笔记 - 修改形状和维度

本次笔记主要使用reshape&#xff0c;transpose&#xff0c;expand_dim&#xff0c;和squeeze对tensor的形状和维度进行操作。 import tensorflow as tf import numpy as nptf.__version__#tensor的shape和维数获取 #假设下面这个tensor表示4张28*28*3的图片 tensor tf.rando…
阅读更多...
RAG 详解

RAG 详解

原文&#xff1a;GitHub - Tongji-KGLLM/RAG-Survey 目录 RAG调查 什么是RAG&#xff1f;RAG的范式 幼稚的 RAG高级 RAG模块化 RAG如何进行增强&#xff1f;RAG 还是微调&#xff1f;如何评估 RAG&#xff1f;前景 严峻的挑战多式联运扩展RAG的生态系统RAG论文清单 增强阶段 …
阅读更多...
C++多线程学习[二]:线程的传参以及传参的一些坑

C++多线程学习[二]:线程的传参以及传参的一些坑

一、线程的传参 #include<iostream> #include<thread> #include<string> using namespace std; void threadtest(int a,double b,string str) {this_thread::sleep_for(100ms);cout << a << " " << b << " " &…
阅读更多...
最新文章

Copyright @ 2022~2023