✅博主简介：擅长数据搜集与处理、建模仿真、程序设计、仿真代码、论文写作与指导，毕业论文、期刊论文经验交流。
✅成品或者定制，扫描文章底部微信二维码。
（1）基于敏感性分析的深度神经网络权重与激活值联合剪枝方法
深度神经网络模型通常具有庞大的参数量和计算量，直接部署于资源受限的边缘设备面临严峻挑战。模型压缩技术通过移除网络中的冗余参数和计算来降低资源需求，其中剪枝是最为直接有效的方法之一。传统的剪枝方法主要关注网络权重的稀疏化，但忽略了中间激活值同样存在大量冗余的事实。本研究提出了一种同时针对权重和激活值的联合剪枝方法，从模型准确率、压缩率和硬件执行效率三个维度进行综合优化。权重剪枝方面，本研究采用了基于聚类的模式剪枝策略。首先，通过对预训练模型的权重分布进行统计分析，识别出具有相似数值模式的权重组。然后，利用聚类算法将这些权重组归并为若干代表性模式，每个模式用其聚类中心的数值作为共享权重。这种模式剪枝方法相比传统的非结构化剪枝更加硬件友好，因为规则化的权重模式便于利用专用硬件的并行计算能力。激活值剪枝方面，本研究提出了基于稀疏行的剪枝算法。通过分析神经网络各层激活值的统计特性，发现许多激活值在经过激活函数后接近于零或呈现高度稀疏的特点。基于此观察，本研究设计了一种运行时激活值剪枝机制，在推理过程中动态跳过那些对最终输出贡献极小的激活计算。为了确定合理的剪枝阈值，本研究引入了基于敏感性分析的方法。具体而言，对网络的每一层分别进行不同程度的剪枝实验，记录模型准确率的变化曲线，据此评估各层对剪枝操作的敏感程度。敏感度低的层可以承受较激进的剪枝比例，而敏感度高的层则需要保守处理。通过这种层间差异化的剪枝策略，本研究实现了在保持模型准确率基本不变的前提下最大化压缩比例。实验结果表明，所提出的权重与激活值联合剪枝方法平均能够减少超过一半的存储空间占用，同时降低约六成的计算量，为边缘侧部署奠定了良好基础。
（2）面向剪枝量化联合压缩的阻变存储器神经网络执行引擎设计
阻变存储器交叉阵列结构能够利用欧姆定律和基尔霍夫电流定律在存储单元内原位完成矩阵向量乘法运算，是实现存内计算的理想硬件载体。然而，标准的交叉阵列结构难以有效支持经过剪枝和量化压缩后的神经网络模型，导致压缩算法带来的理论收益难以在硬件层面兑现。为此，本研究提出了面向剪枝量化联合压缩算法的阻变存储器神经网络执行引擎。首先，在算法层面，本研究设计了基于细粒度块感知的剪枝量化联合压缩方法。该方法将神经网络的权重矩阵划分为多个小尺寸的子块，在每个子块内部独立执行剪枝和量化操作。这种细粒度的分块策略使得压缩算法能够更好地适应权重分布的局部特性，同时便于映射到阻变存储器的物理单元上。量化方面，本研究采用了单比特或极低比特的量化精度，将权重值离散化为少数几个代表值，这样可以显著降低阻变存储器单元的编程复杂度和器件非理想性的影响。在硬件架构层面，本研究设计了一种可配置的混合操作单元执行引擎。该引擎包含多种规格的计算阵列，能够根据压缩后权重块的实际大小动态分配计算资源。对于稀疏度较高的权重块，引擎可以跳过零值对应的计算操作，从而节省功耗和时间。对于量化后的低精度权重，引擎采用查表方式快速获取量化值，避免了复杂的数模转换过程。此外，本研究还设计了专门的稀疏索引编码和地址生成单元，以高效支持压缩后模型的不规则访存模式。通过软硬件协同优化，所设计的执行引擎能够充分发挥剪枝量化联合压缩算法的优势，实验表明该方案相比直接映射稠密模型的基线方案在能效和吞吐率上均有显著提升。
（3）基于权重模式重用的高并行存内计算架构设计与流水线优化
尽管模型压缩技术能够减少神经网络的参数量，但现有的阻变存储器存内计算架构仍存在大量无效计算和重复存储的问题。深入分析发现，经过剪枝后的神经网络权重矩阵中存在大量重复出现的权重模式，如果能够识别并重用这些模式，就可以进一步压缩存储需求并减少冗余计算。本研究提出了面向细粒度权重模式重用策略的阻变存储器执行引擎，该引擎的核心组件包括重复权重模式感知的计算引擎和重复模式与操作单元的映射表。在执行引擎的预处理阶段，首先对压缩后的模型权重进行全局扫描，识别出所有独特的权重模式并建立模式库。每个独特模式只在阻变存储器中存储一份，其他相同模式的位置通过索引指向这份共享副本。这种基于模式重用的存储策略大幅降低了阻变存储器的空间占用，实验中平均节省了超过一半的存储资源。在计算过程中，当遇到重复的权重模式时，执行引擎可以直接复用之前计算过的中间结果，避免冗余的乘累加操作。为了充分利用上述优化策略带来的性能收益，本研究设计了一套完整的高并行存内计算架构。该架构包含多个并行工作的处理单元，每个处理单元负责神经网络特定层或特定通道的计算任务。为了提高流水线效率，本研究为每个处理单元设计了六级流水线结构，分别对应地址生成、数据读取、模式匹配、乘法计算、累加归约和结果写回六个阶段。流水线的各级之间通过寄存器进行数据传递，使得相邻指令能够重叠执行，隐藏访存和计算的延迟。此外，本研究采用异步执行的方式实现神经网络不同层之间的并行处理。
import numpy as np import torch import torch.nn as nn import torch.nn.functional as F from collections import defaultdict from sklearn.cluster import KMeans class SensitivityAnalyzer: def __init__(self, model, dataloader, criterion): self.model = model self.dataloader = dataloader self.criterion = criterion def compute_layer_sensitivity(self, layer_name, prune_ratios): sensitivities = [] original_weight = None for name, module in self.model.named_modules(): if name == layer_name and hasattr(module, 'weight'): original_weight = module.weight.data.clone() break if original_weight is None: return sensitivities baseline_acc = self._evaluate() for ratio in prune_ratios: mask = self._generate_prune_mask(original_weight, ratio) for name, module in self.model.named_modules(): if name == layer_name: module.weight.data = original_weight * mask pruned_acc = self._evaluate() sensitivities.append(baseline_acc - pruned_acc) for name, module in self.model.named_modules(): if name == layer_name: module.weight.data = original_weight.clone() return sensitivities def _generate_prune_mask(self, weight, ratio): threshold = np.percentile(np.abs(weight.cpu().numpy()), ratio * 100) return (torch.abs(weight) >= threshold).float() def _evaluate(self): self.model.eval() correct, total = 0, 0 with torch.no_grad(): for inputs, targets in self.dataloader: outputs = self.model(inputs) _, predicted = outputs.max(1) total += targets.size(0) correct += predicted.eq(targets).sum().item() return correct / total class PatternBasedPruner: def __init__(self, block_size=4, n_patterns=16): self.block_size = block_size self.n_patterns = n_patterns self.pattern_codebook = None def extract_patterns(self, weight_matrix): h, w = weight_matrix.shape patterns = [] positions = [] for i in range(0, h - self.block_size + 1, self.block_size): for j in range(0, w - self.block_size + 1, self.block_size): block = weight_matrix[i:i+self.block_size, j:j+self.block_size] patterns.append(block.flatten()) positions.append((i, j)) return np.array(patterns), positions def build_codebook(self, patterns): kmeans = KMeans(n_clusters=self.n_patterns, random_state=42) kmeans.fit(patterns) self.pattern_codebook = kmeans.cluster_centers_ return kmeans.labels_ def compress_weights(self, weight_matrix): patterns, positions = self.extract_patterns(weight_matrix.cpu().numpy()) labels = self.build_codebook(patterns) compressed = {'codebook': self.pattern_codebook, 'indices': labels, 'positions': positions} return compressed def decompress_weights(self, compressed, original_shape): reconstructed = np.zeros(original_shape) for idx, (i, j) in enumerate(compressed['positions']): pattern_idx = compressed['indices'][idx] block = compressed['codebook'][pattern_idx].reshape(self.block_size, self.block_size) reconstructed[i:i+self.block_size, j:j+self.block_size] = block return reconstructed class ActivationPruner(nn.Module): def __init__(self, threshold=0.01): super(ActivationPruner, self).__init__() self.threshold = threshold self.sparsity_stats = [] def forward(self, x): mask = (torch.abs(x) > self.threshold).float() self.sparsity_stats.append(1 - mask.mean().item()) return x * mask class ReRAMCrossbarSimulator: def __init__(self, rows, cols, bits=4): self.rows = rows self.cols = cols self.bits = bits self.conductance_matrix = np.zeros((rows, cols)) self.max_conductance = 1e-4 self.min_conductance = 1e-6 def program_weights(self, weights): normalized = (weights - weights.min()) / (weights.max() - weights.min() + 1e-8) self.conductance_matrix = self.min_conductance + normalized * (self.max_conductance - self.min_conductance) def compute_mvm(self, input_vector): voltage = input_vector * 0.2 current = np.dot(voltage, self.conductance_matrix) return current class PatternReuseEngine: def __init__(self, crossbar_size=128): self.crossbar_size = crossbar_size self.pattern_cache = {} self.mapping_table = {} def detect_patterns(self, weight_matrix, block_size=8): unique_patterns = {} pattern_map = [] h, w = weight_matrix.shape for i in range(0, h, block_size): row_patterns = [] for j in range(0, w, block_size): block = weight_matrix[i:i+block_size, j:j+block_size] block_hash = hash(block.tobytes()) if block_hash not in unique_patterns: unique_patterns[block_hash] = block.copy() row_patterns.append(block_hash) pattern_map.append(row_patterns) return unique_patterns, pattern_map def allocate_crossbars(self, unique_patterns): allocated = {} crossbar_id = 0 offset = 0 for pattern_hash, pattern in unique_patterns.items(): if offset + pattern.shape[0] > self.crossbar_size: crossbar_id += 1 offset = 0 allocated[pattern_hash] = (crossbar_id, offset) offset += pattern.shape[0] return allocated class PIMComputeUnit: def __init__(self, unit_id, pipeline_stages=6): self.unit_id = unit_id self.pipeline_stages = pipeline_stages self.pipeline_registers = [None] * pipeline_stages self.crossbar = ReRAMCrossbarSimulator(128, 128) self.cycle_count = 0 def execute_layer(self, inputs, weights): self.crossbar.program_weights(weights) outputs = [] for inp in inputs: self._advance_pipeline() result = self.crossbar.compute_mvm(inp) outputs.append(result) return np.array(outputs) def _advance_pipeline(self): for i in range(self.pipeline_stages - 1, 0, -1): self.pipeline_registers[i] = self.pipeline_registers[i-1] self.pipeline_registers[0] = None self.cycle_count += 1 class EdgeDNNAccelerator: def __init__(self, num_units=4): self.compute_units = [PIMComputeUnit(i) for i in range(num_units)] self.pruner = PatternBasedPruner() self.pattern_engine = PatternReuseEngine() def deploy_model(self, model_weights): compressed_layers = [] for layer_weight in model_weights: compressed = self.pruner.compress_weights(torch.tensor(layer_weight)) compressed_layers.append(compressed) return compressed_layers def run_inference(self, inputs, compressed_model): current = inputs for layer_idx, layer_data in enumerate(compressed_model): weights = self.pruner.decompress_weights(layer_data, (128, 128)) unit = self.compute_units[layer_idx % len(self.compute_units)] current = unit.execute_layer(current, weights) current = np.maximum(current, 0) return current如有问题，可以直接沟通
👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇
