Numba加速计算：最近邻插值（CPU+ GPU + Z轴切块 + XYZ轴切块 + 多线程）

文章目录

  • 最近邻插值（加速方法）
    • （1）scipy.ndimage.zoom
    • （2）Numba-CPU加速
    • （3）Numba-GPU加速
    • （4）Numba-CPU加速（Z轴切块）
    • （5）Numba-CPU加速（XYZ轴切块）
    • （6）Numba-CPU加速（XYZ轴切块）+ 多线程

在这里插入图片描述

输入数据插值倍数时耗
scipy.ndimage.zoom(1024, 1024, 512)4172.16s
Numba-CPU(1024, 1024, 512)456.58s
Numba-GPU(1024, 1024, 512)4122.51s
Numba-CPU（Z轴切块）(1024, 1024, 512)452.44
Numba-CPU（XYZ轴切块）(1024, 1024, 512)472.69s
Numba-CPU（XYZ轴切块）+ 多线程(1024, 1024, 512)450.20s

为什么使用 GPU 反而更慢了：

  • （1）数据传输开销：GPU 的计算速度快，但数据在 CPU 和 GPU 之间传输时会有较大的开销。
  • （2）任务并行性不高：GPU 适合大规模并行计算，如果任务的并行性不够高，比如 Z 轴切块后的任务处理，GPU 的潜力可能无法得到充分发挥。相比之下，CPU 在处理较小规模任务时可能表现得更有效率。
  • （3）专用 GPU 内存不足，自动转共享 GPU 内存（时耗增加）。

最近邻插值（加速方法）

（1）scipy.ndimage.zoom

from scipy.ndimage import zoom
import time
import numpy as npif __name__ == "__main__":# （1）创建数组input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)input_data[50:600, 200:1000, 5:30] = 1# （2）插值计算start_time = time.time()#############################################################zoom_factor = [2, 2, 2]  # 指定插值因子   output_data = zoom(input_data, zoom_factor, order=0)#############################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))print("原始数据:", input_data.shape)print("插值结果:", output_data.shape)"""
##### 插值两倍 #####
计算时间: 21.160449504852295
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 88000000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)##### 插值四倍 #####
计算时间: 172.16581082344055
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 704760200
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（2）Numba-CPU加速

import numba
import numpy as np@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_data):"""最近邻插值算法输入参数：3D图像 + 插值因子 + 预分配的输出数据"""# 对目标数组中的每个点进行插值for z in range(output_data.shape[0]):zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)  # round四舍五入可能会超出数据边界的值for y in range(output_data.shape[1]):yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)  # round四舍五入可能会超出数据边界的值for x in range(output_data.shape[2]):# 计算在原始数据中的对应位置，并限制在原始数据范围内xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)  # round四舍五入可能会超出数据边界的值output_data[z, y, x] = input_data[zz, yy, xx]  # 最近邻插值return output_dataif __name__ == "__main__":# （1）创建数组input_data = np.zeros((1024, 1024, int(1024*0.5)), dtype=bool)  # 创建3D数组input_data[50:600, 200:1000, 5:30] = 1# （2）插值计算import timestart_time = time.time()############################################################## 计算目标形状并创建目标数组output_shape = np.round(np.array(input_data.shape) * np.array(scale_factors)).astype(int)output_data = np.zeros(output_shape, dtype=input_data.dtype)scale_factors = [4, 4, 4]  # 指定插值因子nearest_neighbor_interpolation(input_data, scale_factors, output_data)  # 执行3D最近邻插值#############################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))print("原始数据:", input_data.shape)print("插值结果:", output_data.shape)"""
##### 插值两倍 #####
计算时间: 7.694857835769653
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86240000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)##### 插值四倍 #####
计算时间: 56.58441758155823
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 696960000
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（3）Numba-GPU加速

