K 最近邻算法

news2024/11/24 19:40:17

K 最近邻算法

  • 简单 KNN
  • 海伦约会
  • 手写数字识别
  • KNN 算法的优缺点

K 最近邻（K-NearestNeighbor，KNN）算法，是 1967 年由 Cover T 和 Hart P 提出的一种用于分类与回归的方法。

基本原理：存在一个带标签的数据集（也称为训练集），数据集中的每一个样本与所属标签一一对应。当输入新的不带标签的样本数据（预测数据）时，新的样本数据的每个特征会与训练集中每个样本的对应特征进行相似度计算，最后提取与预测样本最相似的训练样本的标签。一般而言，我们会选择训练集中前 K 个最相似的样本数据，这就是 K 最近邻算法。

简单 KNN

假设有一个带标签的数据集，包含“打斗镜头”和“接吻镜头”两个特征，标签为“电影类型”，数据集如下表所示：

电影名称打斗镜头接吻镜头电影类型
电影11101爱情片
电影2589爱情片
电影31085动作片
电影41158动作片

现在有一个新的样本数据（101 个打斗镜头，20 个接吻镜头），该如何预测它的所属类型呢？

我们可以把打斗镜头作为 x 维度，把接吻镜头作为 y 维度，以此建立坐标系，它们的坐标关系如下图所示：

在这里插入图片描述

那我们又该如何比较新样本数据与训练集中样本数据的相似性呢？

我们可以利用它们之间的距离来表示相似度，具体可以根据以下公式：
∣ A B ∣ = ( x 1 − x 2 ) 2 + ( y 1 − y 2 ) 2 |AB| = \sqrt{{(x_1 - x_2)}^{2} + {(y_1 - y_2)}^{2}} ∣AB∣=(x1​−x2​)2+(y1​−y2​)2 ​
通过计算，我们可以得到以下结果：

  • (101, 20) -> 动作片 (108, 5) 的距离约为 16.55
  • (101, 20) -> 动作片 (115, 8) 的距离约为 18.44
  • (101, 20) -> 爱情片 (5, 89) 的距离约为 118.22
  • (101, 20) -> 爱情片 (1, 101) 的距离约为 128.69

通过计算可知，新样本数据 (101, 20) 与训练集中的样本 (108, 5) 距离最近，也就是最相似，因此我们提取样本 (108, 5) 的标签“动作片”，并将其赋给新样本数据 (101, 20)，从而预测出新样本数据的电影类型为“动作片”，这就是 KNN 模型完整的预测过程。

如果模型根据最相似的一个结果，对新样本数据进行预测，这只能说是最近邻算法，而非 K 最近邻算法。K 最近邻算法需要返回最相似的前 K 个结果，并对这 K 个结果进行概率统计，最终选取概率最高的作为最后的预测结果。

K 最近邻算法步骤如下：

  1. 计算新样本数据与训练集中每个样本数据之间的距离
  2. 按照距离递增次序对样本数据进行排列
  3. 选取前 K 个最相似的样本数据，并获取它们的标签
  4. 计算这 K 个标签的出现频率
  5. 将出现频率最高的标签作为预测结果

比如，在上述例子中，选取 K=3，按照距离递增次序排列的前三个样本分别为动作片 (108, 5)、动作片 (115, 8)、爱情片 (5, 89)，其中动作片出现的频率为 2/3，因此我们可以预测新样本数据 (101, 20) 的电影类型为“动作片”。

上述案例的代码实现：

import numpy as np
import pandas as pd


# 读取数据集，并划分特征数据和标签数据
def read_dataset():
    df = pd.read_csv(r'D:\MachineLearning\movie_type.csv')  # 读取数据集

    data = df.iloc[:, 1:]  # 获取数据集的第 2、3、4 列数据
    data = data.to_numpy()  # 将 pandas.core.frame.DataFrame 转为 numpy.ndarray

    train_data = data[:, :2]  # data 的第 1、2 列为特征数据
    labels = data[:, -1]  # data 的第 3 列为标签数据

    return train_data, labels


# 计算距离
def calculate_distance(predict_data, train_data):
    dist = np.sqrt(np.sum((predict_data - train_data) ** 2, axis=1))  # 计算新样本数据与训练集中每一个样本数据间的距离

    return dist


