CANN批处理优化技巧：从动态批处理到流水线并行

lili-felicity2026-02-07 11:15

在 AI 推理的实际应用中，如何处理大量的并发请求、充分利用 NPU 的计算能力、同时保持合理的延迟，是每个系统架构师都需要深入思考的问题。批处理技术作为提升推理性能的核心手段，通过将多个请求合并为一个批次进行处理，能够显著提高硬件利用率、降低单样本的计算开销。CANN 提供的批处理优化能力，结合动态批处理、流水线并行等高级技术，为构建高性能推理系统提供了强有力的支撑。

相关链接：CANN 组织:https://atomgit.com/cann

parser 仓库:https://atomgit.com/cann/parser

一、批处理的核心价值：从单样本到批次的性能跃升

批处理技术的基本思想是将多个独立的推理请求合并为一个批次，然后在 NPU 上一次性处理整个批次。这种处理方式之所以能够提升性能，主要基于以下几个原因：

  1. 减少数据传输开销：将多个样本的数据一次性传输到 Device，相比于逐个传输，能够减少传输次数和传输总时间
  2. 提高计算并行度：NPU 可以并行处理批次中的多个样本，充分利用硬件的并行计算能力
  3. 减少算子调用开销：每个算子只需要调用一次，而不是为每个样本调用一次，减少了函数调用的开销
  4. 优化内存访问模式：批处理使得内存访问更加连续，能够更好地利用缓存和内存带宽

为了更直观地理解批处理的性能优势，我们来看一个简单的对比：

处理方式 样本数量 总延迟 吞吐量 内存占用
单样本处理 10 500ms 20 QPS 低
批处理(Batch=4) 10 150ms 67 QPS 中
批处理(Batch=8) 10 100ms 100 QPS 高

从上表可以看出，批处理能够在保持总延迟基本不变的情况下，显著提升吞吐量。当然，批处理也有其局限性：会增加内存占用、可能增加单请求的延迟（如果需要等待凑够一个批次）。因此，如何选择合适的 Batch Size，是批处理优化的核心问题。

二、Batch Size 的选择策略：平衡延迟与吞吐量

Batch Size 的选择是批处理优化中最关键的问题。Batch Size 过小，无法充分发挥批处理的优势；Batch Size 过大，会增加内存占用，可能导致 OOM（Out of Memory）错误，同时也会增加单请求的延迟（因为需要等待凑够一个批次）。

2.1 静态 Batch Size

静态 Batch Size 是最简单的策略，即在系统启动时就确定一个固定的 Batch Size，所有推理请求都按照这个 Batch Size 进行批处理。

静态 Batch Size 的优点是实现简单、易于理解和调试；缺点是无法适应动态变化的负载，在低负载时会浪费资源，在高负载时可能无法满足性能要求。

以下是实现静态批处理的代码：

python 复制代码 
import acl
import numpy as np
import time
from queue import Queue
from threading import Thread

class StaticBatchProcessor:
    """静态批处理器"""
    def __init__(self, model_path, device_id=0, batch_size=8):
        self.device_id = device_id
        self.batch_size = batch_size

        # 初始化ACL
        acl.init()
        acl.rt.set_device(device_id)

        # 加载模型
        self.model_id, _ = acl.mdl.load_from_file(model_path)
        self.model_desc = acl.mdl.create_desc()
        acl.mdl.get_desc(self.model_desc, self.model_id)

        # 创建Stream
        self.stream, _ = acl.rt.create_stream()

        # 请求队列
        self.request_queue = Queue()

        # 结果队列
        self.result_queues = {}

        # 启动批处理线程
        self.running = True
        self.worker = Thread(target=self._batch_worker)
        self.worker.start()

        print(f"静态批处理器初始化完成")
        print(f"  Batch Size: {batch_size}")

    def _batch_worker(self):
        """批处理工作线程"""
        while self.running:
            batch_requests = []

            # 收集请求，凑够一个批次
            try:
                request = self.request_queue.get(timeout=0.01)
                batch_requests.append(request)

                # 继续收集，直到凑够batch_size个请求
                while len(batch_requests) < self.batch_size:
                    try:
                        request = self.request_queue.get(timeout=0.001)
                        batch_requests.append(request)
                    except:
                        break
            except:
                continue

            # 处理批次
            if batch_requests:
                self._process_batch(batch_requests)

    def _process_batch(self, requests):
        """处理一批请求"""
        # 合并输入
        batch_input = np.stack([req[0] for req in requests])

        # 批量推理
        batch_output = self._batch_infer(batch_input)

        # 分发结果
        for i, request in enumerate(requests):
            req_id, _, result_queue = request
            result_queue.put(batch_output[i])

    def _batch_infer(self, batch_input):
        """批量推理"""
        batch_size = batch_input.shape[0]
        data_size = batch_input.nbytes

        # 分配设备内存
        device_ptr, _ = acl.rt.malloc(data_size, 0)

        # 异步传输数据
        acl.rt.memcpy_async(
            device_ptr, data_size,
            batch_input.ctypes.data, data_size,
            acl.rt.MEMCPY_HOST_TO_DEVICE,
            self.stream
        )

        # 创建数据集
        input_dataset = acl.mdl.create_dataset()
        buffer = acl.create_data_buffer(device_ptr, data_size)
        acl.mdl.add_dataset_buffer(input_dataset, buffer)
        output_dataset = acl.mdl.create_dataset()

        # 执行推理
        acl.mdl.execute_async(
            self.model_id,
            input_dataset,
            output_dataset,
            self.stream
        )

        # 同步等待完成
        acl.rt.synchronize_stream(self.stream)

        # 获取输出
        output_buffer = acl.mdl.get_dataset_buffer(output_dataset, 0)
        output_ptr = acl.get_data_buffer_addr(output_buffer)
        output_size = acl.get_data_buffer_size(output_buffer)

        output = np.zeros((batch_size, 1000), dtype=np.float32)
        acl.rt.memcpy(
            output.ctypes.data, output_size,
            output_ptr, output_size,
            acl.rt.MEMCPY_DEVICE_TO_HOST
        )

        # 清理资源
        acl.rt.free(device_ptr)
        acl.destroy_data_buffer(buffer)
        acl.mdl.destroy_dataset(input_dataset)
        acl.mdl.destroy_dataset(output_dataset)

        return output

    def infer(self, input_data):
        """提交推理请求"""
        # 生成请求ID
        req_id = id(input_data)

        # 创建结果队列
        result_queue = Queue()

        # 提交到批处理队列
        self.request_queue.put((req_id, input_data, result_queue))

        # 等待结果
        return result_queue.get()

    def stop(self):
        """停止批处理器"""
        self.running = False
        self.worker.join()

2.2 动态 Batch Size

动态 Batch Size 是更智能的策略，根据当前的负载情况动态调整 Batch Size。在负载较低时使用较小的 Batch Size，以减少单请求的延迟；在负载较高时使用较大的 Batch Size，以提高吞吐量。

动态 Batch Size 的实现需要考虑以下几个关键因素：

  1. 请求到达速率：根据请求到达的速率调整 Batch Size
  2. 队列长度：当队列长度较长时，增加 Batch Size
  3. 超时机制：设置超时时间，避免等待时间过长
  4. 内存限制：确保 Batch Size 不会导致 OOM

以下是实现动态批处理的代码：

python 复制代码 
class DynamicBatchProcessor(StaticBatchProcessor):
    """动态批处理器"""
    def __init__(self, model_path, device_id=0, max_batch_size=16, timeout=0.01):
        super().__init__(model_path, device_id, max_batch_size)
        self.max_batch_size = max_batch_size
        self.timeout = timeout

        # 负载统计
        self.request_count = 0
        self.total_time = 0
        self.last_stat_time = time.time()

        # 当前Batch Size
        self.current_batch_size = 8

    def _batch_worker(self):
        """动态批处理工作线程"""
        while self.running:
            batch_requests = []

            # 收集请求
            try:
                request = self.request_queue.get(timeout=self.timeout)
                batch_requests.append(request)
                self.request_count += 1

                # 动态调整目标Batch Size
                target_batch = self._calculate_optimal_batch_size()

                # 继续收集，直到达到目标Batch Size或超时
                start_time = time.time()
                while len(batch_requests) < target_batch:
                    try:
                        request = self.request_queue.get(timeout=0.001)
                        batch_requests.append(request)
                        self.request_count += 1

                        # 检查是否超时
                        if time.time() - start_time > self.timeout:
                            break
                    except:
                        break
            except:
                continue

            # 处理批次
            if batch_requests:
                self._process_batch(batch_requests)

            # 定期更新统计
            if time.time() - self.last_stat_time > 1.0:
                self._update_stats()

    def _calculate_optimal_batch_size(self):
        """计算最优Batch Size"""
        # 计算请求到达速率
        elapsed = time.time() - self.last_stat_time
        if elapsed == 0:
            return self.current_batch_size

        arrival_rate = self.request_count / elapsed

        # 根据到达速率调整Batch Size
        if arrival_rate < 10:
            optimal_batch = 4
        elif arrival_rate < 50:
            optimal_batch = 8
        elif arrival_rate < 100:
            optimal_batch = 12
        else:
            optimal_batch = self.max_batch_size

        # 平滑调整
        self.current_batch_size = int(0.7 * self.current_batch_size + 0.3 * optimal_batch)

        return self.current_batch_size

    def _update_stats(self):
        """更新统计信息"""
        elapsed = time.time() - self.last_stat_time
        if elapsed > 0:
            arrival_rate = self.request_count / elapsed
            print(f"统计更新: 到达率={arrival_rate:.1f} QPS, Batch Size={self.current_batch_size}")

        self.request_count = 0
        self.last_stat_time = time.time()

三、流水线并行：批处理的性能倍增器

流水线并行是将批处理的不同阶段分配到不同的处理单元上并行执行，从而进一步提高整体吞吐量。典型的流水线包含以下阶段：

  1. 数据预处理：对输入数据进行归一化、缩放等预处理操作
  2. 数据传输：将数据从 Host 传输到 Device
  3. 推理计算：在 NPU 上执行推理计算
  4. 结果处理：对输出结果进行后处理，如 Softmax、Top-K 等

通过流水线并行，当第一个请求正在进行推理计算时，第二个请求的数据可以开始传输，第三个请求可以进行预处理。这种重叠执行的方式，能够显著提高整体吞吐量。

以下是实现流水线并行的代码：

python 复制代码 
class PipelineBatchProcessor:
    """流水线并行批处理器"""
    def __init__(self, model_path, device_id=0, batch_size=8):
        self.device_id = device_id
        self.batch_size = batch_size

        # 初始化ACL
        acl.init()
        acl.rt.set_device(device_id)

        # 加载模型
        self.model_id, _ = acl.mdl.load_from_file(model_path)
        self.model_desc = acl.mdl.create_desc()
        acl.mdl.get_desc(self.model_desc, self.model_id)

        # 创建多个Stream，用于流水线的不同阶段
        self.preprocess_stream, _ = acl.rt.create_stream()
        self.transfer_stream, _ = acl.rt.create_stream()
        self.infer_stream, _ = acl.rt.create_stream()
        self.postprocess_stream, _ = acl.rt.create_stream()

        # 创建事件，用于同步不同Stream
        self.preprocess_done, _ = acl.rt.create_event()
        self.transfer_done, _ = acl.rt.create_event()
        self.infer_done, _ = acl.rt.create_event()

        # 阶段队列
        self.preprocess_queue = Queue(maxsize=2)
        self.transfer_queue = Queue(maxsize=2)
        self.infer_queue = Queue(maxsize=2)
        self.postprocess_queue = Queue(maxsize=2)

        # 启动流水线阶段
        self.running = True
        self.stages = [
            Thread(target=self._preprocess_stage),
            Thread(target=self._transfer_stage),
            Thread(target=self._infer_stage),
            Thread(target=self._postprocess_stage)
        ]
        for stage in self.stages:
            stage.start()

        print("流水线并行批处理器初始化完成")

    def _preprocess_stage(self):
        """预处理阶段"""
        while self.running:
            try:
                batch = self.preprocess_queue.get(timeout=0.1)

                # 执行预处理
                processed_batch = self._batch_preprocess(batch)

                # 记录事件
                acl.rt.record_event(self.preprocess_done, self.preprocess_stream)

                # 传递到传输阶段
                self.transfer_queue.put(processed_batch)

            except:
                continue

    def _transfer_stage(self):
        """数据传输阶段"""
        while self.running:
            try:
                batch = self.transfer_queue.get(timeout=0.1)

                # 等待预处理完成
                acl.rt.stream_wait_event(self.transfer_stream, self.preprocess_done)

                # 执行数据传输
                transferred_batch = self._batch_transfer(batch)

                # 记录事件
                acl.rt.record_event(self.transfer_done, self.transfer_stream)

                # 传递到推理阶段
                self.infer_queue.put(transferred_batch)

            except:
                continue

    def _infer_stage(self):
        """推理阶段"""
        while self.running:
            try:
                batch = self.infer_queue.get(timeout=0.1)

                # 等待传输完成
                acl.rt.stream_wait_event(self.infer_stream, self.transfer_done)

                # 执行推理
                output_batch = self._batch_infer(batch)

                # 记录事件
                acl.rt.record_event(self.infer_done, self.infer_stream)

                # 传递到后处理阶段
                self.postprocess_queue.put(output_batch)

            except:
                continue

    def _postprocess_stage(self):
        """后处理阶段"""
        while self.running:
            try:
                batch = self.postprocess_queue.get(timeout=0.1)

                # 等待推理完成
                acl.rt.stream_wait_event(self.postprocess_stream, self.infer_done)

                # 执行后处理
                result_batch = self._batch_postprocess(batch)

                # 返回结果
                # 这里应该将结果返回给对应的请求
                # 简化实现，直接打印
                print(f"后处理完成，处理了 {len(result_batch)} 个结果")

            except:
                continue

    def _batch_preprocess(self, batch):
        """批量预处理"""
        # 归一化
        processed = batch / 255.0
        return processed

    def _batch_transfer(self, batch):
        """批量数据传输"""
        data_size = batch.nbytes
        device_ptr, _ = acl.rt.malloc(data_size, 0)

        acl.rt.memcpy_async(
            device_ptr, data_size,
            batch.ctypes.data, data_size,
            acl.rt.MEMCPY_HOST_TO_DEVICE,
            self.transfer_stream
        )

        acl.rt.synchronize_stream(self.transfer_stream)

        return (device_ptr, data_size)

    def _batch_infer(self, batch):
        """批量推理"""
        device_ptr, data_size = batch
        batch_size = data_size // (3 * 224 * 224 * 4)  # 假设输入是 [B, 3, 224, 224]

        # 创建数据集
        input_dataset = acl.mdl.create_dataset()
        buffer = acl.create_data_buffer(device_ptr, data_size)
        acl.mdl.add_dataset_buffer(input_dataset, buffer)
        output_dataset = acl.mdl.create_dataset()

        # 执行推理
        acl.mdl.execute_async(
            self.model_id,
            input_dataset,
            output_dataset,
            self.infer_stream
        )

        acl.rt.synchronize_stream(self.infer_stream)

        # 获取输出
        output_buffer = acl.mdl.get_dataset_buffer(output_dataset, 0)
        output_ptr = acl.get_data_buffer_addr(output_buffer)
        output_size = acl.get_data_buffer_size(output_buffer)

        output = np.zeros((batch_size, 1000), dtype=np.float32)
        acl.rt.memcpy(
            output.ctypes.data, output_size,
            output_ptr, output_size,
            acl.rt.MEMCPY_DEVICE_TO_HOST
        )

        # 清理
        acl.rt.free(device_ptr)
        acl.destroy_data_buffer(buffer)
        acl.mdl.destroy_dataset(input_dataset)
        acl.mdl.destroy_dataset(output_dataset)

        return output

    def _batch_postprocess(self, batch):
        """批量后处理"""
        # Softmax
        exp_batch = np.exp(batch - np.max(batch, axis=1, keepdims=True))
        softmax_batch = exp_batch / np.sum(exp_batch, axis=1, keepdims=True)

        # Top-K
        top5 = np.argsort(softmax_batch, axis=1)[:, -5:][:, ::-1]

        return top5

    def infer(self, input_list):
        """提交批量推理请求"""
        # 将输入列表转换为批次
        batch_input = np.stack(input_list)

        # 提交到预处理队列
        self.preprocess_queue.put(batch_input)

        # 简化实现，直接返回
        # 实际实现中应该等待后处理完成并返回结果
        return None

    def stop(self):
        """停止处理器"""
        self.running = False
        for stage in self.stages:
            stage.join()

四、性能优化策略：从理论到实践

4.1 Batch Size 性能测试

为了找到最优的 Batch Size，我们需要进行性能测试。以下是实现性能测试的代码：

python 复制代码 
def benchmark_batch_size():
    """Batch Size性能测试"""
    print("\n" + "=" * 60)
    print("Batch Size 性能测试")
    print("=" * 60)

    # 测试配置
    batch_sizes = [1, 2, 4, 8, 16, 32]
    num_samples = 100

    print(f"\n测试配置:")
    print(f"  样本数量: {num_samples}")
    print(f"  Batch Size范围: {batch_sizes}")

    # 模拟性能数据
    print(f"\n{'Batch Size':<15} {'总延迟(ms)':<20} {'吞吐量(QPS)':<20} {'内存(MB)':<15}")
    print("-" * 70)

    for batch_size in batch_sizes:
        # 模拟性能数据
        base_latency = 50  # 基础延迟
        per_sample_overhead = 2  # 每个样本的开销

        total_latency = base_latency + batch_size * per_sample_overhead
        throughput = num_samples / (total_latency / 1000)
        memory = batch_size * 2  # 每个样本2MB

        print(f"{batch_size:<15} {total_latency:<20.2f} {throughput:<20.2f} {memory:<15}")

    # 找到最优Batch Size
    print("\n最优Batch Size选择:")
    print("  1. 低延迟场景: Batch Size = 1-4")
    print("  2. 平衡场景: Batch Size = 8-16")
    print("  3. 高吞吐场景: Batch Size = 16-32")
    print("  4. 需要考虑内存限制和硬件特性")

    print("=" * 60)

benchmark_batch_size()

4.2 内存优化策略

批处理会增加内存占用，可能导致 OOM 错误。以下是一些内存优化策略：

  1. 使用混合精度：将部分操作使用 FP16 或 INT8，减少内存占用
  2. 梯度检查点：在训练场景中，使用梯度检查点技术减少内存占用
  3. 内存复用：在推理过程中复用已分配的内存
  4. 动态调整 Batch Size：根据可用内存动态调整 Batch Size

以下是实现内存优化的代码：

python 复制代码 
def optimize_memory_usage(max_memory_gb=16):
    """优化内存使用"""
    print("\n内存优化策略")
    print("=" * 60)

    # 计算不同Batch Size的内存占用
    input_shape = (1, 3, 224, 224)
    output_shape = (1, 1000)

    input_size_per_sample = np.prod(input_shape) * 4  # FP32
    output_size_per_sample = np.prod(output_shape) * 4

    max_memory_bytes = max_memory_gb * 1024 * 1024 * 1024

    batch_sizes = []
    for batch_size in range(1, 33):
        # 计算总内存占用
        total_size = (input_size_per_sample + output_size_per_sample) * batch_size

        # 考虑中间结果和开销
        total_size *= 1.5

        if total_size <= max_memory_bytes:
            batch_sizes.append(batch_size)

    max_safe_batch = max(batch_sizes) if batch_sizes else 1

    print(f"可用内存: {max_memory_gb} GB")
    print(f"最大安全Batch Size: {max_safe_batch}")
    print(f"建议Batch Size: {min(max_safe_batch, 16)}")

    # 内存优化建议
    print("\n内存优化建议:")
    print("  1. 使用FP16精度，减少50%内存占用")
    print("  2. 实现内存复用，减少分配/释放次数")
    print("  3. 分批处理大数据，避免一次性加载")
    print("  4. 监控内存使用，动态调整Batch Size")

    print("=" * 60)

optimize_memory_usage()

五、实战应用：构建高性能批处理推理服务

基于前面介绍的批处理优化技术，我们可以构建一个高性能的批处理推理服务。这个服务能够动态调整 Batch Size，实现流水线并行，最大化推理性能。

5.1 服务架构

高性能批处理推理服务的架构包含以下核心组件：

  1. 请求接收层：接收客户端请求，进行初步验证
  2. 动态批处理层：根据负载动态调整 Batch Size
  3. 流水线并行层：实现预处理、传输、推理、后处理的流水线并行
  4. 结果返回层：将推理结果返回给客户端

5.2 完整实现

python 复制代码 
from flask import Flask, request, jsonify
import numpy as np
import time

class HighPerformanceBatchService:
    """高性能批处理推理服务"""
    def __init__(self, model_path, device_id=0, max_batch=16):
        self.device_id = device_id
        self.max_batch = max_batch

        # 初始化动态批处理器
        self.processor = DynamicBatchProcessor(
            model_path, device_id, max_batch
        )

        # 创建Flask应用
        self.app = Flask(__name__)
        self._register_routes()

        print("高性能批处理推理服务初始化完成")

    def _register_routes(self):
        """注册API路由"""

        @self.app.route('/predict', methods=['POST'])
        def predict():
            """推理接口"""
            try:
                data = request.get_json()

                if 'input' not in data:
                    return jsonify({'error': 'Missing input'}), 400

                # 转换输入
                input_data = np.array(data['input'], dtype=np.float32)

                # 执行推理
                output = self.processor.infer(input_data)

                return jsonify({
                    'success': True,
                    'output': output.tolist()
                })

            except Exception as e:
                return jsonify({'error': str(e)}), 500

        @self.app.route('/batch_predict', methods=['POST'])
        def batch_predict():
            """批量推理接口"""
            try:
                data = request.get_json()

                if 'inputs' not in data:
                    return jsonify({'error': 'Missing inputs'}), 400

                # 转换输入
                input_list = [np.array(inp, dtype=np.float32)
                             for inp in data['inputs']]

                # 批量推理
                outputs = self.processor.batch_infer(input_list)

                return jsonify({
                    'success': True,
                    'outputs': [out.tolist() for out in outputs],
                    'count': len(outputs)
                })

            except Exception as e:
                return jsonify({'error': str(e)}), 500

        @self.app.route('/metrics', methods=['GET'])
        def metrics():
            """服务指标"""
            return jsonify({
                'current_batch_size': self.processor.current_batch_size,
                'max_batch_size': self.max_batch,
                'queue_size': self.processor.request_queue.qsize()
            })

    def run(self, host='0.0.0.0', port=5000):
        """运行服务"""
        print(f"启动高性能批处理推理服务: http://{host}:{port}")
        self.app.run(host=host, port=port, threaded=True)

# 使用示例
def start_batch_service():
    """启动批处理推理服务"""
    print("启动高性能批处理推理服务")
    print("=" * 60)

    # 创建服务（实际使用时需要真实的模型文件）
    # service = HighPerformanceBatchService(
    #     model_path="model.om",
    #     device_id=0,
    #     max_batch=16
    # )

    # 运行服务
    # service.run(host='0.0.0.0', port=5000)

    print("\nAPI接口:")
    print("  POST /predict       - 单次推理")
    print("  POST /batch_predict - 批量推理")
    print("  GET  /metrics       - 服务指标")

    print("\n使用示例:")
    print('  curl -X POST http://localhost:5000/batch_predict \\')
    print('    -H "Content-Type: application/json" \\')
    print('    -d \'{"inputs": [[[0.1, 0.2, 0.3], ...]], ...]\'')

    print("=" * 60)

start_batch_service()

六、总结与展望

CANN 批处理优化技术通过合理的 Batch Size 选择、动态批处理、流水线并行等策略，能够显著提升推理性能和系统吞吐量。本文从批处理的核心价值出发，详细介绍了 Batch Size 的选择策略、动态批处理的实现、流水线并行的设计，最终构建了一个高性能的批处理推理服务。

关键要点总结：

  1. 批处理的核心价值：提高硬件利用率、减少传输开销、提高并行度
  2. Batch Size 选择：根据场景选择合适的 Batch Size，平衡延迟和吞吐量
  3. 动态批处理：根据负载动态调整 Batch Size，适应变化的负载
  4. 流水线并行：实现预处理、传输、推理、后处理的流水线并行
  5. 内存优化：使用混合精度、内存复用等技术，减少内存占用

未来展望：

  • 自适应批处理：根据模型特征和硬件特性自动优化批处理策略
  • 智能调度：基于机器学习的智能任务调度，进一步优化性能
  • 跨设备批处理：实现多设备间的批处理协同
  • 实时优化：在线优化批处理参数，适应实时变化的负载

通过持续优化批处理技术，CANN 将能够更好地支撑大规模 AI 推理场景，为 AI 应用提供更强大的算力支撑。

相关推荐
一个有梦有戏的人3 小时前
Python3基础：进阶基础，筑牢编程底层能力
后端·python
一枕眠秋雨>o<3 小时前
算子之力：解码CANN ops-nn如何重塑昇腾AI计算范式
人工智能
AI科技3 小时前
原创音乐人运用AI编曲软件，编曲怎么配和弦的声音
人工智能
dazzle3 小时前
机器学习算法原理与实践-入门（三）：使用数学方法实现KNN
人工智能·算法·机器学习
那个村的李富贵3 小时前
智能炼金术：CANN加速的新材料AI设计系统
人工智能·算法·aigc·cann
凯子坚持 c3 小时前
CANN 生态新星：`minddata-dataset-engine` 如何加速 AI 数据 pipeline
人工智能
Fairy要carry3 小时前
面试-GRPO强化学习
开发语言·人工智能
xiaobaibai1533 小时前
营销自动化终极形态：AdAgent 自主闭环工作流全解析
大数据·人工智能·自动化
摘星编程4 小时前
解析CANN ops-nn中的Transpose算子：张量维度变换的高效实现
python
热门推荐
01GitHub 镜像站点02Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services03使用 1panel面板 部署 php网站04OpenClaw Chrome扩展使用教程 - 浏览器中继控制05Vue-skills的中文文档06Linux下V2Ray安装配置指南07让 Trae IDE 智能体 “读懂”文档 Excel+PDF+DOCX ：mcp-documents-reader 工具使用指南08UV安装并设置国内源09从零搭建一个 PHP 登录注册系统（含完整源码）10一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示