【TVM 教程】在 CPU 上部署 Hugging Face 剪枝模型

大模型压缩与加速实战:从量化剪枝到生产部署全解析 模型压缩与加速是深度学习工程化的核心技术,旨在解决AI模型在资源受限环境下的部署难题。其核心原理是通过算法优化,在保持模型精度的同时,显著降低其对计算、存储和能耗的需求。这项技术的工程价值在于,它让原本只能在高端GPU上运行的大模型,能够适配移动端、边缘设备和嵌入式系统等多样化场景。从基础的量化技术(如INT8转换)到结构化的剪枝方法,再到知识蒸馏和轻量化网络设计,这些手段共同构成了模型高效部署的技术栈。特别是在大语言模型和轻量化CNN-LSTM混合神经网络的应用中,压缩技术能有效解决模型体积庞大、推理延迟 阅读详情

更多 TVM 中文文档可访问 →Apache TVM 是一个端到端的深度学习编译框架,适用于 CPU、GPU 和各种机器学习加速芯片。 | Apache TVM 中文站

作者:Josh Fromm

本教程演示如何采用剪枝后的模型(本例中模型是 来自 Hugging Face 的 PruneBert),并使用 TVM 来利用模型稀疏支持来加速。

尽管本教程的主要目的是在已经修剪过的模型上实现加速,但评估修剪后模型的速度也十分必要。为此,我们提供了一个函数采用未修剪的模型,并将其权重替换为指定稀疏的随机和修剪权重。确定模型是否值得修剪时,这可能是一个有用的特性。

进入代码前讨论一下稀疏和剪枝,并深入研究两种不同类型的稀疏:结构化和非结构化。

剪枝是一种主要通过将权重值替换为 0 来减小模型参数大小的技术,尽管选择哪些权重设置为 0 的方法众多,但最直接的方法是选择具有最小值的权重。

通常,权重会被修剪为所需的稀疏百分比。例如,一个 95% 的稀疏模型将只有 5% 的权重非零。修剪成非常高的稀疏通常需要微调,或完全重新训练,因为它是有损近似。尽管通过简单的压缩从修剪后的模型中很容易获得参数大小的好处,但利用模型稀疏来产生 runtime 加速更加复杂。

修剪结构化稀疏权重的目的,是把修剪过的权重聚集在一起。换言之,用它们的值和位置进行修剪。将修剪后的权重捆绑在一起的好处是它允许诸如矩阵乘法之类的算法跳过整个块。

事实证明,在当今可用的大多数硬件上,某种程度的块稀疏对于实现显著加速非常重要。这是因为在大多数 CPU 或 GPU 加载内存时,一次跳过读取单个值并不会节省任何工作,而是使用向量化指令之类的东西读入并执行整个块。

非结构化稀疏权重是仅根据原始权重值进行修剪的权重,它们看起来随机分散在整个张量中,而非像块稀疏权重中看到的那样成块。在低稀疏下,非结构化剪枝技术很难加速。然而,在高稀疏下,会出现许多全 0 值的块,这使得加速成为可能。

本教程包含结构化和非结构化稀疏。Hugging Face 的 PruneBert 模型是非结构化的,但 95% 是稀疏的,即使不是最优的,也可以对其应用 TVM 的块稀疏优化。

可以用结构化稀疏为未修剪模型生成随机稀疏权重。将 PruneBert 的真实速度与使用假权重的块稀疏速度比较,可以发现结构化稀疏的优势。

加载所需模块​

除了 TVM,还需要 scipy(最新的 transformers)和 TensorFlow(版本在 2.2 以上)。

import os
import tvm
import time
import itertools
import numpy as np
import tensorflow as tf
from tvm import relay, runtime
from tvm.contrib import graph_executor
from tvm.relay import data_dep_optimization as ddo
from tensorflow.python.framework.convert_to_constants import (
    convert_variables_to_constants_v2,
)
import scipy.sparse as sp

# 要求 TensorFlow 将其 GPU 内存限制为实际需要的内存
# 而不是任其消耗其他内存。
# https://www.tensorflow.org/guide/gpu#limiting_gpu_memory_growth
# 这样对 sphinx-gallery 更友好一点。
gpus = tf.config.list_physical_devices("GPU")
if gpus:
 try:
 for gpu in gpus:
            tf.config.experimental.set_memory_growth(gpu, True)
 print("tensorflow will use experimental.set_memory_growth(True)")
 except RuntimeError as e:
 print("experimental.set_memory_growth option is not available: {}".format(e))

配置设置​

从参数开始,定义要运行的模型类型和稀疏。

# 要下载和运行的 transformer 模型的名称
name = "huggingface/prunebert-base-uncased-6-finepruned-w-distil-squad"
# 输入的 batches 数目
batch_size = 1
# 每个输入序列的长度。
seq_len = 128
# TVM 平台标识符。注意,可以通过设置 -mcpu 来实现最佳 CPU 性能
# 适合特定机器,还支持 CUDA 和 ROCm。
target = "llvm"
# 在哪个设备上运行,tvm.cpu() 或 tvm.cuda() 。
# 如果为 True,则将运行网络的稀疏变体,并进行 benchmark 测试。
measure_sparse = True
# 结构化稀疏块大小转换权重张量
# 进入。更改此参数可能会提高某些平台的速度。
bs_r = 1
# 对于除 PruneBert(95% 稀疏)以外的模型,此参数
# 确定生成的权重稀疏,值越大,稀疏越高,结果越快。
sparsity = 0.85

下载和转换 Transformers 模型​

下面从 transformers 模块获取一个模型,下载并转换为 TensorFlow graphdef,将该 graphdef 转换为可以优化和部署的 Relay 计算图。

def load_keras_model(module, name, seq_len, batch_size, report_runtime=True):
    model = module.from_pretrained(name)
    dummy_input = tf.keras.Input(shape=[seq_len], batch_size=batch_size, dtype="int32")
    dummy_out = model(dummy_input) # 通过 Keras 模型传播 shape。
 if report_runtime:
        np_input = np.random.uniform(size=[batch_size, seq_len], low=0, high=seq_len).astype(
 "int32"
 )
        start = time.time()
        repeats = 50
 for i in range(repeats):
            np_out = model(np_input)
        end = time.time()
 print("Keras Runtime: %f ms." % (1000 * ((end - start) / repeats)))
 return model

def convert_to_graphdef(model, batch_size, seq_len):
    model_func = tf.function(lambda x: model(x))
    input_dict = model._saved_model_inputs_spec
    input_spec = input_dict[list(input_dict.keys())[0]]
    model_func = model_func.get_concrete_function(
        tf.TensorSpec([batch_size, seq_len], input_spec.dtype)
 )
    frozen_func = convert_variables_to_constants_v2(model_func)
 return frozen_func.graph.as_graph_def()

def download_model(name, batch_size, seq_len):
 import transformers

    module = getattr(transformers, "TFBertForSequenceClassification")
    model = load_keras_model(module, name=name, batch_size=batch_size, seq_len=seq_len)
 return convert_to_graphdef(model, batch_size, seq_len)

转换为 Relay 计算图​

目前有很多工具可以获得正确格式的 transformers 模型,从而进行 Relay 转换。下面的函数将导入的计算图保存为 Relay 的 json 格式,这样就不必在每次运行此脚本时从 TensorFlow 重新导入了。

def import_graphdef(
    name,
    batch_size,
    seq_len,
    save_relay=True,
    relay_file="model.json",
    relay_params="model.params",
):
    abs_path = os.path.dirname(os.path.abspath(__file__))
    shape_dict = {"input_1": (batch_size, seq_len)}
    relay_file = ("%s_%d_%d_%s" % (name, batch_size, seq_len, relay_file)).replace("/", "_")
    relay_params = ("%s_%d_%d_%s" % (name, batch_size, seq_len, relay_params)).replace("/", "_")
 if os.path.exists(os.path.join(abs_path, relay_file)) and os.path.exists(
        os.path.join(abs_path, relay_params)
 ):
 with open(os.path.join(abs_path, relay_file), "r") as fi:
            mod = tvm.ir.load_json(fi.read())
 with open(os.path.join(abs_path, relay_params), "rb") as fi:
            params = relay.load_param_dict(fi.read())
 else:
        graph_def = download_model(name, batch_size, seq_len)

        mod, params = relay.frontend.from_tensorflow(graph_def, shape=shape_dict)

 if save_relay:
 with open(os.path.join(abs_path, relay_file), "w") as fo:
                fo.write(tvm.ir.save_json(mod))
 with open(os.path.join(abs_path, relay_params), "wb") as fo:
                fo.write(runtime.save_param_dict(params))

 return mod, dict(params.items()), shape_dict

运行密集计算图​

运行导入模型的默认版本。注意,即使权重是稀疏的,也不会看到任何加速,因为在这些密集(但大部分为零)张量上使用的是常规密集矩阵乘法,而非稀疏感知内核。

def run_relay_graph(mod, params, shape_dict, target, dev):
 with relay.build_config(opt_level=3):
        lib = relay.build(mod, target=target, params=params)
    input_shape = shape_dict["input_1"]
    dummy_data = np.random.uniform(size=input_shape, low=0, high=input_shape[1]).astype("int32")

    m = graph_executor.GraphModule(lib["default"](dev))
    m.set_input(0, dummy_data)
    m.run()
    tvm_output = m.get_output(0)

 print(m.benchmark(dev, repeat=5, number=5))
 return tvm_output

def run_dense(mod, params, shape_dict, target, dev):
 print("Dense Model Benchmark:")
 return run_relay_graph(mod, params, shape_dict, target, dev)

运行稀疏计算图​

接下来把计算图转换为稀疏表示,并在需要时生成假的稀疏权重。然后用与 dense 相同的 benchmark 测试脚本来测试速度!对计算图应用一些 Relay pass,从而利用稀疏。

首先用 simple_fc_transpose 将密集层的权重转置到参数中,便于矩阵乘法转换为稀疏版本。接下来应用 bsr_dense.convert 来识别所有可以稀疏的权重矩阵,并自动替换它们。

下面的 bsr_dense.convert 函数通过检查 sparse_threshold 百分比稀疏,识别模型中的哪些权重可以变得稀疏,并将这些权重转换为 Block Compressed Row Format (BSR) 。

BSR 本质上是一种对张量的 nonzero chunks 进行索引的表示,使算法可以轻松加载那些 nonzero chunks,并忽略张量的其余部分。一旦稀疏权重采用 BSR 格式,就会应用 relay.transform.DenseToSparse,实际上是用 relay.sparse_dense 函数来替换 relay.dense 操作,从而运行更快。

def random_bsr_matrix(M, N, BS_R, BS_C, density, dtype="float32"):
    Y = np.zeros((M, N), dtype=dtype)
 assert M % BS_R == 0
 assert N % BS_C == 0
    nnz = int(density * M * N)
    num_blocks = int(nnz / (BS_R * BS_C)) + 1
    candidate_blocks = np.asarray(list(itertools.product(range(0, M, BS_R), range(0, N, BS_C))))
 assert candidate_blocks.shape[0] == M // BS_R * N // BS_C
    chosen_blocks = candidate_blocks[
        np.random.choice(candidate_blocks.shape[0], size=num_blocks, replace=False)
 ]
 for i in range(len(chosen_blocks)):
        r, c = chosen_blocks[i]
        Y[r : r + BS_R, c : c + BS_C] = np.random.uniform(-0.1, 0.1, (BS_R, BS_C))
    s = sp.bsr_matrix(Y, blocksize=(BS_R, BS_C))
 assert s.data.shape == (num_blocks, BS_R, BS_C)
 assert s.data.size >= nnz
 assert s.indices.shape == (num_blocks,)
 assert s.indptr.shape == (M // BS_R + 1,)
 return s.todense()

def random_sparse_bert_params(func, params, density, BS_R, BS_C):
 def deepcopy(param_dic):
        ret = {}
 for k, v in param_dic.items():
            ret[k] = tvm.nd.array(v.numpy())
 return ret

    new_params = deepcopy(params)
    dense_weight_names = relay.analysis.sparse_dense._search_dense_op_weight(func)
 for item in dense_weight_names:
        name = str(item)
        shape = new_params[name].shape
 if shape[0] % BS_R == 0 and shape[1] % BS_C == 0:
            new_w = random_bsr_matrix(shape[0], shape[1], BS_R, BS_C, density)
            new_params[name] = tvm.nd.array(new_w)
 return new_params

def run_sparse(mod, params, shape_dict, target, dev, bs_r, sparsity, gen_weights):
    mod, params = ddo.simplify_fc_transpose.convert(mod["main"], params)
 if gen_weights:
        params = random_sparse_bert_params(mod, params, BS_R=bs_r, BS_C=1, density=1 - sparsity)
    mod, params = ddo.bsr_dense.convert(mod, params, (bs_r, 1), sparsity_threshold=0.8)
 print("Block Sparse Model with {blocksize}x1 blocks:".format(blocksize=bs_r))
 return run_relay_graph(mod, params, shape_dict, target, dev)

运行所有代码​

调用所有需要的函数,根据设置的参数对模型进行 benchmark 测试。注意,运行这个代码,首先需要取消最后一行的注释。

def benchmark():
    mod, params, shape_dict = import_graphdef(name, batch_size, seq_len)
    run_dense(mod, params, shape_dict, target, dev)
 if measure_sparse:
        gen_weights = "prune" not in name
        run_sparse(mod, params, shape_dict, target, dev, bs_r, sparsity, gen_weights)

# benchmark()

样本输出​

可参考下面在 AMD CPU 上运行的脚本输出,显示用稀疏模型可提高约 2.5 倍的速度。

# Dense Model Benchmark:
# Cannot find config for target=llvm, workload=('dense_nopack.x86', ('TENSOR', (1, 768), 'float32'), ('TENSOR', (2, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('dense_nopack.x86', ('TENSOR', (1, 768), 'float32'), ('TENSOR', (768, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('dense_nopack.x86', ('TENSOR', (128, 3072), 'float32'), ('TENSOR', (768, 3072), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('dense_nopack.x86', ('TENSOR', (128, 768), 'float32'), ('TENSOR', (3072, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('dense_nopack.x86', ('TENSOR', (128, 768), 'float32'), ('TENSOR', (768, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('batch_matmul.x86', ('TENSOR', (12, 128, 128), 'float32'), ('TENSOR', (12, 64, 128), 'float32')). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=llvm, workload=('batch_matmul.x86', ('TENSOR', (12, 128, 64), 'float32'), ('TENSOR', (12, 128, 64), 'float32')). A fallback configuration is used, which may bring great performance regression.
# Runtime:             165.26 ms           (12.83 ms)
# Block Sparse Model with 1x1 blocks:
# Runtime:             67.75 ms            (8.83 ms)

# Here is the output of this script on a GPU (GTX 1070) with the target "cuda -libs=cublas".
#
# Dense Model Benchmark:
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('dense_cublas.cuda', ('TENSOR', (1, 768), 'float32'), ('TENSOR', (2, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('dense_cublas.cuda', ('TENSOR', (1, 768), 'float32'), ('TENSOR', (768, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('dense_cublas.cuda', ('TENSOR', (128, 3072), 'float32'), ('TENSOR', (768, 3072), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('dense_cublas.cuda', ('TENSOR', (128, 768), 'float32'), ('TENSOR', (3072, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('dense_cublas.cuda', ('TENSOR', (128, 768), 'float32'), ('TENSOR', (768, 768), 'float32'), None, 'float32'). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('batch_matmul_cublas.cuda', ('TENSOR', (12, 128, 128), 'float32'), ('TENSOR', (12, 64, 128), 'float32'), (12, 128, 64)). A fallback configuration is used, which may bring great performance regression.
# Cannot find config for target=cuda -keys=cuda,gpu -libs=cublas -max_num_threads=1024 -thread_warp_size=32, workload=('batch_matmul_cublas.cuda', ('TENSOR', (12, 128, 64), 'float32'), ('TENSOR', (12, 128, 64), 'float32'), (12, 128, 128)). A fallback configuration is used, which may bring great performance regression.
# Runtime:             10.64 ms            (0.29 ms)
# Block Sparse Model with 1x1 blocks:
# Runtime:             6.46 ms             (0.05 ms)

下载 Python 源代码:deploy_sparse.py

下载 Jupyter Notebook:deploy_sparse.ipynb

2022年8月AI工程趋势:ONNX Runtime、模型量化与PyTorch部署实战 AI模型部署正从研究导向转向生产就绪,核心围绕模型轻量化、跨平台兼容性与推理性能优化展开。ONNX作为开放中间表示格式,联合PyTorch训练生态与ONNX Runtime多后端执行能力,构成当前主流部署三角;模型量化(如bitsandbytes的LLM.int8)已成上线前强制环节,显著降低显存占用与推理成本。技术价值体现在CPU/GPU/边缘设备统一支持、CI/CD中可验证的部署指标(如ORT延迟、量化精度损失),广泛应用于语音识别(Whisper)、大语言模型(LLaMA)等真实服务场景。本文聚焦20 阅读详情

相关推荐

AI推理优化实战:从模型压缩到服务化部署的开发者指南

模型推理是人工智能技术落地的关键环节,它指的是使用训练好的模型对新数据进行预测计算的过程。其核心原理在于模型的前向传播,通过优化计算图、内存访问和硬件适配来提升效率。推理优化的技术价值在于直接决定了AI应用的生产可行性,能显著降低服务延迟、提升吞吐量并控制计算成本。在应用场景上,无论是云端高并发服务还是边缘端实时处理,都依赖于高效的推理引擎。本文聚焦于模型压缩与推理服务化,深入探讨了量化、剪枝等模型瘦身技术,以及如何利用TensorRT、Triton Inference Server等工具构建稳定、高性能的

379

22|再探HuggingFace:一键部署自己的大模型

过去几讲里,我们一起为 AI 加上了语音能力。而且相对于大语言模型,语音识别和语音合成都有完全可以用于商业应用的开源模型。事实上,Huggingface 的火爆离不开他们开源的这个 Transformers 库。这个开源库里有数万个我们可以直接调用的模型。很多场景下,这个开源模型已经足够我们使用了。不过,在使用这些开源模型的过程中,你会发现大部分模型都需要一块不错的显卡。而如果回到我们更早使用过的开源大语言模型,就更是这样了。在课程里面,我们是通过用 Colab 免费的 GPU 资源来搞定的。

qq_37756660的博客 1万+

AI工具链降维时刻:ONNX默认化、Prompt结构化与QAT工程化

AI推理与生成技术正从模型参数竞赛转向工程落地效率竞争。ONNX Runtime成为Hugging Face默认后端,标志着模型部署进入‘去框架化’新阶段;prompt工程不再依赖语言直觉,而是遵循空间关系、材质反射率、光源参数三要素的物理映射逻辑;量化感知训练(QAT)借助TVM等工具链实现CLI级自动化,使INT8压缩从实验性操作变为DevOps标准环节。这些演进共同指向一个核心趋势:AI工业化的核心瓶颈已从算法创新转向工具链成熟度与工程确定性。本文聚焦2021年10月三个静默但关键的技术拐点,揭示其对

weixin_32238157的博客 272

再探HuggingFace:一键部署自己的大模型

过去几讲里,我们一起为AI加上了语音能力。而且相对于大语言模型,语音识别和语音合成都有完全可以用于商业应用的开源模型。事实上,Huggingface的火爆离不开他们开源的这个Transformers库。这个开源库里有数万个我们可以直接调用的模型。很多场景下,这个开源模型已经足够我们使用了。不过,在使用这些开源模型的过程中,你会发现大部分模型都需要一块不错的显卡。而如果回到我们更早使用过的开源大语言模型,就更是这样了。在课程里面,我们是通过用Colab免费的GPU资源来搞定的。

echohuangshihuxue的博客 2772

大模型高效推理实战指南:从量化压缩到服务部署的全栈优化

深度学习模型推理是AI应用落地的关键环节,其核心目标是在有限的计算资源下,实现低延迟、高吞吐的预测服务。其基本原理涉及计算图优化、内存管理与硬件指令调度。高效推理的技术价值在于,它能将前沿的模型能力转化为稳定、可扩展且经济可行的产品服务,是AI工程化的生命线。当前,量化与模型压缩已成为降低显存占用和加速计算的核心手段,而持续批处理与推测解码等技术则显著提升了服务端的资源利用率与响应速度。这些技术广泛应用于聊天机器人、内容生成、多模态理解等场景。本文聚焦于大语言模型、视觉语言模型及长上下文处理等热门领域,深入

weixin_34082854的博客 625

手机跑27B大模型:Gem ma 2端侧部署全链路实战

大语言模型端侧部署是AI落地的关键环节,其核心在于平衡模型能力、硬件资源与用户体验。不同于云端依赖算力堆叠,手机端需聚焦轻量化架构设计、硬件感知推理引擎与精细化内存管理。Gemma 2 27B凭借RMSNorm优化、Grouped-Query Attention和AWQ量化等关键技术,在骁龙8 Gen3等旗舰SoC上实现首token延迟<520ms、吞吐超15 token/s的稳定表现,成为当前中文场景下兼顾能力与可用性的标杆选择。本文深入解析从模型获取、INT4/AWQ量化、MLC-LLM推理引擎适配,到

weixin_34199405的博客 442

将Hugging Face模型下载到本地并部署为本地服务的步骤指南

下面我将分步骤讲解如何将Hugging Face模型下载到本地并进行部署,包括演示代码。

yuanpan的专栏 7855

小型语言模型SLM:面向边缘设备的智能引擎设计与落地实践

小型语言模型(SLM)并非参数缩减的大模型,而是为终端设备定制的语言智能基础设施。其核心在于以内存占用、推理延迟、功耗控制和部署简易性为刚性约束,通过混合架构(如SSM+CNN)、量化感知训练(QAT)与领域数据蒸馏等技术,在手机SoC、工业PLC、树莓派等资源受限场景实现‘足够好且绝对可靠’的语义理解与生成。相比LLM追求通用SOTA,SLM强调任务导向的工程适配——例如在ARM Cortex-A7芯片上以350mW功耗运行方言指令解析,在骁龙865平板达成320ms首Token延迟。真正可用的SLM,始

cuanku6549的博客 471

如何让huggingface模型运行速度起飞

首先调用接口的时候不要调用一次就加载一下模型,直接一开始就加载好。大家需要把pytorch换成GPU版本。其次能用GPU就不要cpu。

weixin_48262500的博客 2446

2018年深度学习技术栈演进:从PyTorch 1.0到BERT的工程化转折点

深度学习作为人工智能的核心技术,其发展经历了从理论探索到工程落地的关键转折。其核心原理是通过多层神经网络模拟人脑学习机制,从数据中自动提取特征表示。这一技术价值在于能够解决传统算法难以处理的复杂模式识别问题,如图像分类、自然语言处理和时间序列预测等。在应用场景上,深度学习已广泛应用于计算机视觉、语音识别、推荐系统等领域。2018年是深度学习技术栈演进的分水岭,PyTorch 1.0的发布统一了研发与生产工具链,确立了“动态开发、静态部署”的最佳实践;而BERT模型的提出则奠定了“预训练+微调”的范式,推动了

weixin_34310369的博客 429

AI学习指南HuggingFace篇-模型部署与推理

本文介绍了如何将Hugging Face模型部署为API并实现推理,探讨了模型部署的常见方法和优化技巧。通过使用Hugging Face Inference API或本地部署,开发者可以快速将模型应用于实际场景。推理优化技巧(如硬件加速、模型量化和多线程)能够显著提升模型性能,确保高效运行。希望本文能帮助读者掌握模型部署与推理的基本方法。

俞兆鹏的博客 649

大模型能在树莓派运行吗?揭秘轻量化部署的5个核心技术

揭秘大模型在树莓派运行的可行性,解析轻量化部署的5大核心技术。涵盖模型压缩、量化、推理优化等大模型边缘部署案例,适用于物联网与本地AI场景。提升效率降低成本,值得收藏。

LogicGap的博客 1088

揭开AI-OPS 的神秘面纱 第五讲 AI 模型服务层(开源方向)

揭开AI-OPS 的神秘面纱 第五讲 AI 模型服务层(开源方向)

ViniJack的博客 431

实测提速400%!Nebullvm量化编译技术让AI推理性能突破瓶颈

Nebullvm是一款专为大语言模型(LLM)打造的用户分析平台,其核心组件Nebullvm量化编译技术能够显著提升AI模型推理性能,帮助开发者轻松突破计算资源限制。本文将深入解析这项革命性技术的工作原理、实战效果和应用方法,让你快速掌握AI性能优化的核心秘诀。 ## 🔥 为什么AI推理速度如此重要? 在AI应用落地过程中,推理速度直接决定了用户体验和系统成本。想象一下:当用户使用AI聊天机

gitblog_00780的博客 983

Matlab结果性能评价---rms函数(计算矩阵、数组和向量元素均方根)

实例1:创建一个向量(正弦波)并计算其均方根值 实例2:创建一个二维矩阵并计算其均方根值 实例3:计算二维矩阵沿指定维度的均方根值 本例程配套完整源码下载 均方根(Root-Mean-Square Level): 向量x的均方根值为沿着指定的维度执行求和: 语法描述: y = rms(x)返回输入x的均方根值。如果x是行或列向量,y是实数值标量。对于大小尺寸大于1矩阵x,y包含沿x的第一个数组维度计算的均方根值。例如,如果x是N > 1的N*M矩阵,那么y是1*M行向量,对应x矩..

qq_32809093的博客 3万+

群晖NAS搭建Git Server避坑指南:从SSH配置到权限管理的完整流程

本文提供了一份详尽的群晖NAS搭建Git Server实战指南。文章从启用并安全配置SSH服务入手,深入解析了用户权限体系设计、SSH连接与仓库初始化、客户端SSH密钥配置等核心步骤,并提供了常见错误排查与生产环境加固方案,帮助开发者成功构建私有、安全的代码托管平台。

rock5的博客 420

Nebuly AI Speedster:深度学习模型推理加速全攻略

随着深度学习模型规模的不断扩大,推理成本已成为企业部署AI应用的主要瓶颈。传统的手动优化方法不仅耗时耗力,而且难以充分利用硬件潜力。Nebuly AI Speedster应运而生,通过自动化搜索最优加速方案,让AI推理成本降低变得简单高效。 **读完本文,你将掌握:** - Speedster核心架构与四大构建模块 - 五大主流框架的完整加速流程 - 性能基准测试与优化效果分析 - 生产环境部署...

gitblog_00869的博客 516

线上专利申请(超详细)| 签名确认

在【法人登录】页面点击【证书登录】按钮,弹出证书登录提示框,点击【确 认】按钮,进入到输入证书密码页面,点击【取消】按钮,取消本次操作。企业在提交申请时,需要增加签名,如使用企业账户点击提交,会弹出“法人、代理机构不能签名,请使用经办人签名”,这个时候就需要换个账号了。在需要签名时,将专利官网的登录方式点击法人登录,选择扫码登录,使用移动端经办人账户的扫一扫功能扫描登录。登录完成后,再点击签名,使用移动端扫一扫功能,扫描签名,输入证书号,确认签名,并提交。最后,祝大家的申请都成功!

weixin_62112323的博客 9114

DeepSeek-V4-Flash:高效能AI模型的本地部署与实战应用指南

在人工智能领域,模型蒸馏与知识提炼是构建高效小模型的核心技术,其原理是让轻量化的学生模型学习庞大教师模型的行为和内部表征。这项技术的价值在于,它能在保持核心能力的同时,大幅降低推理所需的计算资源和成本,实现降本增效。这直接推动了AI模型从追求参数规模向追求实用效率的转变,使其更易于部署和应用。在实际应用场景中,这种高效模型特别适合集成到开发环境,如VS Code,提供实时代码补全与建议,或部署为企业内部的AI中台,处理智能客服、内容创作等任务。本文聚焦的DeepSeek-V4-Flash,正是这一技术路径的

weixin_30520015的博客 570

手机流畅的秘密:拆解LPDDR5X在骁龙8 Gen2平台上的电源与信号完整性设计

本文深入解析了LPDDR5X内存与骁龙8 Gen2处理器在旗舰手机中的协同设计,重点探讨了0.5V超低电压下的电源完整性设计以及8.5Gbps高速传输中的信号完整性挑战。通过详细的电源树架构、关键器件选型和布线策略分析,揭示了如何实现高性能与低功耗的完美平衡,为手机流畅体验提供硬件保障。

weixin_30235225的博客 485

《缠中说禅108课》5:市场无须分析,只要看和干

喜欢吹牛皮的,在市场里最常见,例如一种以分析市场、吹牛皮为生的职业,叫什么股评、专家的。此类人不过是市场上的寄生虫,真正的猎手只会观察、操作,用嘴是打不了豺狼的。 市场就是一个狩猎场,首先你要成为一个好猎手,而一个猎手,首先要习惯于无言。如果真有什么真理,那真理也是无言的。可言说的,都不过是人类思想的分泌物,臭气熏天。真不可言说了,就无不可言,言而无言,是乃真言。 一个好的猎手,可以没有嘴巴,但一定会有一双不为外物所动的眼睛,在这眼睛下,一切如幻化般透明。要不被外物所动,则首先要不被自我所迷惑,其实..

BenRen1314的博客 802

AI应用性能优化全流程:从监控到部署的工程实践

在AI工程实践中,性能优化是一个贯穿模型全生命周期的系统工程,其核心在于建立可量化的度量体系与持续迭代的闭环。理解模型推理的底层原理,如计算图执行、张量运算与硬件加速,是优化的基础。其技术价值在于平衡模型效果与系统效率,直接关乎应用的用户体验、运营成本与可扩展性。典型的应用场景包括高并发在线服务、资源受限的边缘部署以及对响应延迟敏感的实时交互系统。本文聚焦于通过性能剖析、动态批处理与模型量化等关键技术,系统化地解决从数据预处理、模型推理到服务部署中的瓶颈问题,从而实现成本、延迟与吞吐量的整体优化。

weixin_30907935的博客 347

CP AUTOSAR标准之AUTOSAR OS(AUTOSAR_SWS_OS)(二)

AUTOSAR OS是一个Operating System,即操作系统。它最核心的功能是管理任务和事件的调度,不同任务间的同步流,并且提供监控和错误处理功能。或者用最简化理解就是一个函数调度器。

CoolBreeze的博客 655
上一篇: 首次!GPT-2赋能无线通信物理层,北大团队提出基于预训练LLM的信道预测方案
下一篇: 学术分享丨清华大学博士后李雨哲详解 Cell/Nature 子刊论文,探索基因组学的 AI 应用
HyperAI超神经
博客等级 码龄7年 8873粉丝 1753原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值