# 预测结果
def select_best_result(dist, labels, k):
    labels_lst = [labels[index] for index in dist.argsort()[:k]]  # 获取前 k 个最相似数据对应的标签

    # 选取前 k 个标签中出现频率最高的作为最终结果
    num_labels = {}
    num = labels_lst.count(labels_lst[0])
    num_labels[labels_lst[0]] = num
    if len(labels_lst) > 1:
        for i in range(1, len(labels_lst)):
            for j in range(i):
                if labels_lst[i] == labels_lst[j]:
                    break
            else:  # 第二个循环没有执行 break 时，会执行 else
                num = labels_lst.count(labels_lst[i])
                num_labels[labels_lst[i]] = num

    result = max(num_labels, key=num_labels.get)  # 获取字典中每个键对应的值，并将最大值对应的键返回

    return result


if __name__ == '__main__':
    predict_data = np.array([101, 20])  # 预测数据

    train_data, labels = read_dataset()  # 获取特征数据和标签数据
    train_data = train_data.astype(float)  # 将整数数组转换为浮点数组，方便后续计算

    predict_data = np.full((4, 2), predict_data)  # 将预测数据填充为跟 train_data 有相同的维度
    predict_data = predict_data.astype(float)  # 将整数数组转换为浮点数组，方便后续计算

    dist = calculate_distance(predict_data, train_data)  # 计算距离

    result = select_best_result(dist, labels, k=1)  # 选取最好的结果

    print(result)
---------
action

海伦约会

海伦女士一直使用在线约会网站寻找适合自己的约会对象，她会将接触过的人按以下方式进行分类：

  1. 没有魅力的人
  2. 魅力一般的人
  3. 魅力十足的人

海伦已经收集了一段时间的约会数据，她把这些数据存放在一个文本文件中，一共有 1000 个样本数据，每个样本数据包含以下三种特征：

  • 每年获得的飞行常客里程数
  • 玩视频游戏所消耗的时间百分比
  • 每周消费的冰淇淋公升数

数据集中存放的数据格式如下图所示：

在这里插入图片描述

我们将使用 KNN 模型对其进行分析并预测，完整代码如下所示：

import numpy as np
import pandas as pd


# 读取数据集，将数据集划分成训练集和测试集，并划分特征数据和标签数据，同时将标签进行相应转换以方便后续处理
def read_dataset():
    df = pd.read_table(r'D:\MachineLearning\dating_set.txt', header=None)  # 读取数据集，共 1000 个样本

    data = df.iloc[:, :]  # 获取数据集的第 1、2、3、4 列数据

    train_for_data = data.sample(frac=0.9)  # 从原始数据 data 中随机选择 90% 的数据作为训练集
    test_for_data = data.drop(train_for_data.index)  # 从原始数据 data 中提取剩下的 10% 数据作为测试集
    train_for_data = train_for_data.to_numpy()  # 将 pandas.core.frame.DataFrame 转为 numpy.ndarray
    test_for_data = test_for_data.to_numpy()  # 将 pandas.core.frame.DataFrame 转为 numpy.ndarray

    train_data = train_for_data[:, :3]  # train_for_data 的第 1、2、3 列为训练集的特征数据
    train_labels = train_for_data[:, -1]  # train_for_data 的第 4 列为训练集的标签数据
    test_data = test_for_data[:, :3]  # test_for_data 的第 1、2、3 列为训练集的特征数据
    test_labels = test_for_data[:, -1]  # test_for_data 的第 4 列为训练集的标签数据

    label_mapping = {'didntLike': 1, 'smallDoses': 2, 'largeDoses': 3}  # 建立能将字符串标签映射成数字标签的字典

    train_labels = np.array([label_mapping[label] for label in train_labels])  # 将字符串标签转换成数字标签
    test_labels = np.array([label_mapping[label] for label in test_labels])  # 将字符串标签转换成数字标签

    return train_data, test_data, train_labels, test_labels


# 归一化
def normalize(train_data, test_data):
    for i in range(train_data.shape[1]):
        arr = train_data[:, i]  # 一列特征数据

        max_value = arr.max()  # 最大值
        min_value = arr.min()  # 最小值
        arr = (arr - min_value) / (max_value - min_value)  # 归一化计算

        train_data[:, i] = arr

    for i in range(test_data.shape[1]):
        arr = test_data[:, i]  # 一列特征数据

        max_value = arr.max()  # 最大值
        min_value = arr.min()  # 最小值
        arr = (arr - min_value) / (max_value - min_value)  # 归一化计算

        test_data[:, i] = arr

    return train_data, test_data


# 计算距离
def calculate_distance(predict_data, train_data):
    dist = np.sqrt(np.sum((predict_data - train_data) ** 2, axis=1))  # 计算新样本数据与训练集中每一个样本数据间的距离

    return dist


# 预测结果
def select_best_result(dist, labels, k):
    labels_lst = [labels[index] for index in dist.argsort()[:k]]  # 获取前 k 个最相似数据对应的标签

    # 选取前 k 个标签中出现频率最高的作为最终结果
    num_labels = {}
    num = labels_lst.count(labels_lst[0])
    num_labels[labels_lst[0]] = num
    if len(labels_lst) > 1:
        for i in range(1, len(labels_lst)):
            for j in range(i):
                if labels_lst[i] == labels_lst[j]:
                    break
            else:  # 第二个循环没有执行 break 时，会执行 else
                num = labels_lst.count(labels_lst[i])
                num_labels[labels_lst[i]] = num

    result = max(num_labels, key=num_labels.get)  # 获取字典中每个键对应的值，并将最大值对应的键返回

    return result


# 计算错误率
def calculate_error_rate(test_result, test_labels):
    num_error = 0
    for i in range(len(test_result)):
        if test_result[i] != test_labels[i]:
            num_error += 1

    error_rate = num_error / len(test_result) * 100

    print(f'错误率为：{error_rate}%')


if __name__ == '__main__':
    train_data, test_data, train_labels, test_labels = read_dataset()  # 获取用于训练与测试的特征数据和标签数据

    train_data, test_data = normalize(train_data, test_data)  # 将用于训练与测试的特征数据归一化
    train_data = train_data.astype(float)
    test_data = test_data.astype(float)

    num_samples = train_data.shape[0]  # 训练集中的样本个数（行数）
    num_features = train_data.shape[1]  # 训练集中的特征个数（列数）

    test_result = []
    for i in range(len(test_data)):
        predict_data = np.full((num_samples, num_features), test_data[i])  # 将测试数据集中的一个样本填充为跟 train_data 有相同的维度
        predict_data = predict_data.astype(float)

        dist = calculate_distance(predict_data, train_data)  # 计算距离

        result = select_best_result(dist, train_labels, k=1)  # 选取最好的结果

        test_result.append(result)

    test_result = np.array(test_result)

    calculate_error_rate(test_result, test_labels)  # 计算测试集的错误率
---------
错误率为：6.0%

手写数字识别

scikit learn 简称 sklearn，是 Python 的一个第三方库，里面包含了很多机器学习的方法，借助 sklearn，我们可以很快地实现一个机器学习算法。

sklearn.neighbors 模块实现了 KNN 算法，其函数实现如下所示：

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)
	- n_neighbors：参数 k 的值，默认为 5
    - weights：参数值可以是 uniform、distance 或用户自定义的函数，默认为 uniform；uniform 表示均等的权重，即所有邻近点的权重都是相等的；distance 表示不均等的权重，距离近的点要比距离远的点的影响大；用户自定义的函数接收距离数组，并返回维数相同的权重
    - algorithm：用于计算最近邻的算法，默认使用 auto 方式，即根据传递给拟合方法的值决定最合适的算法；除此外，还可以指定 ball_tree、kd_tree、brute 等方式进行最近邻的计算；brute 是暴力搜索，当训练集很大时，计算非常耗时；kd_tree 是数据结构中的二叉树，构造的 kd 树可以方便地对存储数据进行快速检索，在数据维度小于 20 时效率高；ball_tree 是为了克服 kd 树高维失效而构建的，其以质心和半径分割样本空间，每个节点都是一个超球体
    - leaf_size：传递给 ball_tree 或 kd_tree 的大小，默认为 30；该参数的设置会影响树的构建速度、查询速度以及存储树所需的内存，最佳取值取决于问题的性质
    - p：闵可夫斯基距离度量的幂参数，当 p=1 时，相当于使用曼哈顿距离 l1；当 p=2 时，相当于使用欧几里得距离 l2；对于任意 p 值，则使用闵可夫斯基距离（minkowski distance）
    - metric：距离度量，默认为 minkowski；闵可夫斯基距离也被称为闵式距离，它将多个距离公式（曼哈顿距离、欧式距离、切比雪夫距离）总结成了一个公式
    - metric_params：距离公式的其他关键参数，这个可以不管，使用默认的 None 即可
    - n_jobs：搜索邻近点时的并行工作数，默认为 1；如果为 -1，则表示 CPU 的所有 Cores 都用于并行工作

由 KNeighborsClassifier 创建的实例对象 neigh 具有以下方法：

fit(X, y)  # 根据训练集拟合 k 近邻分类器
	- X：训练数据，形状为 (n_samples, n_features)
    - y：目标值（训练样本对应的标签），形状为 (n_samples,)
    返回拟合的 k 近邻分类器
    
get_params(deep=True)  # 以字典形式返回 KNeighborsClassifier 类的参数
	- deep：布尔值，默认为 True
    返回 {'algorithm': 'auto', 'leaf_size': 30, 'metric': 'minkowski', 'metric_params': None, 'n_jobs': None, 'n_neighbors': 3, 'p': 2, 'weights': 'uniform'}
    
kneighbors(X=None, n_neighbors=None, return_distance=True)  # 给定一个样本和一个查询集，查找该样本在查询集中的 k 个近邻
	- X：训练数据或者说是查询数据，形状为 (n_samples, n_features)
    - n_neighbors：查找的近邻数量 k，默认值为传给构造函数的值
    - return_distance：布尔值，表示是否返回距离，默认为 True
    返回形状为 (n_samples, n_features) 的距离（当 return_distance=True 时才会返回）以及对应的形状为 (n_samples, n_features) 的索引
    
predict(X)  # 预测所提供数据的类别标签
	- X：预测数据，形状为 (n_samples, n_features)
    以 np.ndarray 形式返回形状为 (n_samples,) 的每个数据样本的类别标签
    
predict_proba(X)  # 返回预测数据 X 在各类别标签中所占的概率
	- X：预测数据，形状为 (n_samples, n_features)
    返回该样本在各类别标签中的预测概率，类别标签按词典顺序排列；比如对于 [1. 0. 0. 0. 0. 0. 0. 0. 0. 0.] 这个结果，样本识别为数字 0 的概率为 1，类别标签从 0 到 9 依次排列
    
score(X, y, sample_weight=None)  # 返回预测结果和标签之间的平均准确率
	- X：预测数据，形状为 (n_samples, n_features)
    - y：预测数据的目标值（真实标签）
    - sample_weight：默认为 None
    返回预测数据的平均准确率，相当于先执行了 self.predict(X)，而后再计算预测值和真实值之间的平均准确率

我们知道手写数字图像是大小为 32×32 的二进制图像，为了方便计算，我们可以将其转换为 1×1024 的向量。在 KNeighborsClassifier 函数中，输入可以是矩阵，不过为了跟自己写的 KNN 算法对应上，这里也做了向量化处理。完整的手写数字识别 KNN 模型代码实现如下：

import os
import numpy as np
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier


# 将 (32, 32) 的矩阵转换成 (1, 1024) 的向量
def mat_to_vector(file: str) -> np.ndarray:
    df = pd.read_table(file, header=None)
    df = df.to_numpy()
    vec = np.zeros((1, df.shape[0] * df.shape[0]))  # (1, 1024)

    with open(file, 'r') as f:
        rows = f.readlines()  # 读取文件中的所有行，并以列表形式返回
        for i in range(len(rows)):
            row = rows[i].strip()  # 读取列表中的一个字符串元素
            columns = [int(row[i:i+1]) for i in range(len(row))]  # 将字符串分割成单个数字，并以列表形式返回
            for j in range(len(columns)):
                vec[0, 32 * i + j] = int(columns[j])  # 将每一个数字赋值给向量 vec 对应的位置

    return vec


# 读取训练集
def read_train_dataset(path: str) -> (np.ndarray, np.ndarray):
    train_labels = []  # 用于存储手写数字图像对应的数字标签

    train_files = os.listdir(path)  # 读取所有二进制图像文件，并以列表形式返回
    df = pd.read_table(os.path.join(path, train_files[0]), header=None)
    df = df.to_numpy()
    m = len(train_files)  # 1934
    train_mat = np.zeros((m, df.shape[0] * df.shape[0]))  # (1934, 1024)

    for i in range(m):
        train_file_name = train_files[i]
        digit = int(train_file_name.split('_')[0])
        train_labels.append(digit)  # 将每一个图像文件对应的数字标签存储到列表
        train_mat[i, :] = mat_to_vector(os.path.join(path, train_files[i]))  # 将每一个 (1, 1024) 的二进制图像数据赋值到矩阵

    train_labels = np.array(train_labels)

    return train_mat, train_labels


# 读取测试集
def read_test_dataset(path: str) -> (np.ndarray, np.ndarray):
    test_labels = []  # 用于存储手写数字图像对应的数字标签

    test_files = os.listdir(path)  # 读取所有二进制图像文件，并以列表形式返回
    df = pd.read_table(os.path.join(path, test_files[0]), header=None)
    df = df.to_numpy()
    m = len(test_files)  # 946
    test_mat = np.zeros((m, df.shape[0] * df.shape[0]))  # (946, 1024)

    for i in range(m):
        test_file_name = test_files[i]
        digit = int(test_file_name.split('_')[0])
        test_labels.append(digit)  # 将每一个图像文件对应的数字标签存储到列表
        test_mat[i, :] = mat_to_vector(os.path.join(path, test_files[i]))  # 将每一个 (1, 1024) 的二进制图像数据赋值到矩阵

    test_labels = np.array(test_labels)

    return test_mat, test_labels


# 构建 KNN 模型
def knn_model(train_data: np.ndarray, train_labels: list) -> object:
    neigh = KNeighborsClassifier(n_neighbors=3)
    neigh.fit(train_data, train_labels)

    return neigh


if __name__ == '__main__':
    train_path = r'D:\MachineLearning\trainingDigits'
    test_path = r'D:\MachineLearning\testDigits'

    train_data, train_labels = read_train_dataset(train_path)  # 读取训练数据，并返回训练集和对应标签

    neigh = knn_model(train_data, train_labels)  # 构建 KNN 模型，并返回 KNN 对象

    test_data, test_labels = read_test_dataset(test_path)  # 读取测试数据，并返回测试集和对应标签

    result = neigh.predict(test_data)  # 预测结果，并以 np.ndarray 形式返回

    result_lst = (result - test_labels).tolist()  # 将数组转成列表

    error_rate = (len(result_lst) - result_lst.count(0)) / len(result_lst) * 100  # 计算错误率

    print(f'错误率为：{error_rate}%')

训练集和测试集的文件格式如下图所示，第一个数字为该二进制图像文件对应的数字标签：

在这里插入图片描述

文件中存储的数据格式如下图所示：

在这里插入图片描述

KNN 算法的优缺点

优点

  1. 简单直观：KNN 是一种非参数化算法，不需要假设数据的分布情况。它通过比较实例之间的距离来进行分类或回归，易于理解和实现。
  2. 适用于多类别问题：KNN 可以处理多类别问题，不受类别数量的限制。
  3. 对异常值不敏感：由于 KNN 根据最近的邻居进行分类或回归，异常值对结果的影响较小。
  4. 模型可以随时更新：当新的训练样本加入时，可以很容易地对模型进行更新，而无需重新进行训练。

缺点

  1. 高计算复杂度：在预测时，需要计算测试样本与所有训练样本之间的距离，因此随着训练集规模的增大，计算复杂度也会增加。这可能导致 KNN 在大型数据集上的效率低下。
  2. 对特征尺度敏感：如果特征之间的尺度差异很大，那么在计算距离时，尺度较大的特征会主导结果，从而忽略了其他特征的影响。因此，在使用 KNN 之前，需要对数据进行特征缩放。
  3. 需要确定 K 值：KNN 算法中的 K 值表示选择多少个最近邻居来进行决策。选择不同的 K 值可能会对结果产生不同的影响，而且没有明确的准则可以确定最佳的 K 值，需要通过交叉验证或其他方法进行调优。
  4. 类别不平衡问题：当训练集中某个类别的样本数远远多于其他类别时，KNN 可能会偏向于占主导地位的类别。

综上所述，KNN 算法简单直观，对异常值不敏感，适用于多类别问题，并且可以随时更新模型。然而，它的计算复杂度高，对特征尺度敏感，需要确定 K 值，并且对类别不平衡问题比较敏感。在实际应用中，需要权衡这些因素并根据具体问题的特点选择合适的机器学习算法。

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

用二维码展示产品信息，轻松解决产品宣传难题

用二维码展示产品信息，轻松解决产品宣传难题

为了方便客户更好的了解产品，提升产品宣传效率，可以搭建产品信息二维码系统。为每一类产品生成一个二维码，上传文字、图片、音视频等内容，将二维码印刷在产品外包装、画册、样品卡或说明书上，用户使用微信扫码就能查看…
阅读更多...
4G自动变焦云台球机摄像头如何解决低功耗问题？

4G自动变焦云台球机摄像头如何解决低功耗问题？

目前也很多4G球机，不过对于工业的应用，可能还需要有针对性的球机方案？ 比如,大家关心的功耗问题，在无电无网的情况下，偏远山区，对于一些油田的管控，输线电路可视化监控，天然气管道的…
阅读更多...
怎么快速制作一本出色的电子期刊！

怎么快速制作一本出色的电子期刊！

比起传统纸质期刊，电子期刊有着众多的优势，它打破了以往的传播形式和人们传统的时空观念，从而更加贴近人们的生活，更好地满足新时代人们对文化生活的更高要求。如何制作电子期刊呢？ 其实很简单，只需要使用…
阅读更多...
动态规划背包问题总结

动态规划背包问题总结

背包问题分类繁多,对刚学习动态规划的新手的来说难度不小,接下来就来仔细理一理背包问题 首先我们先不管背包问题有几种分类,反正讲了也不会有什么深刻的认识,只有你真正做题遇到了,你来能感受到他大概是怎么样的 回到最初的起点,我们需要搞明白的是: 什么是背包问题? 我们…
阅读更多...
扩散模型实战（十三）：ControlNet结构以及训练过程

扩散模型实战（十三）：ControlNet结构以及训练过程

推荐阅读列表： 扩散模型实战（一）：基本原理介绍 扩散模型实战（二）：扩散模型的发展 扩散模型实战（三）：扩散模型的应用 扩散模型实战（四&#xff…
阅读更多...
Android : 获取、添加、手机联系人-ContentResolver简单应用

Android : 获取、添加、手机联系人-ContentResolver简单应用

示例图： MainActivity.java package com.example.mygetdata;import androidx.annotation.NonNull; import androidx.appcompat.app.AppCompatActivity; import androidx.core.app.ActivityCompat; import androidx.core.content.ContextCompat;import android.Mani…
阅读更多...
vue项目通过HBuilder打包成apk，实现apk自动更新下载

vue项目通过HBuilder打包成apk，实现apk自动更新下载

vue 项目通过 HBuilder 打包成 apk，实现 apk 自动更新下载 1、vue 项目通过 HBuilder 打包成 apk vue 项目在终端执行 npm run build 打包成 dist 文件，生成的 dist 文件在 项目根目录下 在 HBuilder 中 新建一个项目 默认选择 5APP 的默认模板项目…
阅读更多...
【多属性对象“{a:1,b:2}”】与【单属性对象的数组“[{a:1},{b:2}]”】的相互转换

【多属性对象“{a:1,b:2}”】与【单属性对象的数组“[{a:1},{b:2}]”】的相互转换

前端开发的某些场景（比如用echarts开发某些可视化图表）经常需要将【多属性对象，如“{a:1,b:2}”】与【单属性对象的数组，如“[{a:1},{b:2}]”】做相互转换，以下是不通过循环，简洁实现这种转换的方法&#x…
阅读更多...
广州华锐互动：线上3D低碳环保主题展厅，沉浸式体验有助于培养环保意识

广州华锐互动：线上3D低碳环保主题展厅，沉浸式体验有助于培养环保意识

随着科技的飞速发展，环保已经成为了全球关注的焦点。为了让更多的人了解环保科技的重要性，许多城市都建立了线上3D低碳环保主题展厅。这些展馆通过虚拟现实技术，让人们身临其境地感受到环保科技的魅力，从而提高人们的环保意识。 线…
阅读更多...
卡码网语言基础课 | 14. 链表的基础操作Ⅱ