import numpy as np
from numba import cuda@cuda.jit
def nearest_neighbor_interpolation_gpu(input_data, output_data, scale_factors):"""最近邻插值的CUDA版本"""z, y, x = cuda.grid(3)  # 获取3D网格中线程的位置 (z, y, x)if z < output_data.shape[0] and y < output_data.shape[1] and x < output_data.shape[2]:zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)output_data[z, y, x] = input_data[zz, yy, xx]def gpu_nearest_neighbor_interpolation(input_data, scale_factors):# 创建目标数组的形状output_shape = np.round(input_data.shape * scale_factors).astype(int)output_data = np.zeros(output_shape, dtype=input_data.dtype)# 将输入数据从CPU上传到GPUinput_data_gpu = cuda.to_device(input_data)output_data_gpu = cuda.to_device(output_data)######################################################################## 定义线程和块的大小threads_per_block = (16, 16, 4)blocks_per_grid = ((output_shape[0] + threads_per_block[0] - 1) // threads_per_block[0],(output_shape[1] + threads_per_block[1] - 1) // threads_per_block[1],(output_shape[2] + threads_per_block[2] - 1) // threads_per_block[2])# 执行CUDA核函数nearest_neighbor_interpolation_gpu[blocks_per_grid, threads_per_block](input_data_gpu, output_data_gpu, scale_factors)######################################################################## 将结果从GPU下载回CPUoutput_data = output_data_gpu.copy_to_host()return output_dataif __name__ == "__main__":# （1）创建3D数组input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)input_data[50:600, 200:1000, 5:30] = 1# （2）执行插值import timestart_time = time.time()#######################################################################scale_factors = np.array([4, 4, 4])  # 指定插值因子output_data = gpu_nearest_neighbor_interpolation(input_data, scale_factors)#######################################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))print("原始数据:", input_data.shape)print("插值结果:", output_data.shape)"""
##### 插值两倍 #####
计算时间: 3.6601688861846924
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86240000
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)##### 插值四倍 #####
计算时间: 122.51327633857727
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 696960000
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（4）Numba-CPU加速（Z轴切块）

import numba
import numpy as np@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):# 对目标数组中的每个点进行插值for z in range(output_block.shape[0]):zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)for y in range(output_block.shape[1]):yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)for x in range(output_block.shape[2]):# 计算在原始数据中的对应位置，并限制在原始数据范围内xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)output_block[z, y, x] = input_data[zz, yy, xx]  # 最近邻插值return output_blockdef segment_blocks(input_data, block_size, scale_factors):num_blocks = int(np.ceil(input_data.shape[0] / block_size))print("切块数量 =", num_blocks)zoomed_blocks = []for i in range(num_blocks):start_idx = i * block_sizeend_idx = min((i + 1) * block_size, input_data.shape[0])block = input_data[start_idx:end_idx, :, :]##########################################################################output_shape = np.round(np.array(block.shape) * scale_factors).astype(int)  # 计算目标形状output_block = np.zeros(output_shape, dtype=block.dtype)  # 创建目标形状的数组zoomed_block = nearest_neighbor_interpolation(block, scale_factors, output_block)# zoomed_block = scipy.ndimage.zoom(block, zoom_factor, order=1)##########################################################################zoomed_blocks.append(zoomed_block)output_data = np.concatenate(zoomed_blocks, axis=0)  # 沿着第一个轴进行拼接得到合并结果return output_dataif __name__ == "__main__":input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)  # 创建一个示例的3D数组input_data[50:600, 200:1000, 5:30] = 1import timestart_time = time.time()###############################################################scale_factors = np.array([4, 4, 4])  # 指定插值因子block_size = 100  # 切割小块的Z轴尺度，会自动分配并处理越界问题（切块数量 = input_data[0] / block_size）output_data = segment_blocks(input_data, block_size, scale_factors)  # 分块插值##########################################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))print("原始数据:", input_data.shape)print("插值结果:", output_data.shape)"""
##### 插值两倍 #####
切块数量 = 11
总共耗时: 6.803957223892212
Non-zero Count: 11000000
Non-zero Count: 86318400
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)##### 插值四倍 #####
切块数量 = 11
计算时间: 52.44191575050354
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 697593600
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（5）Numba-CPU加速（XYZ轴切块）

import numba
import numpy as np@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):for z in range(output_block.shape[0]):zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)for y in range(output_block.shape[1]):yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)for x in range(output_block.shape[2]):xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)output_block[z, y, x] = input_data[zz, yy, xx]return output_blockdef segment_blocks(input_data, block_sizes, scale_factors):num_blocks_z = int(np.ceil(input_data.shape[0] / block_sizes[0]))num_blocks_y = int(np.ceil(input_data.shape[1] / block_sizes[1]))num_blocks_x = int(np.ceil(input_data.shape[2] / block_sizes[2]))zoomed_blocks_zz = []for z in range(num_blocks_z):start_z = z * block_sizes[0]end_z = min((z + 1) * block_sizes[0], input_data.shape[0])zoomed_blocks_yy = []for y in range(num_blocks_y):start_y = y * block_sizes[1]end_y = min((y + 1) * block_sizes[1], input_data.shape[1])zoomed_blocks_xx = []for x in range(num_blocks_x):start_x = x * block_sizes[2]end_x = min((x + 1) * block_sizes[2], input_data.shape[2])block = input_data[start_z:end_z, start_y:end_y, start_x:end_x]print(f"{num_blocks_z, num_blocks_y, num_blocks_x}/{z + 1, y + 1, x + 1}", "block.shape =", block.shape)##########################################################################output_shape = np.round(block.shape * scale_factors).astype(int)output_block = np.zeros(output_shape, dtype=block.dtype)zoomed_block_x = nearest_neighbor_interpolation(block, scale_factors, output_block)##########################################################################zoomed_blocks_xx.append(zoomed_block_x)zoomed_block_y = np.concatenate(zoomed_blocks_xx, axis=2)  # 沿着X轴拼接zoomed_blocks_yy.append(zoomed_block_y)zoomed_block_z = np.concatenate(zoomed_blocks_yy, axis=1)  # 沿着Y轴拼接zoomed_blocks_zz.append(zoomed_block_z)zoomed_block = np.concatenate(zoomed_blocks_zz, axis=0)  # 沿着Z轴拼接print("切块数量 =", num_blocks_z * num_blocks_y * num_blocks_x)return zoomed_blockif __name__ == "__main__":input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)input_data[50:600, 200:1000, 5:30] = 1import timestart_time = time.time()##########################################################################scale_factors = np.array([4, 4, 4])block_sizes = (100, 100, 100)  # 小块的尺度，沿着z轴、y轴、x轴zoomed_block = segment_blocks(input_data, block_sizes, scale_factors)##########################################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))print("获取非零元素的数量（输出）:", np.count_nonzero(zoomed_block))print("原始数据:", input_data.shape)print("插值结果:", zoomed_block.shape)"""
##### 插值两倍 #####
切块数量 = 726
计算时间: 9.834398746490479
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 86318400
原始数据: (1024, 1024, 512)
插值结果: (2048, 2048, 1024)##### 插值四倍 #####
切块数量 = 726
计算时间: 72.6902551651001
获取非零元素的数量（输入）: 11000000
获取非零元素的数量（输出）: 697593600
原始数据: (1024, 1024, 512)
插值结果: (4096, 4096, 2048)
"""

（6）Numba-CPU加速（XYZ轴切块）+ 多线程

import numba
import numpy as np
import concurrent.futures@numba.jit()
def nearest_neighbor_interpolation(input_data, scale_factors, output_block):for z in range(output_block.shape[0]):zz = min(round(z / scale_factors[0]), input_data.shape[0] - 1)for y in range(output_block.shape[1]):yy = min(round(y / scale_factors[1]), input_data.shape[1] - 1)for x in range(output_block.shape[2]):xx = min(round(x / scale_factors[2]), input_data.shape[2] - 1)output_block[z, y, x] = input_data[zz, yy, xx]return output_blockdef process_block(block, scale_factors):output_shape = np.round(block.shape * scale_factors).astype(int)output_block = np.zeros(output_shape, dtype=block.dtype)zoomed_block = nearest_neighbor_interpolation(block, scale_factors, output_block)return zoomed_blockdef segment_blocks(input_data, block_sizes, scale_factors):num_blocks_z = int(np.ceil(input_data.shape[0] / block_sizes[0]))num_blocks_y = int(np.ceil(input_data.shape[1] / block_sizes[1]))num_blocks_x = int(np.ceil(input_data.shape[2] / block_sizes[2]))zoomed_blocks = []with concurrent.futures.ThreadPoolExecutor() as executor:futures = []for z in range(num_blocks_z):start_z = z * block_sizes[0]end_z = min((z + 1) * block_sizes[0], input_data.shape[0])for y in range(num_blocks_y):start_y = y * block_sizes[1]end_y = min((y + 1) * block_sizes[1], input_data.shape[1])for x in range(num_blocks_x):start_x = x * block_sizes[2]end_x = min((x + 1) * block_sizes[2], input_data.shape[2])##########################################################################block = input_data[start_z:end_z, start_y:end_y, start_x:end_x]futures.append(executor.submit(process_block, block, scale_factors))########################################################################### for future in concurrent.futures.as_completed(futures):#     zoomed_blocks.append(future.result())print("切块数量 =", num_blocks_z * num_blocks_y * num_blocks_x)return zoomed_blocksif __name__ == "__main__":input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)input_data[50:600, 200:1000, 5:30] = 1import timestart_time = time.time()##########################################################################scale_factors = np.array([4, 4, 4])block_sizes = (100, 100, 100)  # 小块的尺度，沿着z轴、y轴、x轴output_data = segment_blocks(input_data, block_sizes, scale_factors)##########################################################################print("计算时间:", time.time() - start_time)print("获取非零元素的数量（输入）:", np.count_nonzero(input_data))# print("获取非零元素的数量（输出）:", np.count_nonzero(output_data))print("原始数据:", input_data.shape)# print("插值结果:", output_data.shape)"""
##### 插值两倍 #####
切块数量 = 726
计算时间: 6.778625011444092
获取非零元素的数量（输入）: 11000000
原始数据: (1024, 1024, 512)##### 插值四倍 #####
切块数量 = 726
计算时间: 50.20111918449402
获取非零元素的数量（输入）: 11000000
原始数据: (1024, 1024, 512)
"""

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

分类预测|基于贝叶斯优化长短期记忆网络的数据分类预测Matlab程序 多特征输入多类别输出 BO-LSTM 附赠预测新数据

分类预测|基于贝叶斯优化长短期记忆网络的数据分类预测Matlab程序 多特征输入多类别输出 BO-LSTM 附赠预测新数据

分类预测|基于贝叶斯优化长短期记忆网络的数据分类预测Matlab程序 多特征输入多类别输出 BO-LSTM 附赠预测新数据 文章目录 一、基本原理BO-LSTM分类预测原理和流程总结 二、实验结果三、核心代码四、代码获取五、总结 分类预测|基于贝叶斯优化长短期记忆网络的数据分类预测Mat…
阅读更多...
利用zabbix监控ogg进程(Windows平台)

利用zabbix监控ogg进程(Windows平台)

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:Linux运维老纪的首页…
阅读更多...
QT：音视频播放器

QT：音视频播放器

目录 一.播放器设计 二.需要使用的控件 三.选择视频 四.播放视频 五.暂停视频 六.关闭视频 七.播放状态设置 八.切换视频(上一首) 九.切换视频(下一首) 十.设置视频滑块 十一.更新滑块显示 十二.实现效果 十三.代码设计 1.mainwindow.h 2.mainwindow.cpp 一.播放…
阅读更多...
Windows上安装RabbitMQ

Windows上安装RabbitMQ

rabbitmq是干嘛的我就不介绍了&#xff0c;直接开始安装教程。 搭建成功演示图 下载安装包 https://pan.baidu.com/s/1ZlCFxh9Q00ynSU3ZCpTC9Q?pwdry51​pan.baidu.com/s/1ZlCFxh9Q00ynSU3ZCpTC9Q?pwdry51 下载完后有两个包(erlang和rabbitmq) 先安装otp_win64_24.1.7.exe…
阅读更多...
wifiip地址可以随便改吗？wifi的ip地址怎么改变

wifiip地址可以随便改吗？wifi的ip地址怎么改变

对于普通用户来说&#xff0c;WiFi IP地址的管理和修改往往显得神秘而复杂。本文旨在深入探讨WiFi IP地址是否可以随意更改&#xff0c;以及如何正确地改变WiFi的IP地址。虎观代理小二将详细解释WiFi IP地址的基本概念、作用以及更改时需要注意的事项&#xff0c;帮助用户更好地…
阅读更多...
使用ShardingSphere实现MySql的分库分表

使用ShardingSphere实现MySql的分库分表

目录 一 什么是ShardingSphere分库分表 二 代码实现 1.导入相关依赖 2.配置相关参数 3.创建学生类以及mapper接口 4.实现 StandardShardingAlgorithm接口自定义分片算法 唐洋洋我知道你在看!!!嘿嘿 一 什么是ShardingSphere分库分表 我们平时在设计数据库的时候&#xf…
阅读更多...
2-92 基于matlab的KPCA的TE过程的故障监测

2-92 基于matlab的KPCA的TE过程的故障监测

基于matlab的KPCA的TE过程的故障监测&#xff0c;利用核主元分析法(KPCA)来进行故障检测的思想,将输入空间中复杂的非线性问题转化为特征空间中的线性问题&#xff0c;计算步骤&#xff1a;&#xff08;1&#xff09; 选择监控变量&#xff0c;收集正常工况下的各变量的样本&am…
阅读更多...
移动订货小程序哪个好 批发订货系统源码哪个好

移动订货小程序哪个好 批发订货系统源码哪个好

订货小程序就是依托微信小程序的订货系统&#xff0c;微信小程序订货系统相较于其他终端的订货方式&#xff0c;能够更快进入商城&#xff0c;对经销商而言更为方便。今天&#xff0c;我们一起盘点三个主流的移动订货小程序&#xff0c;看看哪个移动订货小程序好。 第一、核货宝…
阅读更多...
无线麦克风哪款好用，手机领夹麦克风哪个牌子好，麦克风推荐

无线麦克风哪款好用，手机领夹麦克风哪个牌子好，麦克风推荐

随着短视频与直播行业的蓬勃发展&#xff0c;无线领夹麦克风市场迎来了前所未有的繁荣。品牌如罗德、大疆、西圣等麦克风品牌凭借卓越的技术实力与品牌影响力占据了市场的主导地位&#xff0c;其中西圣更是凭借其高性价比和用户口碑&#xff0c;稳居行业口碑品牌前列。但在这光…
阅读更多...
线性规划及其MATLAB实现

线性规划及其MATLAB实现

目录 线性规划及其MATLAB实现 引言 线性规划的基本模型 线性规划求解方法 MATLAB中的线性规划求解 MATLAB线性规划应用实例 1. 生产计划问题 模型建立&#xff1a; 2. 运输问题 2. 运输问题 MATLAB实现&#xff1a; 线性规划在实际中的应用 结论 线性规划及其MATLA…
阅读更多...
路基边坡自动化监测解决方案

路基边坡自动化监测解决方案

物联网云平台 平台登录--用户登录 输入网址&#xff1a;http://yun.sj2000.org.cn&#xff0c;进入系统登录界面&#xff0c;输入用户名及密码后进入系统平台。 设备详情--设备概览 登录系统平台后&#xff0c;用户可在界面左侧看到系统项目栏和子项目选项&#xff0c;登陆的…
阅读更多...
LSS可视化分析

LSS可视化分析

1 完整 2 去掉plt.imshow(img_show) 3 去掉plt.axis(‘off’) 4 去掉plt.annotate(cams_text[img_id].replace(‘_’, ’ ), (0.01, 0.92), xycoords=‘axes fraction’)
阅读更多...
多线程与并发区别

多线程与并发区别

在Java中&#xff0c;多线程与并发是两个既相关又有所区别的概念。我们可以这样来理解它们&#xff1a; 多线程&#xff08;Multi-threading&#xff09;&#xff1a; 多线程是指程序能够同时执行多个线程。每个线程都是一个独立的执行流&#xff0c;它们共享程序的内存空间&a…
阅读更多...
【隐私计算】Paillier半同态加密算法

【隐私计算】Paillier半同态加密算法

一、何为同态加密&#xff08;HE&#xff09;&#xff1f; HE是一种特殊的加密方法&#xff0c;它允许直接对加密数据执行计算&#xff0c;如加法和乘法&#xff0c;而计算过程不会泄露原文的任何信息。计算的结果仍然是加密的&#xff0c;拥有密钥的用户对处理过的密文数据进…
阅读更多...
基于 SpringBoot 的车辆充电桩管理系统

基于 SpringBoot 的车辆充电桩管理系统

专业团队&#xff0c;咨询就送开题报告 摘 要 随着信息化时代的到来&#xff0c;管理系统都趋向于智能化、系统化&#xff0c;车辆充电桩管理系统也不例外&#xff0c;但目前国内仍都使用人工管理&#xff0c;市场规模越来越大&#xff0c;同时信息量也越来越庞大&#xff0c;…
阅读更多...
江协科技stm32————11-5 硬件SPI读写W25Q64

江协科技stm32————11-5 硬件SPI读写W25Q64

一、开启时钟&#xff0c;开启SPI和GPIO的时钟 二、初始化GPIO口&#xff0c;其中SCK和MOSI是由硬件外设控制的输出信号&#xff0c;配置为复用推挽输出 MISO是硬件外设的输入信号&#xff0c;配置为上拉输入&#xff0c;SS是软件控制的输出信号&#xff0c;配置为通用推挽输出…
阅读更多...
十，Spring Boot 的内容协商的详细剖析(附+Debug调试说明)

十，Spring Boot 的内容协商的详细剖析(附+Debug调试说明)

十&#xff0c;Spring Boot 的内容协商的详细剖析(附Debug调试说明) 文章目录 十&#xff0c;Spring Boot 的内容协商的详细剖析(附Debug调试说明)1. 基本介绍2. 准备工作3. 内容协商的本质4. 内容协商&#xff1a;注意事项和使用细节5. 总结&#xff1a;6. 最后&#xff1a; 1…
阅读更多...
数据库安全性控制

数据库安全性控制

‍ 在当今信息化时代&#xff0c;数据库安全性 对于保护数据免受非法访问和损害至关重要。无论是个人数据还是企业机密&#xff0c;数据库安全性控制都能有效地防范潜在的威胁。本文将为你深入浅出地介绍数据库安全性控制的关键方法和机制&#xff0c;帮助你轻松掌握这一重要概…
阅读更多...
空间物联网中的大规模接入：挑战、机遇和未来方向

空间物联网中的大规模接入：挑战、机遇和未来方向

这篇论文的标题是《Massive Access in Space-based Internet of Things: Challenges, Opportunities, and Future Directions》&#xff0c;作者包括Jian Jiao, Shaohua Wu, Rongxing Lu, 和 Qinyu Zhang。文章发表在2021年10月的IEEE Wireless Communications上。论文主要探讨…
阅读更多...
YoloV10改进策略：Block改进|PromptIR（NIPS‘2023）|轻量高效，即插即用|(适用于分类、分割、检测等多种场景)

YoloV10改进策略：Block改进|PromptIR（NIPS‘2023）|轻量高效，即插即用|(适用于分类、分割、检测等多种场景)

文章目录 摘要官方结果代码详解如何在自己的论文中描述摘要 本文使用PromptIR框架中的PGM模块来改进YoloV10。PGM（Prompt Generation Module）模块是PromptIR框架中的一个重要组成部分，主要负责生成输入条件化的提示（prompts）。这些提示是一组可学习的参数，它们与输入特征…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023