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

置顶 已于 2024-09-10 11:13:55 修改
阅读量564 收藏 8
点赞数 7
分类专栏： 深度学习 文章标签： python numba 多线程
于 2024-09-09 21:48:45 首次发布
版权声明：本文为博主原创文章，未经作者允许不得转载，且不得用于商业目的，否则将追究法律责任。
本文链接：https://blog.csdn.net/shinuone/article/details/134791872
版权

文章目录

在这里插入图片描述

输入数据插值倍数时耗
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 np

if __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_data


if __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 time
    start_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上传到GPU
    input_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下载回CPU
    output_data = output_data_gpu.copy_to_host()

    return output_data


if __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 time
    start_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_block


def 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_size
        end_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_data


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)  # 创建一个示例的3D数组
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_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_block


def 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_block


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_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_block


def 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_block


def 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_blocks


if __name__ == "__main__":
    input_data = np.zeros((1024, 1024, int(1024 * 0.5))).astype(bool)
    input_data[50:600, 200:1000, 5:30] = 1

    import time
    start_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)
"""
胖墩会武术
关注
  • 7
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Numba加速计算（CPU + GPU + prange）
shinuone的博客
08-22 1223
Numba：专为 NumPy 科学计算而打造的，用于加速 Python 代码的即时编译器（Just-In-Time, JIT Compiler）。
通过Numba调用CUDA用GPU为Python加速：进阶理解网格跨步、多流、共享内存
漫步量化
12-03 6861
前导知识 理解本文需要先了解： 计算机底层基础知识，CPU、机器码、编译等《编译型语言与解释型语言如何在计算机底层运行》《计算机底层运转机制：多核、缓存、CPU、CU、ALU、Cache》 Python代码与GPU加速的关系《Python程序如何用GPU加速：Tesla、CUDA、Numba》 在CPU入门numba《Python代码在CPU下加速：Numba入门》 在GPU入门numba《...
Numba加速计算：坐标索引（CPU + 多线程）
最新发布
shinuone的博客
09-09 424
坐标索引：（1）多线程（每一个像素值遍历一次图像）；（2）Numba-CPU（每一个像素值遍历一次图像）；（3）Numba-CPU（只遍历一次图像并匹配像素值）
python GPU加速 以numba为例
qq_42947060的博客
03-06 1406
本文主要在于记录针对于cuda的基础知识学习，在通过numba的实际例子了解如何在python中进行GPU运算
GPU环境下Python+Numba编程报错:RuntimeError: Numba cannot operate on non-primary CUDA context 55d3358f3aa0
liuz_notes的博客
03-20 2416
Numba-GPU报错
python加速方法：GPU加速（numba库）Demo及编写注意事项
静以修身，简以养德
11-27 1005
上周使用GPU加速了一个算法，效果特别惊艳，由于算法代码本身没有太大参考价值，所以这里只记录了一些心得体会，以便后续遇到问题进行参考排查。
Numba+GPU
源代码杀手的博客
06-28 589
什么是nopython模式？ Numba@jit装饰器基本上以两种编译模式运行，nopython模式和object模式。在go_fast上面的例子中，nopython=True是在@jit装饰器中设置的；这是指示 Numba 在nopython模式下运行。nopython编译模式的行为本质上是编译装饰函数，使其完全运行而无需 Python 解释器的参与。这是使用 Numbajit装饰器的推荐和最佳实践方法，因为它可以带来最佳性能。 如果nopython模式下的编译失败，Numba 可以使用.如...
【Python-GPU加速】基于Numba的GPU计算加速（一）基本
热门推荐
TomRen
11-23 1万+
Numba是一个可以利用GPU/CPU和CUDA 对python函数进行动态编译，大幅提高执行速度的加速工具包。 利用修饰器@jit,@cuda.jit,@vectorize等对函数进行编译 JIT：即时编译，提高执行速度 基于特定数据类型 集中与数值计算(高效编译math，cmath，sub-numpy) Numba是一个开源的JIT编译器，可以将python或者numpy 的一些数学...
python使用numba库实现gpu加速
m0_56015193的博客
10-18 4529
Numba是一个针对Python的开源JIT编译器，由Anaconda公司主导开发，可以对Python原生代码进行CPU和GPU加速。Numba对NumPy数组和函数非常友好。 使用Numba非常方便，只需要在Python原生函数上增加一个装饰器（Decorator）。Numba会将这些函数使用即时编译JIT方式编译成机器码，这些代码将以近乎机器码的速度运行。 1.CPU加速： 只用1行代码即可加速，对loop有奇效 在函数前面加一个@nb.jit()其他不用变 ...
numba-dppy:numba + dpPy + dpCtl + dpNP = numba-dppy
04-04
numba-dppy通过新的后端扩展了Numba，以支持针对Intel CPU和GPU架构的编译。 有关Numba的更多信息，请参见Numba主页： ://numba.pydata.org。 注意： numba-dppy需要numba-dppy修补版本。 参见 。 有关dpCtl的更...
NCCV：使用Numba + CUDA + OpenCV进行计算机视觉和图像处理的短期课程
02-05
2. **CUDA入门**：理解CUDA架构，学习CUDA编程的基本概念，如线程块、网格和共享内存，以及如何使用CUDA C++编写简单的GPU程序。 3. **OpenCV与Numba/CUDA结合**：学习如何将OpenCV的图像处理函数与Numba和CUDA集成...
常用GPU计算工具numba的3个例子.docx
10-09
除了CPU加速，Numba还支持CUDA编程，允许我们利用GPU的强大计算能力。要使用GPU，你需要确保你的系统有NVIDIA GPU和适当的CUDA驱动。下面是一个使用GPU的例子： ```python from numba import cuda, jit @cuda.jit ...
【python】—— Python爬虫实战：爬取珠海市2011-2023年天气数据并保存为CSV文件
weixin_63106307的博客
09-05 1102
本文将介绍如何使用Python编写一个简单的爬虫程序，以爬取珠海市2011年至2023年的天气数据，并将这些数据保存为CSV文件。
【FFMPEG】Install FFmpeg CUDA gltransition in Ubuntu
RockWang的博客
09-05 482
FFMPEG gltranlations CUDA
pip-tools：打造可重复、可控的 Python 开发环境，解决依赖关系，让代码更稳定
weixin_53707653的博客
09-09 771
是一个强大且易用的工具，可以帮助开发者轻松管理 Python 项目的依赖关系，确保代码的可重复性和稳定性。是一组命令行工具，旨在简化 Python 依赖关系的管理，确保项目环境的稳定性和可重复性。可以确保每次构建环境时都使用相同的依赖项版本，从而避免由于依赖项版本不一致导致的错误，提高代码可重复性和稳定性。自动化了依赖关系管理过程，节省了开发者的时间和精力，可以将更多时间投入到实际的开发工作中。文件中的信息，更新虚拟环境，安装、升级或卸载所需的软件包，确保虚拟环境与。命令可以从你的项目配置文件中生成。
Python实现多线程、多进程及协程
qq_42568323的博客
09-09 1008
本文详细介绍了 Python 中多线程、多进程和协程的并发模型及其实现方式，并通过具体场景演示了如何使用面向对象思想实现这些模型。在实际应用中，应根据任务的类型和需求选择合适的并发模型，从而优化程序的性能和资源利用率。本文将详细介绍 Python 中的多线程、多进程和协程的概念及其实现方式，并通过具体场景展示如何在 Python 中使用面向对象的思想实现这些并发模型。接下来，我们通过一个计算密集型任务的示例来演示多进程的实现：计算一系列大数字的阶乘。主程序中创建并启动了多个计算进程，并使用。
[Python]生成器和yield关键字
weixin_57336987的博客
09-07 391
概述:​ 它指的是 generator, 类似于以前学过的: 列表推导式, 集合推导式, 字典推导式…作用:​ 降低资源消耗, 快速(批量)生成数据.实现方式:​ 1.推导式写法.​ 2.yield写法.yield i # yield会记录每个生成的数据, 然后逐个的放到生成器对象中, 最终返回生成器对象.问题: 如何从生成器对象中获取数据?​ 答案:​ 1.for循环遍历​ 2.next()函数, 逐个获取.
基于人工智能的音乐情感分类系统
stm32d1219的博客
09-06 1084
音乐作为一种强烈的情感表达方式，不同的音调、节奏和和声传递着不同的情感信息。通过人工智能技术，能够自动识别音乐中的情感，为用户提供个性化的音乐推荐或情感分析服务。通过使用MFCC特征提取与神经网络分类算法，音乐情感分类系统可以有效地分析音乐中的情感信息，并根据不同情感对音乐进行分类。随着深度学习技术的进一步发展，音乐情感分类系统的准确性和应用范围将得到进一步提升。音乐情感分类是通过对音乐音频信号进行分析，识别出音乐传递的情感，如“愉快”、“悲伤”、“愤怒”等。问题讨论，人工智能的资料领取可以私信！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

胖墩会武术

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值