卡码网语言基础课 | 14. 链表的基础操作Ⅱ

题目： 构建一个单向链表，链表中包含一组整数数据，输出链表中的第 m 个元素（m 从 1 开始计数）。 要求： 1. 使用自定义的链表数据结构 2. 提供一个 linkedList 类来管理链表，包含构建链表、输出…
阅读更多...
自动标注好用吗？基于SAM和Label Studio搭建半自动实例分割标注平台

自动标注好用吗？基于SAM和Label Studio搭建半自动实例分割标注平台

文章目录 一、半自动标注二、缺点三、安装方法1、 python版本要求2、下载playground3、SAM安装4、SAM权重下载5、安装label-studio-ml6、启动SAM接口7、SAM启动日志8、安装并启动label-studio9、label-studio启动日志 四、半自动标注使用方法1、创建project并导入数据2、标签设…
阅读更多...
多元系的复相平衡

多元系的复相平衡

多元系的复相平衡 多元系的吉布斯函数 G-{T,p,n}系统 吉布斯关系 多元系的热力学基本方程
阅读更多...
使用Three.js创建导航立方体

使用Three.js创建导航立方体

什么是导航立方体？ 导航立方体是一个交互式的3D控件，它允许用户通过点击和拖动立方体的各个面来改变3D视图的方向。这是一种非常直观的方式，让用户能够轻松地在3D空间中导航。 创建导航立方体 下面是一个基本的步骤，说明如何使用Three.js创建一个导航立方体： // 创建场景…
阅读更多...
ICCV 2023 | 动态蛇形卷积（内含即插即用的代码及测试用例）

ICCV 2023 | 动态蛇形卷积（内含即插即用的代码及测试用例）

论文链接： https://arxiv.org/abs/2307.08388 代码链接： https://github.com/YaoleiQi/DSCNet 下面直接上代码，并且源码中也给了测试用例，是一个即插即用的模块 import os import torch import numpy as np from torch impor…
阅读更多...
怎么做excel表格的二维码？文件快速做二维码的教程

怎么做excel表格的二维码？文件快速做二维码的教程

Excel表格怎么做成二维码来扫码插看呢？Excel是工作中常用的一种文件格式，想要将表格内容分享给其他人查看，那么将表格生成二维码的方法会更加的方便快捷，其他人只需要扫描二维码就可以查看或者下载文件。表格excel二维码可以通过文…
阅读更多...
Rust语言入门教程(六) - 字符串类型

Rust语言入门教程(六) - 字符串类型

在Rust中， 字符串类型其实是一个比较复杂的话题。在Rust的标准库中，至少都提供了6种字符串类型，我们平常使用的最多的是其中的两种。这两种类型互相之间也有所关联： str： 字符串切片String 字符串 其中， 字…
阅读更多...
细说数据仓库上篇

细说数据仓库上篇

在谈数仓之前，先来看下面几个问题： 数仓为什么要分层？ 用空间换时间，通过大量的预处理来提升应用系统的用户体验（效率），因此数据仓库会存在大量冗余的数据；不分层的话，…
阅读更多...
高效运维管理的7个要点

高效运维管理的7个要点

T管理和运维工作涵盖了各行业的各岗位中，如何提高工作效率，规避风险，更好的做好IT管理和运维工作，已经成为一个不断探索和研究的新兴课题。因此，应从两个层面加强和完善IT管理和运维工作，可以改善IT运维工作…
阅读更多...
为什么要编写测试用例，自己知道不就行了吗

为什么要编写测试用例，自己知道不就行了吗

“为什么要编写测试用例，测试用例写给谁看”，这个问题看似简单，但却涵盖了一系列复杂的考虑因素，并不太好回答。 为了向各位学测试的同学们解释清楚“为什么编写测试用例是至关重要的”，我将通过以下5个方面进行展开&…
阅读更多...
MySQL-05-MySQL的日志系统

MySQL-05-MySQL的日志系统

1-redo log(重做日志) 在MySQL里也有这个问题，如果每一次的更新操作都需要写进磁盘，然后磁盘也要找到对应的那条记录，然后再更新，整个过程IO成本、查找成本都很高。MySQL里经常说到的WAL技术，WAL的全称是Write-Ahead L…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023